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/devel-api/actors/actor-devel.h>
 427
 428 #include <dali/public-api/math/matrix.h>
 429 #include <dali/public-api/math/matrix3.h>
 430 #include <dali/public-api/math/viewport.h>
 431 #include <dali/public-api/object/property-key.h>
 432 #include <dali/devel-api/object/csharp-type-info.h>
 433 #include <dali/devel-api/object/csharp-type-registry.h>
 434
 435 #include <dali/public-api/adaptor-framework/timer.h>
 436 #include <dali/public-api/adaptor-framework/window.h>
 437 #include <dali/public-api/adaptor-framework/style-change.h>
 438 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 439 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 440
 441 #include <dali/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446
 447 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 448 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 449 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 454 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 455
 456 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 457 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 458 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 459
 460 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 461
 462 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 463
 464 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 465
 466 // add here SWIG version check
 467
 468 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 469 // disable Swig-dependent warnings
 470
 471 // 'identifier1' has C-linkage specified,
 472 // but returns UDT 'identifier2' which is incompatible with C
 473 #pragma warning(disable: 4190)
 474
 475 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 476 #pragma warning(disable: 4800)
 477
 478 // debug info too long etc etc
 479 #pragma warning(disable: 4786)
 480 #endif
 481
 482
 483 #include <stdexcept>
 484
 485
 486 #include <string>
 487
 488
 489 #include <vector>
 490 #include <algorithm>
 491 #include <stdexcept>
 492
 493
 494 #include <map>
 495 #include <algorithm>
 496 #include <stdexcept>
 497
 498
 499 #include <utility>
 500
 501
 502 typedef float floatp;
 503
 504 SWIGINTERN floatp *new_floatp(){
 505   return new float();
 506 }
 507 SWIGINTERN void delete_floatp(floatp *self){
 508   if (self) delete self;
 509 }
 510 SWIGINTERN void floatp_assign(floatp *self,float value){
 511   *self = value;
 512 }
 513 SWIGINTERN float floatp_value(floatp *self){
 514   return *self;
 515 }
 516 SWIGINTERN float *floatp_cast(floatp *self){
 517   return self;
 518 }
 519 SWIGINTERN floatp *floatp_frompointer(float *t){
 520   return (floatp *) t;
 521 }
 522
 523 typedef int intp;
 524
 525 SWIGINTERN intp *new_intp(){
 526   return new int();
 527 }
 528 SWIGINTERN void delete_intp(intp *self){
 529   if (self) delete self;
 530 }
 531 SWIGINTERN void intp_assign(intp *self,int value){
 532   *self = value;
 533 }
 534 SWIGINTERN int intp_value(intp *self){
 535   return *self;
 536 }
 537 SWIGINTERN int *intp_cast(intp *self){
 538   return self;
 539 }
 540 SWIGINTERN intp *intp_frompointer(int *t){
 541   return (intp *) t;
 542 }
 543
 544 typedef double doublep;
 545
 546 SWIGINTERN doublep *new_doublep(){
 547   return new double();
 548 }
 549 SWIGINTERN void delete_doublep(doublep *self){
 550   if (self) delete self;
 551 }
 552 SWIGINTERN void doublep_assign(doublep *self,double value){
 553   *self = value;
 554 }
 555 SWIGINTERN double doublep_value(doublep *self){
 556   return *self;
 557 }
 558 SWIGINTERN double *doublep_cast(doublep *self){
 559   return self;
 560 }
 561 SWIGINTERN doublep *doublep_frompointer(double *t){
 562   return (doublep *) t;
 563 }
 564
 565 typedef unsigned int uintp;
 566
 567 SWIGINTERN uintp *new_uintp(){
 568   return new unsigned int();
 569 }
 570 SWIGINTERN void delete_uintp(uintp *self){
 571   if (self) delete self;
 572 }
 573 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 574   *self = value;
 575 }
 576 SWIGINTERN unsigned int uintp_value(uintp *self){
 577   return *self;
 578 }
 579 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 580   return self;
 581 }
 582 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 583   return (uintp *) t;
 584 }
 585
 586 typedef unsigned short ushortp;
 587
 588 SWIGINTERN ushortp *new_ushortp(){
 589   return new unsigned short();
 590 }
 591 SWIGINTERN void delete_ushortp(ushortp *self){
 592   if (self) delete self;
 593 }
 594 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 595   *self = value;
 596 }
 597 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 598   return *self;
 599 }
 600 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 601   return self;
 602 }
 603 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 604   return (ushortp *) t;
 605 }
 606
 607 unsigned int int_to_uint(int x) {
 608    return (unsigned int) x;
 609 }
 610
 611
 612 using namespace Dali;
 613 using namespace Dali::Toolkit;
 614
 615 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 616
 617      // C++ code. DALi uses Handle <-> Body design pattern.
 618      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 619      // Handles in DALi can be converted into a boolean type
 620      // to check if the handle has a valid body attached to it.
 621      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 622      if( *self )
 623      {
 624        return true;
 625      }
 626      else
 627      {
 628        return false;
 629      }
 630     }
 631 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 632
 633      // C++ code. Check if two handles reference the same implemtion
 634      if( *self == rhs)
 635      {
 636        return true;
 637      }
 638      else
 639      {
 640        return false;
 641      }
 642     }
 643 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 644      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 645    }
 646 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){
 647      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 648    }
 649 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 650         std::vector< Dali::TouchPoint >* pv = 0;
 651         if (capacity >= 0) {
 652           pv = new std::vector< Dali::TouchPoint >();
 653           pv->reserve(capacity);
 654        } else {
 655           throw std::out_of_range("capacity");
 656        }
 657        return pv;
 658       }
 659 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 660         if (index>=0 && index<(int)self->size())
 661           return (*self)[index];
 662         else
 663           throw std::out_of_range("index");
 664       }
 665 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 666         if (index>=0 && index<(int)self->size())
 667           return (*self)[index];
 668         else
 669           throw std::out_of_range("index");
 670       }
 671 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 672         if (index>=0 && index<(int)self->size())
 673           (*self)[index] = val;
 674         else
 675           throw std::out_of_range("index");
 676       }
 677 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 678         self->insert(self->end(), values.begin(), values.end());
 679       }
 680 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 681         if (index < 0)
 682           throw std::out_of_range("index");
 683         if (count < 0)
 684           throw std::out_of_range("count");
 685         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 686           throw std::invalid_argument("invalid range");
 687         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 688       }
 689 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 690         if (index>=0 && index<(int)self->size()+1)
 691           self->insert(self->begin()+index, x);
 692         else
 693           throw std::out_of_range("index");
 694       }
 695 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 696         if (index>=0 && index<(int)self->size()+1)
 697           self->insert(self->begin()+index, values.begin(), values.end());
 698         else
 699           throw std::out_of_range("index");
 700       }
 701 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 702         if (index>=0 && index<(int)self->size())
 703           self->erase(self->begin() + index);
 704         else
 705           throw std::out_of_range("index");
 706       }
 707 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 708         if (index < 0)
 709           throw std::out_of_range("index");
 710         if (count < 0)
 711           throw std::out_of_range("count");
 712         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 713           throw std::invalid_argument("invalid range");
 714         self->erase(self->begin()+index, self->begin()+index+count);
 715       }
 716 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 717         if (count < 0)
 718           throw std::out_of_range("count");
 719         return new std::vector< Dali::TouchPoint >(count, value);
 720       }
 721 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 722         std::reverse(self->begin(), self->end());
 723       }
 724 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 725         if (index < 0)
 726           throw std::out_of_range("index");
 727         if (count < 0)
 728           throw std::out_of_range("count");
 729         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 730           throw std::invalid_argument("invalid range");
 731         std::reverse(self->begin()+index, self->begin()+index+count);
 732       }
 733 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 734         if (index < 0)
 735           throw std::out_of_range("index");
 736         if (index+values.size() > self->size())
 737           throw std::out_of_range("index");
 738         std::copy(values.begin(), values.end(), self->begin()+index);
 739       }
 740 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 741          return self->Empty();
 742       }
 743 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 744         return self->GetConnectionCount();
 745       }
 746 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 747           self->Connect( func );
 748       }
 749 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 750           self->Disconnect( func );
 751       }
 752 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 753           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 754 /*@SWIG@*/ self->Emit( arg );
 755       }
 756 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 757          return self->Empty();
 758       }
 759 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 760         return self->GetConnectionCount();
 761       }
 762 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 763           self->Connect( func );
 764       }
 765 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 766           self->Disconnect( func );
 767       }
 768 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 769           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 770 /*@SWIG@*/ self->Emit( arg );
 771       }
 772 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 773          return self->Empty();
 774       }
 775 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){
 776         return self->GetConnectionCount();
 777       }
 778 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 *)){
 779           self->Connect( func );
 780       }
 781 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 *)){
 782           self->Disconnect( func );
 783       }
 784 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){
 785           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 786 /*@SWIG@*/ self->Emit( arg );
 787       }
 788 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 789          return self->Empty();
 790       }
 791 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 792         return self->GetConnectionCount();
 793       }
 794 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 795           self->Connect( func );
 796       }
 797 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 798           self->Disconnect( func );
 799       }
 800 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 801           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 802 /*@SWIG@*/ self->Emit( arg );
 803       }
 804 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 805          return self->Empty();
 806       }
 807 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 808         return self->GetConnectionCount();
 809       }
 810 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 811           self->Connect( func );
 812       }
 813 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 814           self->Disconnect( func );
 815       }
 816 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 817           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 818 /*@SWIG@*/ self->Emit( arg );
 819       }
 820 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){
 821          return self->Empty();
 822       }
 823 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){
 824         return self->GetConnectionCount();
 825       }
 826 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 &)){
 827         self->Connect( func );
 828       }
 829 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 &)){
 830         self->Disconnect( func );
 831       }
 832 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){
 833         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 834 /*@SWIG@*/ self->Emit( arg1, arg2 );
 835       }
 836 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){
 837          return self->Empty();
 838       }
 839 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){
 840         return self->GetConnectionCount();
 841       }
 842 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 &)){
 843         self->Connect( func );
 844       }
 845 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 &)){
 846         self->Disconnect( func );
 847       }
 848 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){
 849         return self->Emit( arg1, arg2 );
 850       }
 851 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){
 852          return self->Empty();
 853       }
 854 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){
 855         return self->GetConnectionCount();
 856       }
 857 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 &)){
 858         self->Connect( func );
 859       }
 860 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 &)){
 861         self->Disconnect( func );
 862       }
 863 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){
 864         return self->Emit( arg1, arg2 );
 865       }
 866 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){
 867          return self->Empty();
 868       }
 869 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){
 870         return self->GetConnectionCount();
 871       }
 872 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 &)){
 873         self->Connect( func );
 874       }
 875 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 &)){
 876         self->Disconnect( func );
 877       }
 878 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){
 879         return self->Emit( arg1, arg2 );
 880       }
 881 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 882          return self->Empty();
 883       }
 884 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 885         return self->GetConnectionCount();
 886       }
 887 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 888           self->Connect( func );
 889       }
 890 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 891           self->Disconnect( func );
 892       }
 893 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 894           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 895 /*@SWIG@*/ self->Emit( arg );
 896       }
 897 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 898          return self->Empty();
 899       }
 900 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){
 901         return self->GetConnectionCount();
 902       }
 903 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 &)){
 904           self->Connect( func );
 905       }
 906 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 &)){
 907           self->Disconnect( func );
 908       }
 909 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){
 910           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 911 /*@SWIG@*/ self->Emit( arg );
 912       }
 913 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 914          return self->Empty();
 915       }
 916 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){
 917         return self->GetConnectionCount();
 918       }
 919 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 &)){
 920           self->Connect( func );
 921       }
 922 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 &)){
 923           self->Disconnect( func );
 924       }
 925 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){
 926           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 927 /*@SWIG@*/ self->Emit( arg );
 928       }
 929 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 930          return self->Empty();
 931       }
 932 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){
 933         return self->GetConnectionCount();
 934       }
 935 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 &)){
 936           self->Connect( func );
 937       }
 938 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 &)){
 939           self->Disconnect( func );
 940       }
 941 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){
 942           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 943 /*@SWIG@*/ self->Emit( arg );
 944       }
 945 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){
 946          return self->Empty();
 947       }
 948 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){
 949         return self->GetConnectionCount();
 950       }
 951 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 &)){
 952         self->Connect( func );
 953       }
 954 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 &)){
 955         self->Disconnect( func );
 956       }
 957 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){
 958         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 959 /*@SWIG@*/ self->Emit( arg1, arg2 );
 960       }
 961 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){
 962          return self->Empty();
 963       }
 964 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){
 965         return self->GetConnectionCount();
 966       }
 967 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 &)){
 968         self->Connect( func );
 969       }
 970 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 &)){
 971         self->Disconnect( func );
 972       }
 973 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){
 974         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 975 /*@SWIG@*/ self->Emit( arg1, arg2 );
 976       }
 977 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){
 978          return self->Empty();
 979       }
 980 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){
 981         return self->GetConnectionCount();
 982       }
 983 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 &)){
 984         self->Connect( func );
 985       }
 986 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 &)){
 987         self->Disconnect( func );
 988       }
 989 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){
 990         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 991 /*@SWIG@*/ self->Emit( arg1, arg2 );
 992       }
 993 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
 994          return self->Empty();
 995       }
 996 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
 997         return self->GetConnectionCount();
 998       }
 999 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1000           self->Connect( func );
1001       }
1002 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1003           self->Disconnect( func );
1004       }
1005 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1006           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1007 /*@SWIG@*/ self->Emit( arg );
1008       }
1009 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1010          return self->Empty();
1011       }
1012 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1013         return self->GetConnectionCount();
1014       }
1015 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1016           self->Connect( func );
1017       }
1018 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1019           self->Disconnect( func );
1020       }
1021 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1022           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1023 /*@SWIG@*/ self->Emit( arg );
1024       }
1025
1026   // keep argcs and argv so they're always available to DALi
1027   int argC = 1;
1028   char **argV = NULL;
1029
1030 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1031          return self->Empty();
1032       }
1033 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1034         return self->GetConnectionCount();
1035       }
1036 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1037           self->Connect( func );
1038       }
1039 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1040           self->Disconnect( func );
1041       }
1042 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1043           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1044 /*@SWIG@*/ self->Emit( arg );
1045       }
1046 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1047          return self->Empty();
1048       }
1049 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){
1050         return self->GetConnectionCount();
1051       }
1052 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 *)){
1053         self->Connect( func );
1054       }
1055 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 *)){
1056         self->Disconnect( func );
1057       }
1058 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){
1059         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1060 /*@SWIG@*/ self->Emit( arg1, arg2 );
1061       }
1062 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1063          return self->Empty();
1064       }
1065 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1066         return self->GetConnectionCount();
1067       }
1068 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1069           self->Connect( func );
1070       }
1071 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1072           self->Disconnect( func );
1073       }
1074 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1075           return self->Emit();
1076       }
1077 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1078         std::vector< unsigned int >* pv = 0;
1079         if (capacity >= 0) {
1080           pv = new std::vector< unsigned int >();
1081           pv->reserve(capacity);
1082        } else {
1083           throw std::out_of_range("capacity");
1084        }
1085        return pv;
1086       }
1087 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1088         if (index>=0 && index<(int)self->size())
1089           return (*self)[index];
1090         else
1091           throw std::out_of_range("index");
1092       }
1093 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1094         if (index>=0 && index<(int)self->size())
1095           return (*self)[index];
1096         else
1097           throw std::out_of_range("index");
1098       }
1099 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1100         if (index>=0 && index<(int)self->size())
1101           (*self)[index] = val;
1102         else
1103           throw std::out_of_range("index");
1104       }
1105 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1106         self->insert(self->end(), values.begin(), values.end());
1107       }
1108 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1109         if (index < 0)
1110           throw std::out_of_range("index");
1111         if (count < 0)
1112           throw std::out_of_range("count");
1113         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1114           throw std::invalid_argument("invalid range");
1115         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1116       }
1117 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1118         if (index>=0 && index<(int)self->size()+1)
1119           self->insert(self->begin()+index, x);
1120         else
1121           throw std::out_of_range("index");
1122       }
1123 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1124         if (index>=0 && index<(int)self->size()+1)
1125           self->insert(self->begin()+index, values.begin(), values.end());
1126         else
1127           throw std::out_of_range("index");
1128       }
1129 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1130         if (index>=0 && index<(int)self->size())
1131           self->erase(self->begin() + index);
1132         else
1133           throw std::out_of_range("index");
1134       }
1135 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(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         self->erase(self->begin()+index, self->begin()+index+count);
1143       }
1144 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1145         if (count < 0)
1146           throw std::out_of_range("count");
1147         return new std::vector< unsigned int >(count, value);
1148       }
1149 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1150         std::reverse(self->begin(), self->end());
1151       }
1152 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1153         if (index < 0)
1154           throw std::out_of_range("index");
1155         if (count < 0)
1156           throw std::out_of_range("count");
1157         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1158           throw std::invalid_argument("invalid range");
1159         std::reverse(self->begin()+index, self->begin()+index+count);
1160       }
1161 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1162         if (index < 0)
1163           throw std::out_of_range("index");
1164         if (index+values.size() > self->size())
1165           throw std::out_of_range("index");
1166         std::copy(values.begin(), values.end(), self->begin()+index);
1167       }
1168 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1169         return std::find(self->begin(), self->end(), value) != self->end();
1170       }
1171 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1172         int index = -1;
1173         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1174         if (it != self->end())
1175           index = (int)(it - self->begin());
1176         return index;
1177       }
1178 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1179         int index = -1;
1180         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1181         if (rit != self->rend())
1182           index = (int)(self->rend() - 1 - rit);
1183         return index;
1184       }
1185 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1186         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1187         if (it != self->end()) {
1188           self->erase(it);
1189           return true;
1190         }
1191         return false;
1192       }
1193 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){
1194         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1195         if (capacity >= 0) {
1196           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1197           pv->reserve(capacity);
1198        } else {
1199           throw std::out_of_range("capacity");
1200        }
1201        return pv;
1202       }
1203 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){
1204         if (index>=0 && index<(int)self->size())
1205           return (*self)[index];
1206         else
1207           throw std::out_of_range("index");
1208       }
1209 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){
1210         if (index>=0 && index<(int)self->size())
1211           return (*self)[index];
1212         else
1213           throw std::out_of_range("index");
1214       }
1215 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){
1216         if (index>=0 && index<(int)self->size())
1217           (*self)[index] = val;
1218         else
1219           throw std::out_of_range("index");
1220       }
1221 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){
1222         self->insert(self->end(), values.begin(), values.end());
1223       }
1224 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){
1225         if (index < 0)
1226           throw std::out_of_range("index");
1227         if (count < 0)
1228           throw std::out_of_range("count");
1229         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1230           throw std::invalid_argument("invalid range");
1231         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1232       }
1233 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){
1234         if (index>=0 && index<(int)self->size()+1)
1235           self->insert(self->begin()+index, x);
1236         else
1237           throw std::out_of_range("index");
1238       }
1239 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){
1240         if (index>=0 && index<(int)self->size()+1)
1241           self->insert(self->begin()+index, values.begin(), values.end());
1242         else
1243           throw std::out_of_range("index");
1244       }
1245 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){
1246         if (index>=0 && index<(int)self->size())
1247           self->erase(self->begin() + index);
1248         else
1249           throw std::out_of_range("index");
1250       }
1251 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){
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         self->erase(self->begin()+index, self->begin()+index+count);
1259       }
1260 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){
1261         if (count < 0)
1262           throw std::out_of_range("count");
1263         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1264       }
1265 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){
1266         std::reverse(self->begin(), self->end());
1267       }
1268 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){
1269         if (index < 0)
1270           throw std::out_of_range("index");
1271         if (count < 0)
1272           throw std::out_of_range("count");
1273         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1274           throw std::invalid_argument("invalid range");
1275         std::reverse(self->begin()+index, self->begin()+index+count);
1276       }
1277 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){
1278         if (index < 0)
1279           throw std::out_of_range("index");
1280         if (index+values.size() > self->size())
1281           throw std::out_of_range("index");
1282         std::copy(values.begin(), values.end(), self->begin()+index);
1283       }
1284 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1285         std::vector< Dali::Actor >* pv = 0;
1286         if (capacity >= 0) {
1287           pv = new std::vector< Dali::Actor >();
1288           pv->reserve(capacity);
1289        } else {
1290           throw std::out_of_range("capacity");
1291        }
1292        return pv;
1293       }
1294 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1295         if (index>=0 && index<(int)self->size())
1296           return (*self)[index];
1297         else
1298           throw std::out_of_range("index");
1299       }
1300 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1301         if (index>=0 && index<(int)self->size())
1302           return (*self)[index];
1303         else
1304           throw std::out_of_range("index");
1305       }
1306 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1307         if (index>=0 && index<(int)self->size())
1308           (*self)[index] = val;
1309         else
1310           throw std::out_of_range("index");
1311       }
1312 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1313         self->insert(self->end(), values.begin(), values.end());
1314       }
1315 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1316         if (index < 0)
1317           throw std::out_of_range("index");
1318         if (count < 0)
1319           throw std::out_of_range("count");
1320         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1321           throw std::invalid_argument("invalid range");
1322         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1323       }
1324 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1325         if (index>=0 && index<(int)self->size()+1)
1326           self->insert(self->begin()+index, x);
1327         else
1328           throw std::out_of_range("index");
1329       }
1330 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1331         if (index>=0 && index<(int)self->size()+1)
1332           self->insert(self->begin()+index, values.begin(), values.end());
1333         else
1334           throw std::out_of_range("index");
1335       }
1336 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1337         if (index>=0 && index<(int)self->size())
1338           self->erase(self->begin() + index);
1339         else
1340           throw std::out_of_range("index");
1341       }
1342 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(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         self->erase(self->begin()+index, self->begin()+index+count);
1350       }
1351 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1352         if (count < 0)
1353           throw std::out_of_range("count");
1354         return new std::vector< Dali::Actor >(count, value);
1355       }
1356 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1357         std::reverse(self->begin(), self->end());
1358       }
1359 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1360         if (index < 0)
1361           throw std::out_of_range("index");
1362         if (count < 0)
1363           throw std::out_of_range("count");
1364         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1365           throw std::invalid_argument("invalid range");
1366         std::reverse(self->begin()+index, self->begin()+index+count);
1367       }
1368 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1369         if (index < 0)
1370           throw std::out_of_range("index");
1371         if (index+values.size() > self->size())
1372           throw std::out_of_range("index");
1373         std::copy(values.begin(), values.end(), self->begin()+index);
1374       }
1375 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1376          return self->Empty();
1377       }
1378 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1379         return self->GetConnectionCount();
1380       }
1381 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 &)){
1382           self->Connect( func );
1383       }
1384 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 &)){
1385           self->Disconnect( func );
1386       }
1387 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){
1388           return self->Emit( arg );
1389       }
1390 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){
1391          return self->Empty();
1392       }
1393 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){
1394         return self->GetConnectionCount();
1395       }
1396 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)){
1397         self->Connect( func );
1398       }
1399 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)){
1400         self->Disconnect( func );
1401       }
1402 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){
1403         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1404 /*@SWIG@*/ self->Emit( arg1, arg2 );
1405       }
1406 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1407          return self->Empty();
1408       }
1409 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){
1410         return self->GetConnectionCount();
1411       }
1412 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)){
1413         self->Connect( func );
1414       }
1415 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)){
1416         self->Disconnect( func );
1417       }
1418 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){
1419         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1420 /*@SWIG@*/ self->Emit( arg1, arg2 );
1421       }
1422 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1423          return self->Empty();
1424       }
1425 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1426         return self->GetConnectionCount();
1427       }
1428 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)){
1429         self->Connect( func );
1430       }
1431 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)){
1432         self->Disconnect( func );
1433       }
1434 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){
1435         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1436 /*@SWIG@*/ self->Emit( arg1, arg2 );
1437       }
1438 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){
1439          return self->Empty();
1440       }
1441 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){
1442         return self->GetConnectionCount();
1443       }
1444 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)){
1445         self->Connect( func );
1446       }
1447 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)){
1448         self->Disconnect( func );
1449       }
1450 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){
1451         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1452 /*@SWIG@*/ self->Emit( arg1, arg2 );
1453       }
1454 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1455          return self->Empty();
1456       }
1457 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1458         return self->GetConnectionCount();
1459       }
1460 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)){
1461           self->Connect( func );
1462       }
1463 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)){
1464           self->Disconnect( func );
1465       }
1466 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1467           return self->Emit( arg );
1468       }
1469 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1470          return self->Empty();
1471       }
1472 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1473         return self->GetConnectionCount();
1474       }
1475 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)){
1476           self->Connect( func );
1477       }
1478 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)){
1479           self->Disconnect( func );
1480       }
1481 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1482           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1483 /*@SWIG@*/ self->Emit( arg );
1484       }
1485 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){
1486          return self->Empty();
1487       }
1488 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){
1489         return self->GetConnectionCount();
1490       }
1491 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)){
1492           return self->Connect( func );
1493       }
1494 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)){
1495           self->Disconnect( func );
1496       }
1497 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){
1498           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1499 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1500       }
1501 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1502          return self->Empty();
1503       }
1504 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1505         return self->GetConnectionCount();
1506       }
1507 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)){
1508           self->Connect( func );
1509       }
1510 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)){
1511           self->Disconnect( func );
1512       }
1513 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1514           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1515 /*@SWIG@*/ self->Emit( arg );
1516       }
1517 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1518          return self->Empty();
1519       }
1520 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1521         return self->GetConnectionCount();
1522       }
1523 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1524           return self->Connect( func );
1525       }
1526 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1527           self->Disconnect( func );
1528       }
1529 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1530           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1531 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1532       }
1533 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){
1534          return self->Empty();
1535       }
1536 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){
1537         return self->GetConnectionCount();
1538       }
1539 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 &)){
1540           self->Connect( func );
1541       }
1542 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 &)){
1543           self->Disconnect( func );
1544       }
1545 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){
1546           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1547 /*@SWIG@*/ self->Emit( arg );
1548       }
1549 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1550          return self->Empty();
1551       }
1552 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){
1553         return self->GetConnectionCount();
1554       }
1555 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 &)){
1556           self->Connect( func );
1557       }
1558 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 &)){
1559           self->Disconnect( func );
1560       }
1561 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){
1562           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1563 /*@SWIG@*/ self->Emit( arg );
1564       }
1565 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1566          return self->Empty();
1567       }
1568 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1569         return self->GetConnectionCount();
1570       }
1571 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)){
1572           self->Connect( func );
1573       }
1574 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)){
1575           self->Disconnect( func );
1576       }
1577 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1578           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1579 /*@SWIG@*/ self->Emit( arg );
1580       }
1581 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1582          return self->Empty();
1583       }
1584 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1585         return self->GetConnectionCount();
1586       }
1587 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)){
1588           self->Connect( func );
1589       }
1590 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)){
1591           self->Disconnect( func );
1592       }
1593 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1594           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1595 /*@SWIG@*/ self->Emit( arg );
1596       }
1597 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){
1598          return self->Empty();
1599       }
1600 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){
1601         return self->GetConnectionCount();
1602       }
1603 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 &)){
1604         self->Connect( func );
1605       }
1606 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 &)){
1607         self->Disconnect( func );
1608       }
1609 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){
1610         return self->Emit( arg1, arg2 );
1611       }
1612 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1613          return self->Empty();
1614       }
1615 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1616         return self->GetConnectionCount();
1617       }
1618 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)){
1619           self->Connect( func );
1620       }
1621 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)){
1622           self->Disconnect( func );
1623       }
1624 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1625           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1626 /*@SWIG@*/ self->Emit( arg );
1627       }
1628 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1629          return self->Empty();
1630       }
1631 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1632         return self->GetConnectionCount();
1633       }
1634 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 &)){
1635           self->Connect( func );
1636       }
1637 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 &)){
1638           self->Disconnect( func );
1639       }
1640 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){
1641           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1642 /*@SWIG@*/ self->Emit( arg );
1643       }
1644 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1645          return self->Empty();
1646       }
1647 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){
1648         return self->GetConnectionCount();
1649       }
1650 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)){
1651         self->Connect( func );
1652       }
1653 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)){
1654         self->Disconnect( func );
1655       }
1656 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){
1657         return self->Emit( arg1, arg2 );
1658       }
1659 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1660          return self->Empty();
1661       }
1662 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){
1663         return self->GetConnectionCount();
1664       }
1665 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)){
1666         self->Connect( func );
1667       }
1668 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)){
1669         self->Disconnect( func );
1670       }
1671 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){
1672         return self->Emit( arg1, arg2 );
1673       }
1674
1675
1676 /* ---------------------------------------------------
1677  * C++ director class methods
1678  * --------------------------------------------------- */
1679
1680 #include "dali_wrap.h"
1681
1682 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1683   swig_init_callbacks();
1684 }
1685
1686 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1687
1688 }
1689
1690
1691 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1692   int jdepth  ;
1693
1694   if (!swig_callbackOnStageConnection) {
1695     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1696     return;
1697   } else {
1698     jdepth = depth;
1699     swig_callbackOnStageConnection(jdepth);
1700   }
1701 }
1702
1703 void SwigDirector_ViewImpl::OnStageDisconnection() {
1704   if (!swig_callbackOnStageDisconnection) {
1705     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1706     return;
1707   } else {
1708     swig_callbackOnStageDisconnection();
1709   }
1710 }
1711
1712 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1713   void * jchild = 0 ;
1714
1715   if (!swig_callbackOnChildAdd) {
1716     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1717     return;
1718   } else {
1719     jchild = (Dali::Actor *) &child;
1720     swig_callbackOnChildAdd(jchild);
1721   }
1722 }
1723
1724 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1725   void * jchild = 0 ;
1726
1727   if (!swig_callbackOnChildRemove) {
1728     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1729     return;
1730   } else {
1731     jchild = (Dali::Actor *) &child;
1732     swig_callbackOnChildRemove(jchild);
1733   }
1734 }
1735
1736 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1737   int jindex  ;
1738   void * jpropertyValue  ;
1739
1740   if (!swig_callbackOnPropertySet) {
1741     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1742     return;
1743   } else {
1744     jindex = index;
1745     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1746     swig_callbackOnPropertySet(jindex, jpropertyValue);
1747   }
1748 }
1749
1750 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1751   void * jtargetSize = 0 ;
1752
1753   if (!swig_callbackOnSizeSet) {
1754     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1755     return;
1756   } else {
1757     jtargetSize = (Dali::Vector3 *) &targetSize;
1758     swig_callbackOnSizeSet(jtargetSize);
1759   }
1760 }
1761
1762 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1763   void * janimation = 0 ;
1764   void * jtargetSize = 0 ;
1765
1766   if (!swig_callbackOnSizeAnimation) {
1767     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1768     return;
1769   } else {
1770     janimation = (Dali::Animation *) &animation;
1771     jtargetSize = (Dali::Vector3 *) &targetSize;
1772     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1773   }
1774 }
1775
1776 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1777   bool c_result = SwigValueInit< bool >() ;
1778   unsigned int jresult = 0 ;
1779   void * jarg0 = 0 ;
1780
1781   if (!swig_callbackOnTouchEvent) {
1782     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1783   } else {
1784     jarg0 = (Dali::TouchEvent *) &event;
1785     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1786     c_result = jresult ? true : false;
1787   }
1788   return c_result;
1789 }
1790
1791 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1792   bool c_result = SwigValueInit< bool >() ;
1793   unsigned int jresult = 0 ;
1794   void * jarg0 = 0 ;
1795
1796   if (!swig_callbackOnHoverEvent) {
1797     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1798   } else {
1799     jarg0 = (Dali::HoverEvent *) &event;
1800     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1801     c_result = jresult ? true : false;
1802   }
1803   return c_result;
1804 }
1805
1806 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1807   bool c_result = SwigValueInit< bool >() ;
1808   unsigned int jresult = 0 ;
1809   void * jarg0 = 0 ;
1810
1811   if (!swig_callbackOnKeyEvent) {
1812     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1813   } else {
1814     jarg0 = (Dali::KeyEvent *) &event;
1815     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1816     c_result = jresult ? true : false;
1817   }
1818   return c_result;
1819 }
1820
1821 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1822   bool c_result = SwigValueInit< bool >() ;
1823   unsigned int jresult = 0 ;
1824   void * jarg0 = 0 ;
1825
1826   if (!swig_callbackOnWheelEvent) {
1827     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1828   } else {
1829     jarg0 = (Dali::WheelEvent *) &event;
1830     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1831     c_result = jresult ? true : false;
1832   }
1833   return c_result;
1834 }
1835
1836 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1837   void * jsize = 0 ;
1838   void * jcontainer = 0 ;
1839
1840   if (!swig_callbackOnRelayout) {
1841     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1842     return;
1843   } else {
1844     jsize = (Dali::Vector2 *) &size;
1845     jcontainer = (Dali::RelayoutContainer *) &container;
1846     swig_callbackOnRelayout(jsize, jcontainer);
1847   }
1848 }
1849
1850 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1851   int jpolicy  ;
1852   int jdimension  ;
1853
1854   if (!swig_callbackOnSetResizePolicy) {
1855     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1856     return;
1857   } else {
1858     jpolicy = (int)policy;
1859     jdimension = (int)dimension;
1860     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1861   }
1862 }
1863
1864 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1865   Dali::Vector3 c_result ;
1866   void * jresult = 0 ;
1867
1868   if (!swig_callbackGetNaturalSize) {
1869     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1870   } else {
1871     jresult = (void *) swig_callbackGetNaturalSize();
1872     if (!jresult) {
1873       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1874       return c_result;
1875     }
1876     c_result = *(Dali::Vector3 *)jresult;
1877   }
1878   return c_result;
1879 }
1880
1881 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1882   float c_result = SwigValueInit< float >() ;
1883   float jresult = 0 ;
1884   void * jchild = 0 ;
1885   int jdimension  ;
1886
1887   if (!swig_callbackCalculateChildSize) {
1888     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1889   } else {
1890     jchild = (Dali::Actor *) &child;
1891     jdimension = (int)dimension;
1892     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1893     c_result = (float)jresult;
1894   }
1895   return c_result;
1896 }
1897
1898 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1899   float c_result = SwigValueInit< float >() ;
1900   float jresult = 0 ;
1901   float jwidth  ;
1902
1903   if (!swig_callbackGetHeightForWidth) {
1904     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1905   } else {
1906     jwidth = width;
1907     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1908     c_result = (float)jresult;
1909   }
1910   return c_result;
1911 }
1912
1913 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1914   float c_result = SwigValueInit< float >() ;
1915   float jresult = 0 ;
1916   float jheight  ;
1917
1918   if (!swig_callbackGetWidthForHeight) {
1919     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1920   } else {
1921     jheight = height;
1922     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1923     c_result = (float)jresult;
1924   }
1925   return c_result;
1926 }
1927
1928 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1929   bool c_result = SwigValueInit< bool >() ;
1930   unsigned int jresult = 0 ;
1931   int jdimension  ;
1932
1933   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1934     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1935   } else {
1936     jdimension = (int)dimension;
1937     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1938     c_result = jresult ? true : false;
1939   }
1940   return c_result;
1941 }
1942
1943 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1944   int jdimension  ;
1945
1946   if (!swig_callbackOnCalculateRelayoutSize) {
1947     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1948     return;
1949   } else {
1950     jdimension = (int)dimension;
1951     swig_callbackOnCalculateRelayoutSize(jdimension);
1952   }
1953 }
1954
1955 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1956   float jsize  ;
1957   int jdimension  ;
1958
1959   if (!swig_callbackOnLayoutNegotiated) {
1960     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1961     return;
1962   } else {
1963     jsize = size;
1964     jdimension = (int)dimension;
1965     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1966   }
1967 }
1968
1969 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1970   return Dali::CustomActorImpl::GetExtension();
1971 }
1972
1973 void SwigDirector_ViewImpl::OnInitialize() {
1974   if (!swig_callbackOnInitialize) {
1975     Dali::Toolkit::Internal::Control::OnInitialize();
1976     return;
1977   } else {
1978     swig_callbackOnInitialize();
1979   }
1980 }
1981
1982 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1983   void * jchild = 0 ;
1984
1985   if (!swig_callbackOnControlChildAdd) {
1986     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1987     return;
1988   } else {
1989     jchild = (Dali::Actor *) &child;
1990     swig_callbackOnControlChildAdd(jchild);
1991   }
1992 }
1993
1994 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1995   void * jchild = 0 ;
1996
1997   if (!swig_callbackOnControlChildRemove) {
1998     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1999     return;
2000   } else {
2001     jchild = (Dali::Actor *) &child;
2002     swig_callbackOnControlChildRemove(jchild);
2003   }
2004 }
2005
2006 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2007   void * jstyleManager  ;
2008   int jchange  ;
2009
2010   if (!swig_callbackOnStyleChange) {
2011     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2012     return;
2013   } else {
2014     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2015     jchange = (int)change;
2016     swig_callbackOnStyleChange(jstyleManager, jchange);
2017   }
2018 }
2019
2020 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2021   bool c_result = SwigValueInit< bool >() ;
2022   unsigned int jresult = 0 ;
2023
2024   if (!swig_callbackOnAccessibilityActivated) {
2025     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2026   } else {
2027     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2028     c_result = jresult ? true : false;
2029   }
2030   return c_result;
2031 }
2032
2033 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2034   bool c_result = SwigValueInit< bool >() ;
2035   unsigned int jresult = 0 ;
2036   void * jgesture  ;
2037
2038   if (!swig_callbackOnAccessibilityPan) {
2039     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2040   } else {
2041     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2042     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2043     c_result = jresult ? true : false;
2044   }
2045   return c_result;
2046 }
2047
2048 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2049   bool c_result = SwigValueInit< bool >() ;
2050   unsigned int jresult = 0 ;
2051   void * jtouchEvent = 0 ;
2052
2053   if (!swig_callbackOnAccessibilityTouch) {
2054     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2055   } else {
2056     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2057     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2058     c_result = jresult ? true : false;
2059   }
2060   return c_result;
2061 }
2062
2063 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2064   bool c_result = SwigValueInit< bool >() ;
2065   unsigned int jresult = 0 ;
2066   unsigned int jisIncrease  ;
2067
2068   if (!swig_callbackOnAccessibilityValueChange) {
2069     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2070   } else {
2071     jisIncrease = isIncrease;
2072     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2073     c_result = jresult ? true : false;
2074   }
2075   return c_result;
2076 }
2077
2078 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2079   bool c_result = SwigValueInit< bool >() ;
2080   unsigned int jresult = 0 ;
2081
2082   if (!swig_callbackOnAccessibilityZoom) {
2083     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2084   } else {
2085     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2086     c_result = jresult ? true : false;
2087   }
2088   return c_result;
2089 }
2090
2091 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2092   if (!swig_callbackOnKeyInputFocusGained) {
2093     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2094     return;
2095   } else {
2096     swig_callbackOnKeyInputFocusGained();
2097   }
2098 }
2099
2100 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2101   if (!swig_callbackOnKeyInputFocusLost) {
2102     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2103     return;
2104   } else {
2105     swig_callbackOnKeyInputFocusLost();
2106   }
2107 }
2108
2109 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2110   Dali::Actor c_result ;
2111   void * jresult = 0 ;
2112   void * jcurrentFocusedActor  ;
2113   int jdirection  ;
2114   unsigned int jloopEnabled  ;
2115
2116   if (!swig_callbackGetNextKeyboardFocusableActor) {
2117     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2118   } else {
2119     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2120     jdirection = (int)direction;
2121     jloopEnabled = loopEnabled;
2122     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2123     if (!jresult) {
2124       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2125       return c_result;
2126     }
2127     c_result = *(Dali::Actor *)jresult;
2128   }
2129   return c_result;
2130 }
2131
2132 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2133   void * jcommitedFocusableActor  ;
2134
2135   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2136     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2137     return;
2138   } else {
2139     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2140     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2141   }
2142 }
2143
2144 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2145   bool c_result = SwigValueInit< bool >() ;
2146   unsigned int jresult = 0 ;
2147
2148   if (!swig_callbackOnKeyboardEnter) {
2149     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2150   } else {
2151     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2152     c_result = jresult ? true : false;
2153   }
2154   return c_result;
2155 }
2156
2157 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2158   void * jpinch = 0 ;
2159
2160   if (!swig_callbackOnPinch) {
2161     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2162     return;
2163   } else {
2164     jpinch = (Dali::PinchGesture *) &pinch;
2165     swig_callbackOnPinch(jpinch);
2166   }
2167 }
2168
2169 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2170   void * jpan = 0 ;
2171
2172   if (!swig_callbackOnPan) {
2173     Dali::Toolkit::Internal::Control::OnPan(pan);
2174     return;
2175   } else {
2176     jpan = (Dali::PanGesture *) &pan;
2177     swig_callbackOnPan(jpan);
2178   }
2179 }
2180
2181 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2182   void * jtap = 0 ;
2183
2184   if (!swig_callbackOnTap) {
2185     Dali::Toolkit::Internal::Control::OnTap(tap);
2186     return;
2187   } else {
2188     jtap = (Dali::TapGesture *) &tap;
2189     swig_callbackOnTap(jtap);
2190   }
2191 }
2192
2193 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2194   void * jlongPress = 0 ;
2195
2196   if (!swig_callbackOnLongPress) {
2197     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2198     return;
2199   } else {
2200     jlongPress = (Dali::LongPressGesture *) &longPress;
2201     swig_callbackOnLongPress(jlongPress);
2202   }
2203 }
2204
2205 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2206   void * jslotObserver = 0 ;
2207   void * jcallback = 0 ;
2208
2209   if (!swig_callbackSignalConnected) {
2210     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2211     return;
2212   } else {
2213     jslotObserver = (void *) slotObserver;
2214     jcallback = (void *) callback;
2215     swig_callbackSignalConnected(jslotObserver, jcallback);
2216   }
2217 }
2218
2219 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2220   void * jslotObserver = 0 ;
2221   void * jcallback = 0 ;
2222
2223   if (!swig_callbackSignalDisconnected) {
2224     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2225     return;
2226   } else {
2227     jslotObserver = (void *) slotObserver;
2228     jcallback = (void *) callback;
2229     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2230   }
2231 }
2232
2233 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2234   return Dali::Toolkit::Internal::Control::GetControlExtension();
2235 }
2236
2237 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) {
2238   swig_callbackOnStageConnection = callbackOnStageConnection;
2239   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2240   swig_callbackOnChildAdd = callbackOnChildAdd;
2241   swig_callbackOnChildRemove = callbackOnChildRemove;
2242   swig_callbackOnPropertySet = callbackOnPropertySet;
2243   swig_callbackOnSizeSet = callbackOnSizeSet;
2244   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2245   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2246   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2247   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2248   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2249   swig_callbackOnRelayout = callbackOnRelayout;
2250   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2251   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2252   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2253   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2254   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2255   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2256   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2257   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2258   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2259   swig_callbackOnInitialize = callbackOnInitialize;
2260   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2261   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2262   swig_callbackOnStyleChange = callbackOnStyleChange;
2263   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2264   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2265   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2266   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2267   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2268   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2269   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2270   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2271   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2272   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2273   swig_callbackOnPinch = callbackOnPinch;
2274   swig_callbackOnPan = callbackOnPan;
2275   swig_callbackOnTap = callbackOnTap;
2276   swig_callbackOnLongPress = callbackOnLongPress;
2277   swig_callbackSignalConnected = callbackSignalConnected;
2278   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2279 }
2280
2281 void SwigDirector_ViewImpl::swig_init_callbacks() {
2282   swig_callbackOnStageConnection = 0;
2283   swig_callbackOnStageDisconnection = 0;
2284   swig_callbackOnChildAdd = 0;
2285   swig_callbackOnChildRemove = 0;
2286   swig_callbackOnPropertySet = 0;
2287   swig_callbackOnSizeSet = 0;
2288   swig_callbackOnSizeAnimation = 0;
2289   swig_callbackOnTouchEvent = 0;
2290   swig_callbackOnHoverEvent = 0;
2291   swig_callbackOnKeyEvent = 0;
2292   swig_callbackOnWheelEvent = 0;
2293   swig_callbackOnRelayout = 0;
2294   swig_callbackOnSetResizePolicy = 0;
2295   swig_callbackGetNaturalSize = 0;
2296   swig_callbackCalculateChildSize = 0;
2297   swig_callbackGetHeightForWidth = 0;
2298   swig_callbackGetWidthForHeight = 0;
2299   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2300   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2301   swig_callbackOnCalculateRelayoutSize = 0;
2302   swig_callbackOnLayoutNegotiated = 0;
2303   swig_callbackOnInitialize = 0;
2304   swig_callbackOnControlChildAdd = 0;
2305   swig_callbackOnControlChildRemove = 0;
2306   swig_callbackOnStyleChange = 0;
2307   swig_callbackOnAccessibilityActivated = 0;
2308   swig_callbackOnAccessibilityPan = 0;
2309   swig_callbackOnAccessibilityTouch = 0;
2310   swig_callbackOnAccessibilityValueChange = 0;
2311   swig_callbackOnAccessibilityZoom = 0;
2312   swig_callbackOnKeyInputFocusGained = 0;
2313   swig_callbackOnKeyInputFocusLost = 0;
2314   swig_callbackGetNextKeyboardFocusableActor = 0;
2315   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2316   swig_callbackOnKeyboardEnter = 0;
2317   swig_callbackOnPinch = 0;
2318   swig_callbackOnPan = 0;
2319   swig_callbackOnTap = 0;
2320   swig_callbackOnLongPress = 0;
2321   swig_callbackSignalConnected = 0;
2322   swig_callbackSignalDisconnected = 0;
2323 }
2324
2325 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2326   swig_init_callbacks();
2327 }
2328
2329 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2330
2331 }
2332
2333
2334 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2335   unsigned int c_result = SwigValueInit< unsigned int >() ;
2336   unsigned int jresult = 0 ;
2337
2338   if (!swig_callbackGetNumberOfItems) {
2339     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2340   } else {
2341     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2342     c_result = (unsigned int)jresult;
2343   }
2344   return c_result;
2345 }
2346
2347 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2348   Dali::Actor c_result ;
2349   void * jresult = 0 ;
2350   unsigned int jitemId  ;
2351
2352   if (!swig_callbackNewItem) {
2353     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2354   } else {
2355     jitemId = itemId;
2356     jresult = (void *) swig_callbackNewItem(jitemId);
2357     if (!jresult) {
2358       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2359       return c_result;
2360     }
2361     c_result = *(Dali::Actor *)jresult;
2362   }
2363   return c_result;
2364 }
2365
2366 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2367   unsigned int jitemId  ;
2368   void * jactor  ;
2369
2370   if (!swig_callbackItemReleased) {
2371     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2372     return;
2373   } else {
2374     jitemId = itemId;
2375     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2376     swig_callbackItemReleased(jitemId, jactor);
2377   }
2378 }
2379
2380 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2381   return Dali::Toolkit::ItemFactory::GetExtension();
2382 }
2383
2384 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2385   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2386   swig_callbackNewItem = callbackNewItem;
2387   swig_callbackItemReleased = callbackItemReleased;
2388 }
2389
2390 void SwigDirector_ItemFactory::swig_init_callbacks() {
2391   swig_callbackGetNumberOfItems = 0;
2392   swig_callbackNewItem = 0;
2393   swig_callbackItemReleased = 0;
2394 }
2395
2396
2397 #ifdef __cplusplus
2398 extern "C" {
2399 #endif
2400
2401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2402   void * jresult ;
2403   floatp *result = 0 ;
2404
2405   {
2406     try {
2407       result = (floatp *)new_floatp();
2408     } catch (std::out_of_range& e) {
2409       {
2410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2411       };
2412     } catch (std::exception& e) {
2413       {
2414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2415       };
2416     } catch (...) {
2417       {
2418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2419       };
2420     }
2421   }
2422   jresult = (void *)result;
2423   return jresult;
2424 }
2425
2426
2427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2428   floatp *arg1 = (floatp *) 0 ;
2429
2430   arg1 = (floatp *)jarg1;
2431   {
2432     try {
2433       delete_floatp(arg1);
2434     } catch (std::out_of_range& e) {
2435       {
2436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2437       };
2438     } catch (std::exception& e) {
2439       {
2440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2441       };
2442     } catch (...) {
2443       {
2444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2445       };
2446     }
2447   }
2448 }
2449
2450
2451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2452   floatp *arg1 = (floatp *) 0 ;
2453   float arg2 ;
2454
2455   arg1 = (floatp *)jarg1;
2456   arg2 = (float)jarg2;
2457   {
2458     try {
2459       floatp_assign(arg1,arg2);
2460     } catch (std::out_of_range& e) {
2461       {
2462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2463       };
2464     } catch (std::exception& e) {
2465       {
2466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2467       };
2468     } catch (...) {
2469       {
2470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2471       };
2472     }
2473   }
2474 }
2475
2476
2477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2478   float jresult ;
2479   floatp *arg1 = (floatp *) 0 ;
2480   float result;
2481
2482   arg1 = (floatp *)jarg1;
2483   {
2484     try {
2485       result = (float)floatp_value(arg1);
2486     } catch (std::out_of_range& e) {
2487       {
2488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2489       };
2490     } catch (std::exception& e) {
2491       {
2492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2493       };
2494     } catch (...) {
2495       {
2496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2497       };
2498     }
2499   }
2500   jresult = result;
2501   return jresult;
2502 }
2503
2504
2505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2506   void * jresult ;
2507   floatp *arg1 = (floatp *) 0 ;
2508   float *result = 0 ;
2509
2510   arg1 = (floatp *)jarg1;
2511   {
2512     try {
2513       result = (float *)floatp_cast(arg1);
2514     } catch (std::out_of_range& e) {
2515       {
2516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2517       };
2518     } catch (std::exception& e) {
2519       {
2520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2521       };
2522     } catch (...) {
2523       {
2524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2525       };
2526     }
2527   }
2528   jresult = (void *)result;
2529   return jresult;
2530 }
2531
2532
2533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2534   void * jresult ;
2535   float *arg1 = (float *) 0 ;
2536   floatp *result = 0 ;
2537
2538   arg1 = (float *)jarg1;
2539   {
2540     try {
2541       result = (floatp *)floatp_frompointer(arg1);
2542     } catch (std::out_of_range& e) {
2543       {
2544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2545       };
2546     } catch (std::exception& e) {
2547       {
2548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2549       };
2550     } catch (...) {
2551       {
2552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2553       };
2554     }
2555   }
2556   jresult = (void *)result;
2557   return jresult;
2558 }
2559
2560
2561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2562   void * jresult ;
2563   intp *result = 0 ;
2564
2565   {
2566     try {
2567       result = (intp *)new_intp();
2568     } catch (std::out_of_range& e) {
2569       {
2570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2571       };
2572     } catch (std::exception& e) {
2573       {
2574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2575       };
2576     } catch (...) {
2577       {
2578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2579       };
2580     }
2581   }
2582   jresult = (void *)result;
2583   return jresult;
2584 }
2585
2586
2587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2588   intp *arg1 = (intp *) 0 ;
2589
2590   arg1 = (intp *)jarg1;
2591   {
2592     try {
2593       delete_intp(arg1);
2594     } catch (std::out_of_range& e) {
2595       {
2596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2597       };
2598     } catch (std::exception& e) {
2599       {
2600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2601       };
2602     } catch (...) {
2603       {
2604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2605       };
2606     }
2607   }
2608 }
2609
2610
2611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2612   intp *arg1 = (intp *) 0 ;
2613   int arg2 ;
2614
2615   arg1 = (intp *)jarg1;
2616   arg2 = (int)jarg2;
2617   {
2618     try {
2619       intp_assign(arg1,arg2);
2620     } catch (std::out_of_range& e) {
2621       {
2622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2623       };
2624     } catch (std::exception& e) {
2625       {
2626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2627       };
2628     } catch (...) {
2629       {
2630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2631       };
2632     }
2633   }
2634 }
2635
2636
2637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2638   int jresult ;
2639   intp *arg1 = (intp *) 0 ;
2640   int result;
2641
2642   arg1 = (intp *)jarg1;
2643   {
2644     try {
2645       result = (int)intp_value(arg1);
2646     } catch (std::out_of_range& e) {
2647       {
2648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2649       };
2650     } catch (std::exception& e) {
2651       {
2652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2653       };
2654     } catch (...) {
2655       {
2656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2657       };
2658     }
2659   }
2660   jresult = result;
2661   return jresult;
2662 }
2663
2664
2665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2666   void * jresult ;
2667   intp *arg1 = (intp *) 0 ;
2668   int *result = 0 ;
2669
2670   arg1 = (intp *)jarg1;
2671   {
2672     try {
2673       result = (int *)intp_cast(arg1);
2674     } catch (std::out_of_range& e) {
2675       {
2676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2677       };
2678     } catch (std::exception& e) {
2679       {
2680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2681       };
2682     } catch (...) {
2683       {
2684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2685       };
2686     }
2687   }
2688   jresult = (void *)result;
2689   return jresult;
2690 }
2691
2692
2693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2694   void * jresult ;
2695   int *arg1 = (int *) 0 ;
2696   intp *result = 0 ;
2697
2698   arg1 = (int *)jarg1;
2699   {
2700     try {
2701       result = (intp *)intp_frompointer(arg1);
2702     } catch (std::out_of_range& e) {
2703       {
2704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2705       };
2706     } catch (std::exception& e) {
2707       {
2708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2709       };
2710     } catch (...) {
2711       {
2712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2713       };
2714     }
2715   }
2716   jresult = (void *)result;
2717   return jresult;
2718 }
2719
2720
2721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2722   void * jresult ;
2723   doublep *result = 0 ;
2724
2725   {
2726     try {
2727       result = (doublep *)new_doublep();
2728     } catch (std::out_of_range& e) {
2729       {
2730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2731       };
2732     } catch (std::exception& e) {
2733       {
2734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2735       };
2736     } catch (...) {
2737       {
2738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2739       };
2740     }
2741   }
2742   jresult = (void *)result;
2743   return jresult;
2744 }
2745
2746
2747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2748   doublep *arg1 = (doublep *) 0 ;
2749
2750   arg1 = (doublep *)jarg1;
2751   {
2752     try {
2753       delete_doublep(arg1);
2754     } catch (std::out_of_range& e) {
2755       {
2756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2757       };
2758     } catch (std::exception& e) {
2759       {
2760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2761       };
2762     } catch (...) {
2763       {
2764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2765       };
2766     }
2767   }
2768 }
2769
2770
2771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2772   doublep *arg1 = (doublep *) 0 ;
2773   double arg2 ;
2774
2775   arg1 = (doublep *)jarg1;
2776   arg2 = (double)jarg2;
2777   {
2778     try {
2779       doublep_assign(arg1,arg2);
2780     } catch (std::out_of_range& e) {
2781       {
2782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2783       };
2784     } catch (std::exception& e) {
2785       {
2786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2787       };
2788     } catch (...) {
2789       {
2790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2791       };
2792     }
2793   }
2794 }
2795
2796
2797 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2798   double jresult ;
2799   doublep *arg1 = (doublep *) 0 ;
2800   double result;
2801
2802   arg1 = (doublep *)jarg1;
2803   {
2804     try {
2805       result = (double)doublep_value(arg1);
2806     } catch (std::out_of_range& e) {
2807       {
2808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2809       };
2810     } catch (std::exception& e) {
2811       {
2812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2813       };
2814     } catch (...) {
2815       {
2816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2817       };
2818     }
2819   }
2820   jresult = result;
2821   return jresult;
2822 }
2823
2824
2825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2826   void * jresult ;
2827   doublep *arg1 = (doublep *) 0 ;
2828   double *result = 0 ;
2829
2830   arg1 = (doublep *)jarg1;
2831   {
2832     try {
2833       result = (double *)doublep_cast(arg1);
2834     } catch (std::out_of_range& e) {
2835       {
2836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2837       };
2838     } catch (std::exception& e) {
2839       {
2840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2841       };
2842     } catch (...) {
2843       {
2844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2845       };
2846     }
2847   }
2848   jresult = (void *)result;
2849   return jresult;
2850 }
2851
2852
2853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2854   void * jresult ;
2855   double *arg1 = (double *) 0 ;
2856   doublep *result = 0 ;
2857
2858   arg1 = (double *)jarg1;
2859   {
2860     try {
2861       result = (doublep *)doublep_frompointer(arg1);
2862     } catch (std::out_of_range& e) {
2863       {
2864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2865       };
2866     } catch (std::exception& e) {
2867       {
2868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2869       };
2870     } catch (...) {
2871       {
2872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2873       };
2874     }
2875   }
2876   jresult = (void *)result;
2877   return jresult;
2878 }
2879
2880
2881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2882   void * jresult ;
2883   uintp *result = 0 ;
2884
2885   {
2886     try {
2887       result = (uintp *)new_uintp();
2888     } catch (std::out_of_range& e) {
2889       {
2890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2891       };
2892     } catch (std::exception& e) {
2893       {
2894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2895       };
2896     } catch (...) {
2897       {
2898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2899       };
2900     }
2901   }
2902   jresult = (void *)result;
2903   return jresult;
2904 }
2905
2906
2907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2908   uintp *arg1 = (uintp *) 0 ;
2909
2910   arg1 = (uintp *)jarg1;
2911   {
2912     try {
2913       delete_uintp(arg1);
2914     } catch (std::out_of_range& e) {
2915       {
2916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2917       };
2918     } catch (std::exception& e) {
2919       {
2920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2921       };
2922     } catch (...) {
2923       {
2924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2925       };
2926     }
2927   }
2928 }
2929
2930
2931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2932   uintp *arg1 = (uintp *) 0 ;
2933   unsigned int arg2 ;
2934
2935   arg1 = (uintp *)jarg1;
2936   arg2 = (unsigned int)jarg2;
2937   {
2938     try {
2939       uintp_assign(arg1,arg2);
2940     } catch (std::out_of_range& e) {
2941       {
2942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2943       };
2944     } catch (std::exception& e) {
2945       {
2946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2947       };
2948     } catch (...) {
2949       {
2950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2951       };
2952     }
2953   }
2954 }
2955
2956
2957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2958   unsigned int jresult ;
2959   uintp *arg1 = (uintp *) 0 ;
2960   unsigned int result;
2961
2962   arg1 = (uintp *)jarg1;
2963   {
2964     try {
2965       result = (unsigned int)uintp_value(arg1);
2966     } catch (std::out_of_range& e) {
2967       {
2968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2969       };
2970     } catch (std::exception& e) {
2971       {
2972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2973       };
2974     } catch (...) {
2975       {
2976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2977       };
2978     }
2979   }
2980   jresult = result;
2981   return jresult;
2982 }
2983
2984
2985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2986   void * jresult ;
2987   uintp *arg1 = (uintp *) 0 ;
2988   unsigned int *result = 0 ;
2989
2990   arg1 = (uintp *)jarg1;
2991   {
2992     try {
2993       result = (unsigned int *)uintp_cast(arg1);
2994     } catch (std::out_of_range& e) {
2995       {
2996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2997       };
2998     } catch (std::exception& e) {
2999       {
3000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3001       };
3002     } catch (...) {
3003       {
3004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3005       };
3006     }
3007   }
3008   jresult = (void *)result;
3009   return jresult;
3010 }
3011
3012
3013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3014   void * jresult ;
3015   unsigned int *arg1 = (unsigned int *) 0 ;
3016   uintp *result = 0 ;
3017
3018   arg1 = (unsigned int *)jarg1;
3019   {
3020     try {
3021       result = (uintp *)uintp_frompointer(arg1);
3022     } catch (std::out_of_range& e) {
3023       {
3024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3025       };
3026     } catch (std::exception& e) {
3027       {
3028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3029       };
3030     } catch (...) {
3031       {
3032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3033       };
3034     }
3035   }
3036   jresult = (void *)result;
3037   return jresult;
3038 }
3039
3040
3041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3042   void * jresult ;
3043   ushortp *result = 0 ;
3044
3045   {
3046     try {
3047       result = (ushortp *)new_ushortp();
3048     } catch (std::out_of_range& e) {
3049       {
3050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3051       };
3052     } catch (std::exception& e) {
3053       {
3054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3055       };
3056     } catch (...) {
3057       {
3058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3059       };
3060     }
3061   }
3062   jresult = (void *)result;
3063   return jresult;
3064 }
3065
3066
3067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3068   ushortp *arg1 = (ushortp *) 0 ;
3069
3070   arg1 = (ushortp *)jarg1;
3071   {
3072     try {
3073       delete_ushortp(arg1);
3074     } catch (std::out_of_range& e) {
3075       {
3076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3077       };
3078     } catch (std::exception& e) {
3079       {
3080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3081       };
3082     } catch (...) {
3083       {
3084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3085       };
3086     }
3087   }
3088 }
3089
3090
3091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3092   ushortp *arg1 = (ushortp *) 0 ;
3093   unsigned short arg2 ;
3094
3095   arg1 = (ushortp *)jarg1;
3096   arg2 = (unsigned short)jarg2;
3097   {
3098     try {
3099       ushortp_assign(arg1,arg2);
3100     } catch (std::out_of_range& e) {
3101       {
3102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3103       };
3104     } catch (std::exception& e) {
3105       {
3106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3107       };
3108     } catch (...) {
3109       {
3110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3111       };
3112     }
3113   }
3114 }
3115
3116
3117 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3118   unsigned short jresult ;
3119   ushortp *arg1 = (ushortp *) 0 ;
3120   unsigned short result;
3121
3122   arg1 = (ushortp *)jarg1;
3123   {
3124     try {
3125       result = (unsigned short)ushortp_value(arg1);
3126     } catch (std::out_of_range& e) {
3127       {
3128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3129       };
3130     } catch (std::exception& e) {
3131       {
3132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3133       };
3134     } catch (...) {
3135       {
3136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3137       };
3138     }
3139   }
3140   jresult = result;
3141   return jresult;
3142 }
3143
3144
3145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3146   void * jresult ;
3147   ushortp *arg1 = (ushortp *) 0 ;
3148   unsigned short *result = 0 ;
3149
3150   arg1 = (ushortp *)jarg1;
3151   {
3152     try {
3153       result = (unsigned short *)ushortp_cast(arg1);
3154     } catch (std::out_of_range& e) {
3155       {
3156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3157       };
3158     } catch (std::exception& e) {
3159       {
3160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3161       };
3162     } catch (...) {
3163       {
3164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3165       };
3166     }
3167   }
3168   jresult = (void *)result;
3169   return jresult;
3170 }
3171
3172
3173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3174   void * jresult ;
3175   unsigned short *arg1 = (unsigned short *) 0 ;
3176   ushortp *result = 0 ;
3177
3178   arg1 = (unsigned short *)jarg1;
3179   {
3180     try {
3181       result = (ushortp *)ushortp_frompointer(arg1);
3182     } catch (std::out_of_range& e) {
3183       {
3184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3185       };
3186     } catch (std::exception& e) {
3187       {
3188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3189       };
3190     } catch (...) {
3191       {
3192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3193       };
3194     }
3195   }
3196   jresult = (void *)result;
3197   return jresult;
3198 }
3199
3200
3201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3202   unsigned int jresult ;
3203   int arg1 ;
3204   unsigned int result;
3205
3206   arg1 = (int)jarg1;
3207   {
3208     try {
3209       result = (unsigned int)int_to_uint(arg1);
3210     } catch (std::out_of_range& e) {
3211       {
3212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3213       };
3214     } catch (std::exception& e) {
3215       {
3216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3217       };
3218     } catch (...) {
3219       {
3220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3221       };
3222     }
3223   }
3224   jresult = result;
3225   return jresult;
3226 }
3227
3228
3229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3230   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3231
3232   arg1 = (Dali::RefObject *)jarg1;
3233   {
3234     try {
3235       (arg1)->Reference();
3236     } catch (std::out_of_range& e) {
3237       {
3238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3239       };
3240     } catch (std::exception& e) {
3241       {
3242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3243       };
3244     } catch (...) {
3245       {
3246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3247       };
3248     }
3249   }
3250 }
3251
3252
3253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3254   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3255
3256   arg1 = (Dali::RefObject *)jarg1;
3257   {
3258     try {
3259       (arg1)->Unreference();
3260     } catch (std::out_of_range& e) {
3261       {
3262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3263       };
3264     } catch (std::exception& e) {
3265       {
3266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3267       };
3268     } catch (...) {
3269       {
3270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3271       };
3272     }
3273   }
3274 }
3275
3276
3277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3278   int jresult ;
3279   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3280   int result;
3281
3282   arg1 = (Dali::RefObject *)jarg1;
3283   {
3284     try {
3285       result = (int)(arg1)->ReferenceCount();
3286     } catch (std::out_of_range& e) {
3287       {
3288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3289       };
3290     } catch (std::exception& e) {
3291       {
3292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3293       };
3294     } catch (...) {
3295       {
3296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3297       };
3298     }
3299   }
3300   jresult = result;
3301   return jresult;
3302 }
3303
3304
3305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3306   void * jresult ;
3307   Dali::Any *result = 0 ;
3308
3309   {
3310     try {
3311       result = (Dali::Any *)new Dali::Any();
3312     } catch (std::out_of_range& e) {
3313       {
3314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3315       };
3316     } catch (std::exception& e) {
3317       {
3318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3319       };
3320     } catch (...) {
3321       {
3322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3323       };
3324     }
3325   }
3326   jresult = (void *)result;
3327   return jresult;
3328 }
3329
3330
3331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3332   Dali::Any *arg1 = (Dali::Any *) 0 ;
3333
3334   arg1 = (Dali::Any *)jarg1;
3335   {
3336     try {
3337       delete arg1;
3338     } catch (std::out_of_range& e) {
3339       {
3340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3341       };
3342     } catch (std::exception& e) {
3343       {
3344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3345       };
3346     } catch (...) {
3347       {
3348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3349       };
3350     }
3351   }
3352 }
3353
3354
3355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3356   char *arg1 = (char *) 0 ;
3357
3358   arg1 = (char *)jarg1;
3359   {
3360     try {
3361       Dali::Any::AssertAlways((char const *)arg1);
3362     } catch (std::out_of_range& e) {
3363       {
3364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3365       };
3366     } catch (std::exception& e) {
3367       {
3368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3369       };
3370     } catch (...) {
3371       {
3372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3373       };
3374     }
3375   }
3376 }
3377
3378
3379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3380   void * jresult ;
3381   Dali::Any *arg1 = 0 ;
3382   Dali::Any *result = 0 ;
3383
3384   arg1 = (Dali::Any *)jarg1;
3385   if (!arg1) {
3386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3387     return 0;
3388   }
3389   {
3390     try {
3391       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3392     } catch (std::out_of_range& e) {
3393       {
3394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3395       };
3396     } catch (std::exception& e) {
3397       {
3398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3399       };
3400     } catch (...) {
3401       {
3402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3403       };
3404     }
3405   }
3406   jresult = (void *)result;
3407   return jresult;
3408 }
3409
3410
3411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3412   void * jresult ;
3413   Dali::Any *arg1 = (Dali::Any *) 0 ;
3414   Dali::Any *arg2 = 0 ;
3415   Dali::Any *result = 0 ;
3416
3417   arg1 = (Dali::Any *)jarg1;
3418   arg2 = (Dali::Any *)jarg2;
3419   if (!arg2) {
3420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3421     return 0;
3422   }
3423   {
3424     try {
3425       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3426     } catch (std::out_of_range& e) {
3427       {
3428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3429       };
3430     } catch (std::exception& e) {
3431       {
3432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3433       };
3434     } catch (...) {
3435       {
3436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3437       };
3438     }
3439   }
3440   jresult = (void *)result;
3441   return jresult;
3442 }
3443
3444
3445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3446   void * jresult ;
3447   Dali::Any *arg1 = (Dali::Any *) 0 ;
3448   std::type_info *result = 0 ;
3449
3450   arg1 = (Dali::Any *)jarg1;
3451   {
3452     try {
3453       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3454     } catch (std::out_of_range& e) {
3455       {
3456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3457       };
3458     } catch (std::exception& e) {
3459       {
3460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3461       };
3462     } catch (...) {
3463       {
3464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3465       };
3466     }
3467   }
3468   jresult = (void *)result;
3469   return jresult;
3470 }
3471
3472
3473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3474   unsigned int jresult ;
3475   Dali::Any *arg1 = (Dali::Any *) 0 ;
3476   bool result;
3477
3478   arg1 = (Dali::Any *)jarg1;
3479   {
3480     try {
3481       result = (bool)((Dali::Any const *)arg1)->Empty();
3482     } catch (std::out_of_range& e) {
3483       {
3484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3485       };
3486     } catch (std::exception& e) {
3487       {
3488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3489       };
3490     } catch (...) {
3491       {
3492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3493       };
3494     }
3495   }
3496   jresult = result;
3497   return jresult;
3498 }
3499
3500
3501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3502   void * jresult ;
3503   std::type_info *arg1 = 0 ;
3504   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3505   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3506   Dali::Any::AnyContainerBase *result = 0 ;
3507
3508   arg1 = (std::type_info *)jarg1;
3509   if (!arg1) {
3510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3511     return 0;
3512   }
3513   arg2 = (Dali::Any::CloneFunc)jarg2;
3514   arg3 = (Dali::Any::DeleteFunc)jarg3;
3515   {
3516     try {
3517       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3518     } catch (std::out_of_range& e) {
3519       {
3520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3521       };
3522     } catch (std::exception& e) {
3523       {
3524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3525       };
3526     } catch (...) {
3527       {
3528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3529       };
3530     }
3531   }
3532   jresult = (void *)result;
3533   return jresult;
3534 }
3535
3536
3537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3538   void * jresult ;
3539   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3540   std::type_info *result = 0 ;
3541
3542   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3543   {
3544     try {
3545       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3546     } catch (std::out_of_range& e) {
3547       {
3548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3549       };
3550     } catch (std::exception& e) {
3551       {
3552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3553       };
3554     } catch (...) {
3555       {
3556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3557       };
3558     }
3559   }
3560   jresult = (void *)result;
3561   return jresult;
3562 }
3563
3564
3565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3566   void * jresult ;
3567   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3568   ::std::type_info *result = 0 ;
3569
3570   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3571   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3572   jresult = (void *)result;
3573   return jresult;
3574 }
3575
3576
3577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3578   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3579   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3580
3581   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3582   arg2 = (Dali::Any::CloneFunc)jarg2;
3583   if (arg1) (arg1)->mCloneFunc = arg2;
3584 }
3585
3586
3587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3588   void * jresult ;
3589   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3590   Dali::Any::CloneFunc result;
3591
3592   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3593   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3594   jresult = (void *)result;
3595   return jresult;
3596 }
3597
3598
3599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3600   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3601   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3602
3603   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3604   arg2 = (Dali::Any::DeleteFunc)jarg2;
3605   if (arg1) (arg1)->mDeleteFunc = arg2;
3606 }
3607
3608
3609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3610   void * jresult ;
3611   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3612   Dali::Any::DeleteFunc result;
3613
3614   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3615   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3616   jresult = (void *)result;
3617   return jresult;
3618 }
3619
3620
3621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3622   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3623
3624   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3625   {
3626     try {
3627       delete arg1;
3628     } catch (std::out_of_range& e) {
3629       {
3630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3631       };
3632     } catch (std::exception& e) {
3633       {
3634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3635       };
3636     } catch (...) {
3637       {
3638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3639       };
3640     }
3641   }
3642 }
3643
3644
3645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3646   Dali::Any *arg1 = (Dali::Any *) 0 ;
3647   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3648
3649   arg1 = (Dali::Any *)jarg1;
3650   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3651   if (arg1) (arg1)->mContainer = arg2;
3652 }
3653
3654
3655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3656   void * jresult ;
3657   Dali::Any *arg1 = (Dali::Any *) 0 ;
3658   Dali::Any::AnyContainerBase *result = 0 ;
3659
3660   arg1 = (Dali::Any *)jarg1;
3661   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3662   jresult = (void *)result;
3663   return jresult;
3664 }
3665
3666
3667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3668   char *arg1 = (char *) 0 ;
3669   char *arg2 = (char *) 0 ;
3670
3671   arg1 = (char *)jarg1;
3672   arg2 = (char *)jarg2;
3673   {
3674     try {
3675       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3676     } catch (std::out_of_range& e) {
3677       {
3678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3679       };
3680     } catch (std::exception& e) {
3681       {
3682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3683       };
3684     } catch (...) {
3685       {
3686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3687       };
3688     }
3689   }
3690 }
3691
3692
3693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3694   void * jresult ;
3695   char *arg1 = (char *) 0 ;
3696   char *arg2 = (char *) 0 ;
3697   Dali::DaliException *result = 0 ;
3698
3699   arg1 = (char *)jarg1;
3700   arg2 = (char *)jarg2;
3701   {
3702     try {
3703       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3704     } catch (std::out_of_range& e) {
3705       {
3706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3707       };
3708     } catch (std::exception& e) {
3709       {
3710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3711       };
3712     } catch (...) {
3713       {
3714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3715       };
3716     }
3717   }
3718   jresult = (void *)result;
3719   return jresult;
3720 }
3721
3722
3723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3724   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3725   char *arg2 = (char *) 0 ;
3726
3727   arg1 = (Dali::DaliException *)jarg1;
3728   arg2 = (char *)jarg2;
3729   {
3730     if (arg2) {
3731       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3732       strcpy((char *)arg1->location, (const char *)arg2);
3733     } else {
3734       arg1->location = 0;
3735     }
3736   }
3737 }
3738
3739
3740 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3741   char * jresult ;
3742   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3743   char *result = 0 ;
3744
3745   arg1 = (Dali::DaliException *)jarg1;
3746   result = (char *) ((arg1)->location);
3747   jresult = SWIG_csharp_string_callback((const char *)result);
3748   return jresult;
3749 }
3750
3751
3752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3753   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3754   char *arg2 = (char *) 0 ;
3755
3756   arg1 = (Dali::DaliException *)jarg1;
3757   arg2 = (char *)jarg2;
3758   {
3759     if (arg2) {
3760       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3761       strcpy((char *)arg1->condition, (const char *)arg2);
3762     } else {
3763       arg1->condition = 0;
3764     }
3765   }
3766 }
3767
3768
3769 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3770   char * jresult ;
3771   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3772   char *result = 0 ;
3773
3774   arg1 = (Dali::DaliException *)jarg1;
3775   result = (char *) ((arg1)->condition);
3776   jresult = SWIG_csharp_string_callback((const char *)result);
3777   return jresult;
3778 }
3779
3780
3781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3782   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3783
3784   arg1 = (Dali::DaliException *)jarg1;
3785   {
3786     try {
3787       delete arg1;
3788     } catch (std::out_of_range& e) {
3789       {
3790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3791       };
3792     } catch (std::exception& e) {
3793       {
3794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3795       };
3796     } catch (...) {
3797       {
3798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3799       };
3800     }
3801   }
3802 }
3803
3804
3805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3806   void * jresult ;
3807   Dali::Vector2 *result = 0 ;
3808
3809   {
3810     try {
3811       result = (Dali::Vector2 *)new Dali::Vector2();
3812     } catch (std::out_of_range& e) {
3813       {
3814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3815       };
3816     } catch (std::exception& e) {
3817       {
3818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3819       };
3820     } catch (...) {
3821       {
3822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3823       };
3824     }
3825   }
3826   jresult = (void *)result;
3827   return jresult;
3828 }
3829
3830
3831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3832   void * jresult ;
3833   float arg1 ;
3834   float arg2 ;
3835   Dali::Vector2 *result = 0 ;
3836
3837   arg1 = (float)jarg1;
3838   arg2 = (float)jarg2;
3839   {
3840     try {
3841       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3842     } catch (std::out_of_range& e) {
3843       {
3844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3845       };
3846     } catch (std::exception& e) {
3847       {
3848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3849       };
3850     } catch (...) {
3851       {
3852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3853       };
3854     }
3855   }
3856   jresult = (void *)result;
3857   return jresult;
3858 }
3859
3860
3861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3862   void * jresult ;
3863   float *arg1 = (float *) 0 ;
3864   Dali::Vector2 *result = 0 ;
3865
3866   arg1 = jarg1;
3867   {
3868     try {
3869       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3870     } catch (std::out_of_range& e) {
3871       {
3872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3873       };
3874     } catch (std::exception& e) {
3875       {
3876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3877       };
3878     } catch (...) {
3879       {
3880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3881       };
3882     }
3883   }
3884   jresult = (void *)result;
3885
3886
3887   return jresult;
3888 }
3889
3890
3891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3892   void * jresult ;
3893   Dali::Vector3 *arg1 = 0 ;
3894   Dali::Vector2 *result = 0 ;
3895
3896   arg1 = (Dali::Vector3 *)jarg1;
3897   if (!arg1) {
3898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3899     return 0;
3900   }
3901   {
3902     try {
3903       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3904     } catch (std::out_of_range& e) {
3905       {
3906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3907       };
3908     } catch (std::exception& e) {
3909       {
3910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3911       };
3912     } catch (...) {
3913       {
3914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3915       };
3916     }
3917   }
3918   jresult = (void *)result;
3919   return jresult;
3920 }
3921
3922
3923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3924   void * jresult ;
3925   Dali::Vector4 *arg1 = 0 ;
3926   Dali::Vector2 *result = 0 ;
3927
3928   arg1 = (Dali::Vector4 *)jarg1;
3929   if (!arg1) {
3930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3931     return 0;
3932   }
3933   {
3934     try {
3935       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3936     } catch (std::out_of_range& e) {
3937       {
3938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3939       };
3940     } catch (std::exception& e) {
3941       {
3942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3943       };
3944     } catch (...) {
3945       {
3946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3947       };
3948     }
3949   }
3950   jresult = (void *)result;
3951   return jresult;
3952 }
3953
3954
3955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3956   void * jresult ;
3957   Dali::Vector2 *result = 0 ;
3958
3959   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3960   jresult = (void *)result;
3961   return jresult;
3962 }
3963
3964
3965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3966   void * jresult ;
3967   Dali::Vector2 *result = 0 ;
3968
3969   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3970   jresult = (void *)result;
3971   return jresult;
3972 }
3973
3974
3975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3976   void * jresult ;
3977   Dali::Vector2 *result = 0 ;
3978
3979   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3980   jresult = (void *)result;
3981   return jresult;
3982 }
3983
3984
3985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3986   void * jresult ;
3987   Dali::Vector2 *result = 0 ;
3988
3989   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3990   jresult = (void *)result;
3991   return jresult;
3992 }
3993
3994
3995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3996   void * jresult ;
3997   Dali::Vector2 *result = 0 ;
3998
3999   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4000   jresult = (void *)result;
4001   return jresult;
4002 }
4003
4004
4005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4006   void * jresult ;
4007   Dali::Vector2 *result = 0 ;
4008
4009   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4010   jresult = (void *)result;
4011   return jresult;
4012 }
4013
4014
4015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4016   void * jresult ;
4017   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4018   float *arg2 = (float *) 0 ;
4019   Dali::Vector2 *result = 0 ;
4020
4021   arg1 = (Dali::Vector2 *)jarg1;
4022   arg2 = jarg2;
4023   {
4024     try {
4025       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4026     } catch (std::out_of_range& e) {
4027       {
4028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4029       };
4030     } catch (std::exception& e) {
4031       {
4032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4033       };
4034     } catch (...) {
4035       {
4036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4037       };
4038     }
4039   }
4040   jresult = (void *)result;
4041
4042
4043   return jresult;
4044 }
4045
4046
4047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4048   void * jresult ;
4049   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4050   Dali::Vector3 *arg2 = 0 ;
4051   Dali::Vector2 *result = 0 ;
4052
4053   arg1 = (Dali::Vector2 *)jarg1;
4054   arg2 = (Dali::Vector3 *)jarg2;
4055   if (!arg2) {
4056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4057     return 0;
4058   }
4059   {
4060     try {
4061       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4062     } catch (std::out_of_range& e) {
4063       {
4064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4065       };
4066     } catch (std::exception& e) {
4067       {
4068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4069       };
4070     } catch (...) {
4071       {
4072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4073       };
4074     }
4075   }
4076   jresult = (void *)result;
4077   return jresult;
4078 }
4079
4080
4081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4082   void * jresult ;
4083   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4084   Dali::Vector4 *arg2 = 0 ;
4085   Dali::Vector2 *result = 0 ;
4086
4087   arg1 = (Dali::Vector2 *)jarg1;
4088   arg2 = (Dali::Vector4 *)jarg2;
4089   if (!arg2) {
4090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4091     return 0;
4092   }
4093   {
4094     try {
4095       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4096     } catch (std::out_of_range& e) {
4097       {
4098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4099       };
4100     } catch (std::exception& e) {
4101       {
4102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4103       };
4104     } catch (...) {
4105       {
4106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4107       };
4108     }
4109   }
4110   jresult = (void *)result;
4111   return jresult;
4112 }
4113
4114
4115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4116   void * jresult ;
4117   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4118   Dali::Vector2 *arg2 = 0 ;
4119   Dali::Vector2 result;
4120
4121   arg1 = (Dali::Vector2 *)jarg1;
4122   arg2 = (Dali::Vector2 *)jarg2;
4123   if (!arg2) {
4124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4125     return 0;
4126   }
4127   {
4128     try {
4129       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4130     } catch (std::out_of_range& e) {
4131       {
4132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4133       };
4134     } catch (std::exception& e) {
4135       {
4136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4137       };
4138     } catch (...) {
4139       {
4140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4141       };
4142     }
4143   }
4144   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4145   return jresult;
4146 }
4147
4148
4149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4150   void * jresult ;
4151   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4152   Dali::Vector2 *arg2 = 0 ;
4153   Dali::Vector2 *result = 0 ;
4154
4155   arg1 = (Dali::Vector2 *)jarg1;
4156   arg2 = (Dali::Vector2 *)jarg2;
4157   if (!arg2) {
4158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4159     return 0;
4160   }
4161   {
4162     try {
4163       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4164     } catch (std::out_of_range& e) {
4165       {
4166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4167       };
4168     } catch (std::exception& e) {
4169       {
4170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4171       };
4172     } catch (...) {
4173       {
4174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4175       };
4176     }
4177   }
4178   jresult = (void *)result;
4179   return jresult;
4180 }
4181
4182
4183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4184   void * jresult ;
4185   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4186   Dali::Vector2 *arg2 = 0 ;
4187   Dali::Vector2 result;
4188
4189   arg1 = (Dali::Vector2 *)jarg1;
4190   arg2 = (Dali::Vector2 *)jarg2;
4191   if (!arg2) {
4192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4193     return 0;
4194   }
4195   {
4196     try {
4197       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4198     } catch (std::out_of_range& e) {
4199       {
4200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4201       };
4202     } catch (std::exception& e) {
4203       {
4204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4205       };
4206     } catch (...) {
4207       {
4208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4209       };
4210     }
4211   }
4212   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4213   return jresult;
4214 }
4215
4216
4217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4218   void * jresult ;
4219   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4220   Dali::Vector2 *arg2 = 0 ;
4221   Dali::Vector2 *result = 0 ;
4222
4223   arg1 = (Dali::Vector2 *)jarg1;
4224   arg2 = (Dali::Vector2 *)jarg2;
4225   if (!arg2) {
4226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4227     return 0;
4228   }
4229   {
4230     try {
4231       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4232     } catch (std::out_of_range& e) {
4233       {
4234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4235       };
4236     } catch (std::exception& e) {
4237       {
4238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4239       };
4240     } catch (...) {
4241       {
4242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4243       };
4244     }
4245   }
4246   jresult = (void *)result;
4247   return jresult;
4248 }
4249
4250
4251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4252   void * jresult ;
4253   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4254   Dali::Vector2 *arg2 = 0 ;
4255   Dali::Vector2 result;
4256
4257   arg1 = (Dali::Vector2 *)jarg1;
4258   arg2 = (Dali::Vector2 *)jarg2;
4259   if (!arg2) {
4260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4261     return 0;
4262   }
4263   {
4264     try {
4265       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4266     } catch (std::out_of_range& e) {
4267       {
4268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4269       };
4270     } catch (std::exception& e) {
4271       {
4272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4273       };
4274     } catch (...) {
4275       {
4276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4277       };
4278     }
4279   }
4280   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4281   return jresult;
4282 }
4283
4284
4285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4286   void * jresult ;
4287   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4288   float arg2 ;
4289   Dali::Vector2 result;
4290
4291   arg1 = (Dali::Vector2 *)jarg1;
4292   arg2 = (float)jarg2;
4293   {
4294     try {
4295       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4296     } catch (std::out_of_range& e) {
4297       {
4298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4299       };
4300     } catch (std::exception& e) {
4301       {
4302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4303       };
4304     } catch (...) {
4305       {
4306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4307       };
4308     }
4309   }
4310   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4311   return jresult;
4312 }
4313
4314
4315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4316   void * jresult ;
4317   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4318   Dali::Vector2 *arg2 = 0 ;
4319   Dali::Vector2 *result = 0 ;
4320
4321   arg1 = (Dali::Vector2 *)jarg1;
4322   arg2 = (Dali::Vector2 *)jarg2;
4323   if (!arg2) {
4324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4325     return 0;
4326   }
4327   {
4328     try {
4329       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4330     } catch (std::out_of_range& e) {
4331       {
4332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4333       };
4334     } catch (std::exception& e) {
4335       {
4336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4337       };
4338     } catch (...) {
4339       {
4340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4341       };
4342     }
4343   }
4344   jresult = (void *)result;
4345   return jresult;
4346 }
4347
4348
4349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4350   void * jresult ;
4351   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4352   float arg2 ;
4353   Dali::Vector2 *result = 0 ;
4354
4355   arg1 = (Dali::Vector2 *)jarg1;
4356   arg2 = (float)jarg2;
4357   {
4358     try {
4359       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4360     } catch (std::out_of_range& e) {
4361       {
4362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4363       };
4364     } catch (std::exception& e) {
4365       {
4366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4367       };
4368     } catch (...) {
4369       {
4370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4371       };
4372     }
4373   }
4374   jresult = (void *)result;
4375   return jresult;
4376 }
4377
4378
4379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4380   void * jresult ;
4381   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4382   Dali::Vector2 *arg2 = 0 ;
4383   Dali::Vector2 result;
4384
4385   arg1 = (Dali::Vector2 *)jarg1;
4386   arg2 = (Dali::Vector2 *)jarg2;
4387   if (!arg2) {
4388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4389     return 0;
4390   }
4391   {
4392     try {
4393       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4394     } catch (std::out_of_range& e) {
4395       {
4396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4397       };
4398     } catch (std::exception& e) {
4399       {
4400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4401       };
4402     } catch (...) {
4403       {
4404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4405       };
4406     }
4407   }
4408   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4409   return jresult;
4410 }
4411
4412
4413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4414   void * jresult ;
4415   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4416   float arg2 ;
4417   Dali::Vector2 result;
4418
4419   arg1 = (Dali::Vector2 *)jarg1;
4420   arg2 = (float)jarg2;
4421   {
4422     try {
4423       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4424     } catch (std::out_of_range& e) {
4425       {
4426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4427       };
4428     } catch (std::exception& e) {
4429       {
4430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4431       };
4432     } catch (...) {
4433       {
4434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4435       };
4436     }
4437   }
4438   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4439   return jresult;
4440 }
4441
4442
4443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4444   void * jresult ;
4445   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4446   Dali::Vector2 *arg2 = 0 ;
4447   Dali::Vector2 *result = 0 ;
4448
4449   arg1 = (Dali::Vector2 *)jarg1;
4450   arg2 = (Dali::Vector2 *)jarg2;
4451   if (!arg2) {
4452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4453     return 0;
4454   }
4455   {
4456     try {
4457       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4458     } catch (std::out_of_range& e) {
4459       {
4460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4461       };
4462     } catch (std::exception& e) {
4463       {
4464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4465       };
4466     } catch (...) {
4467       {
4468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4469       };
4470     }
4471   }
4472   jresult = (void *)result;
4473   return jresult;
4474 }
4475
4476
4477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4478   void * jresult ;
4479   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4480   float arg2 ;
4481   Dali::Vector2 *result = 0 ;
4482
4483   arg1 = (Dali::Vector2 *)jarg1;
4484   arg2 = (float)jarg2;
4485   {
4486     try {
4487       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4488     } catch (std::out_of_range& e) {
4489       {
4490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4491       };
4492     } catch (std::exception& e) {
4493       {
4494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4495       };
4496     } catch (...) {
4497       {
4498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4499       };
4500     }
4501   }
4502   jresult = (void *)result;
4503   return jresult;
4504 }
4505
4506
4507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4508   void * jresult ;
4509   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4510   Dali::Vector2 result;
4511
4512   arg1 = (Dali::Vector2 *)jarg1;
4513   {
4514     try {
4515       result = ((Dali::Vector2 const *)arg1)->operator -();
4516     } catch (std::out_of_range& e) {
4517       {
4518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4519       };
4520     } catch (std::exception& e) {
4521       {
4522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4523       };
4524     } catch (...) {
4525       {
4526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4527       };
4528     }
4529   }
4530   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4531   return jresult;
4532 }
4533
4534
4535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4536   unsigned int jresult ;
4537   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4538   Dali::Vector2 *arg2 = 0 ;
4539   bool result;
4540
4541   arg1 = (Dali::Vector2 *)jarg1;
4542   arg2 = (Dali::Vector2 *)jarg2;
4543   if (!arg2) {
4544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4545     return 0;
4546   }
4547   {
4548     try {
4549       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4550     } catch (std::out_of_range& e) {
4551       {
4552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4553       };
4554     } catch (std::exception& e) {
4555       {
4556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4557       };
4558     } catch (...) {
4559       {
4560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4561       };
4562     }
4563   }
4564   jresult = result;
4565   return jresult;
4566 }
4567
4568
4569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4570   unsigned int jresult ;
4571   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4572   Dali::Vector2 *arg2 = 0 ;
4573   bool result;
4574
4575   arg1 = (Dali::Vector2 *)jarg1;
4576   arg2 = (Dali::Vector2 *)jarg2;
4577   if (!arg2) {
4578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4579     return 0;
4580   }
4581   {
4582     try {
4583       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4584     } catch (std::out_of_range& e) {
4585       {
4586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4587       };
4588     } catch (std::exception& e) {
4589       {
4590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4591       };
4592     } catch (...) {
4593       {
4594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4595       };
4596     }
4597   }
4598   jresult = result;
4599   return jresult;
4600 }
4601
4602
4603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4604   float jresult ;
4605   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4606   unsigned int arg2 ;
4607   float *result = 0 ;
4608
4609   arg1 = (Dali::Vector2 *)jarg1;
4610   arg2 = (unsigned int)jarg2;
4611   {
4612     try {
4613       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4614     } catch (std::out_of_range& e) {
4615       {
4616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4617       };
4618     } catch (std::exception& e) {
4619       {
4620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4621       };
4622     } catch (...) {
4623       {
4624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4625       };
4626     }
4627   }
4628   jresult = *result;
4629   return jresult;
4630 }
4631
4632
4633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4634   float jresult ;
4635   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4636   float result;
4637
4638   arg1 = (Dali::Vector2 *)jarg1;
4639   {
4640     try {
4641       result = (float)((Dali::Vector2 const *)arg1)->Length();
4642     } catch (std::out_of_range& e) {
4643       {
4644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4645       };
4646     } catch (std::exception& e) {
4647       {
4648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4649       };
4650     } catch (...) {
4651       {
4652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4653       };
4654     }
4655   }
4656   jresult = result;
4657   return jresult;
4658 }
4659
4660
4661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4662   float jresult ;
4663   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4664   float result;
4665
4666   arg1 = (Dali::Vector2 *)jarg1;
4667   {
4668     try {
4669       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4670     } catch (std::out_of_range& e) {
4671       {
4672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4673       };
4674     } catch (std::exception& e) {
4675       {
4676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4677       };
4678     } catch (...) {
4679       {
4680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4681       };
4682     }
4683   }
4684   jresult = result;
4685   return jresult;
4686 }
4687
4688
4689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4690   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4691
4692   arg1 = (Dali::Vector2 *)jarg1;
4693   {
4694     try {
4695       (arg1)->Normalize();
4696     } catch (std::out_of_range& e) {
4697       {
4698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4699       };
4700     } catch (std::exception& e) {
4701       {
4702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4703       };
4704     } catch (...) {
4705       {
4706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4707       };
4708     }
4709   }
4710 }
4711
4712
4713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4714   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4715   Dali::Vector2 *arg2 = 0 ;
4716   Dali::Vector2 *arg3 = 0 ;
4717
4718   arg1 = (Dali::Vector2 *)jarg1;
4719   arg2 = (Dali::Vector2 *)jarg2;
4720   if (!arg2) {
4721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4722     return ;
4723   }
4724   arg3 = (Dali::Vector2 *)jarg3;
4725   if (!arg3) {
4726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4727     return ;
4728   }
4729   {
4730     try {
4731       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4732     } catch (std::out_of_range& e) {
4733       {
4734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4735       };
4736     } catch (std::exception& e) {
4737       {
4738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4739       };
4740     } catch (...) {
4741       {
4742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4743       };
4744     }
4745   }
4746 }
4747
4748
4749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4750   void * jresult ;
4751   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4752   float *result = 0 ;
4753
4754   arg1 = (Dali::Vector2 *)jarg1;
4755   {
4756     try {
4757       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4758     } catch (std::out_of_range& e) {
4759       {
4760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4761       };
4762     } catch (std::exception& e) {
4763       {
4764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4765       };
4766     } catch (...) {
4767       {
4768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4769       };
4770     }
4771   }
4772   jresult = (void *)result;
4773   return jresult;
4774 }
4775
4776
4777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4778   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4779   float arg2 ;
4780
4781   arg1 = (Dali::Vector2 *)jarg1;
4782   arg2 = (float)jarg2;
4783   if (arg1) (arg1)->x = arg2;
4784 }
4785
4786
4787 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4788   float jresult ;
4789   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4790   float result;
4791
4792   arg1 = (Dali::Vector2 *)jarg1;
4793   result = (float) ((arg1)->x);
4794   jresult = result;
4795   return jresult;
4796 }
4797
4798
4799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4800   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4801   float arg2 ;
4802
4803   arg1 = (Dali::Vector2 *)jarg1;
4804   arg2 = (float)jarg2;
4805   if (arg1) (arg1)->width = arg2;
4806 }
4807
4808
4809 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4810   float jresult ;
4811   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4812   float result;
4813
4814   arg1 = (Dali::Vector2 *)jarg1;
4815   result = (float) ((arg1)->width);
4816   jresult = result;
4817   return jresult;
4818 }
4819
4820
4821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4822   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4823   float arg2 ;
4824
4825   arg1 = (Dali::Vector2 *)jarg1;
4826   arg2 = (float)jarg2;
4827   if (arg1) (arg1)->y = arg2;
4828 }
4829
4830
4831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4832   float jresult ;
4833   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4834   float result;
4835
4836   arg1 = (Dali::Vector2 *)jarg1;
4837   result = (float) ((arg1)->y);
4838   jresult = result;
4839   return jresult;
4840 }
4841
4842
4843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4844   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4845   float arg2 ;
4846
4847   arg1 = (Dali::Vector2 *)jarg1;
4848   arg2 = (float)jarg2;
4849   if (arg1) (arg1)->height = arg2;
4850 }
4851
4852
4853 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4854   float jresult ;
4855   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4856   float result;
4857
4858   arg1 = (Dali::Vector2 *)jarg1;
4859   result = (float) ((arg1)->height);
4860   jresult = result;
4861   return jresult;
4862 }
4863
4864
4865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4866   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4867
4868   arg1 = (Dali::Vector2 *)jarg1;
4869   {
4870     try {
4871       delete arg1;
4872     } catch (std::out_of_range& e) {
4873       {
4874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4875       };
4876     } catch (std::exception& e) {
4877       {
4878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4879       };
4880     } catch (...) {
4881       {
4882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4883       };
4884     }
4885   }
4886 }
4887
4888
4889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4890   void * jresult ;
4891   Dali::Vector2 *arg1 = 0 ;
4892   Dali::Vector2 *arg2 = 0 ;
4893   Dali::Vector2 result;
4894
4895   arg1 = (Dali::Vector2 *)jarg1;
4896   if (!arg1) {
4897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4898     return 0;
4899   }
4900   arg2 = (Dali::Vector2 *)jarg2;
4901   if (!arg2) {
4902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4903     return 0;
4904   }
4905   {
4906     try {
4907       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4908     } catch (std::out_of_range& e) {
4909       {
4910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4911       };
4912     } catch (std::exception& e) {
4913       {
4914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4915       };
4916     } catch (...) {
4917       {
4918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4919       };
4920     }
4921   }
4922   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4923   return jresult;
4924 }
4925
4926
4927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4928   void * jresult ;
4929   Dali::Vector2 *arg1 = 0 ;
4930   Dali::Vector2 *arg2 = 0 ;
4931   Dali::Vector2 result;
4932
4933   arg1 = (Dali::Vector2 *)jarg1;
4934   if (!arg1) {
4935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4936     return 0;
4937   }
4938   arg2 = (Dali::Vector2 *)jarg2;
4939   if (!arg2) {
4940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4941     return 0;
4942   }
4943   {
4944     try {
4945       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4946     } catch (std::out_of_range& e) {
4947       {
4948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4949       };
4950     } catch (std::exception& e) {
4951       {
4952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4953       };
4954     } catch (...) {
4955       {
4956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4957       };
4958     }
4959   }
4960   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4961   return jresult;
4962 }
4963
4964
4965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4966   void * jresult ;
4967   Dali::Vector2 *arg1 = 0 ;
4968   float *arg2 = 0 ;
4969   float *arg3 = 0 ;
4970   float temp2 ;
4971   float temp3 ;
4972   Dali::Vector2 result;
4973
4974   arg1 = (Dali::Vector2 *)jarg1;
4975   if (!arg1) {
4976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4977     return 0;
4978   }
4979   temp2 = (float)jarg2;
4980   arg2 = &temp2;
4981   temp3 = (float)jarg3;
4982   arg3 = &temp3;
4983   {
4984     try {
4985       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4986     } catch (std::out_of_range& e) {
4987       {
4988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4989       };
4990     } catch (std::exception& e) {
4991       {
4992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4993       };
4994     } catch (...) {
4995       {
4996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4997       };
4998     }
4999   }
5000   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5001   return jresult;
5002 }
5003
5004
5005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5006   void * jresult ;
5007   Dali::Vector3 *result = 0 ;
5008
5009   {
5010     try {
5011       result = (Dali::Vector3 *)new Dali::Vector3();
5012     } catch (std::out_of_range& e) {
5013       {
5014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5015       };
5016     } catch (std::exception& e) {
5017       {
5018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5019       };
5020     } catch (...) {
5021       {
5022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5023       };
5024     }
5025   }
5026   jresult = (void *)result;
5027   return jresult;
5028 }
5029
5030
5031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5032   void * jresult ;
5033   float arg1 ;
5034   float arg2 ;
5035   float arg3 ;
5036   Dali::Vector3 *result = 0 ;
5037
5038   arg1 = (float)jarg1;
5039   arg2 = (float)jarg2;
5040   arg3 = (float)jarg3;
5041   {
5042     try {
5043       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5044     } catch (std::out_of_range& e) {
5045       {
5046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5047       };
5048     } catch (std::exception& e) {
5049       {
5050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5051       };
5052     } catch (...) {
5053       {
5054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5055       };
5056     }
5057   }
5058   jresult = (void *)result;
5059   return jresult;
5060 }
5061
5062
5063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5064   void * jresult ;
5065   float *arg1 = (float *) 0 ;
5066   Dali::Vector3 *result = 0 ;
5067
5068   arg1 = jarg1;
5069   {
5070     try {
5071       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5072     } catch (std::out_of_range& e) {
5073       {
5074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5075       };
5076     } catch (std::exception& e) {
5077       {
5078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5079       };
5080     } catch (...) {
5081       {
5082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5083       };
5084     }
5085   }
5086   jresult = (void *)result;
5087
5088
5089   return jresult;
5090 }
5091
5092
5093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5094   void * jresult ;
5095   Dali::Vector2 *arg1 = 0 ;
5096   Dali::Vector3 *result = 0 ;
5097
5098   arg1 = (Dali::Vector2 *)jarg1;
5099   if (!arg1) {
5100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5101     return 0;
5102   }
5103   {
5104     try {
5105       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5106     } catch (std::out_of_range& e) {
5107       {
5108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5109       };
5110     } catch (std::exception& e) {
5111       {
5112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5113       };
5114     } catch (...) {
5115       {
5116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5117       };
5118     }
5119   }
5120   jresult = (void *)result;
5121   return jresult;
5122 }
5123
5124
5125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5126   void * jresult ;
5127   Dali::Vector4 *arg1 = 0 ;
5128   Dali::Vector3 *result = 0 ;
5129
5130   arg1 = (Dali::Vector4 *)jarg1;
5131   if (!arg1) {
5132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5133     return 0;
5134   }
5135   {
5136     try {
5137       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5138     } catch (std::out_of_range& e) {
5139       {
5140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5141       };
5142     } catch (std::exception& e) {
5143       {
5144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5145       };
5146     } catch (...) {
5147       {
5148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5149       };
5150     }
5151   }
5152   jresult = (void *)result;
5153   return jresult;
5154 }
5155
5156
5157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5158   void * jresult ;
5159   Dali::Vector3 *result = 0 ;
5160
5161   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5162   jresult = (void *)result;
5163   return jresult;
5164 }
5165
5166
5167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5168   void * jresult ;
5169   Dali::Vector3 *result = 0 ;
5170
5171   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5172   jresult = (void *)result;
5173   return jresult;
5174 }
5175
5176
5177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5178   void * jresult ;
5179   Dali::Vector3 *result = 0 ;
5180
5181   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5182   jresult = (void *)result;
5183   return jresult;
5184 }
5185
5186
5187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5188   void * jresult ;
5189   Dali::Vector3 *result = 0 ;
5190
5191   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5192   jresult = (void *)result;
5193   return jresult;
5194 }
5195
5196
5197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5198   void * jresult ;
5199   Dali::Vector3 *result = 0 ;
5200
5201   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5202   jresult = (void *)result;
5203   return jresult;
5204 }
5205
5206
5207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5208   void * jresult ;
5209   Dali::Vector3 *result = 0 ;
5210
5211   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5212   jresult = (void *)result;
5213   return jresult;
5214 }
5215
5216
5217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5218   void * jresult ;
5219   Dali::Vector3 *result = 0 ;
5220
5221   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5222   jresult = (void *)result;
5223   return jresult;
5224 }
5225
5226
5227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5228   void * jresult ;
5229   Dali::Vector3 *result = 0 ;
5230
5231   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5232   jresult = (void *)result;
5233   return jresult;
5234 }
5235
5236
5237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5238   void * jresult ;
5239   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5240   float *arg2 = (float *) 0 ;
5241   Dali::Vector3 *result = 0 ;
5242
5243   arg1 = (Dali::Vector3 *)jarg1;
5244   arg2 = jarg2;
5245   {
5246     try {
5247       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5248     } catch (std::out_of_range& e) {
5249       {
5250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5251       };
5252     } catch (std::exception& e) {
5253       {
5254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5255       };
5256     } catch (...) {
5257       {
5258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5259       };
5260     }
5261   }
5262   jresult = (void *)result;
5263
5264
5265   return jresult;
5266 }
5267
5268
5269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5270   void * jresult ;
5271   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5272   Dali::Vector2 *arg2 = 0 ;
5273   Dali::Vector3 *result = 0 ;
5274
5275   arg1 = (Dali::Vector3 *)jarg1;
5276   arg2 = (Dali::Vector2 *)jarg2;
5277   if (!arg2) {
5278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5279     return 0;
5280   }
5281   {
5282     try {
5283       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5284     } catch (std::out_of_range& e) {
5285       {
5286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5287       };
5288     } catch (std::exception& e) {
5289       {
5290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5291       };
5292     } catch (...) {
5293       {
5294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5295       };
5296     }
5297   }
5298   jresult = (void *)result;
5299   return jresult;
5300 }
5301
5302
5303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5304   void * jresult ;
5305   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5306   Dali::Vector4 *arg2 = 0 ;
5307   Dali::Vector3 *result = 0 ;
5308
5309   arg1 = (Dali::Vector3 *)jarg1;
5310   arg2 = (Dali::Vector4 *)jarg2;
5311   if (!arg2) {
5312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5313     return 0;
5314   }
5315   {
5316     try {
5317       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5318     } catch (std::out_of_range& e) {
5319       {
5320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5321       };
5322     } catch (std::exception& e) {
5323       {
5324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5325       };
5326     } catch (...) {
5327       {
5328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5329       };
5330     }
5331   }
5332   jresult = (void *)result;
5333   return jresult;
5334 }
5335
5336
5337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5338   void * jresult ;
5339   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5340   Dali::Vector3 *arg2 = 0 ;
5341   Dali::Vector3 result;
5342
5343   arg1 = (Dali::Vector3 *)jarg1;
5344   arg2 = (Dali::Vector3 *)jarg2;
5345   if (!arg2) {
5346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5347     return 0;
5348   }
5349   {
5350     try {
5351       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5352     } catch (std::out_of_range& e) {
5353       {
5354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5355       };
5356     } catch (std::exception& e) {
5357       {
5358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5359       };
5360     } catch (...) {
5361       {
5362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5363       };
5364     }
5365   }
5366   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5367   return jresult;
5368 }
5369
5370
5371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5372   void * jresult ;
5373   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5374   Dali::Vector3 *arg2 = 0 ;
5375   Dali::Vector3 *result = 0 ;
5376
5377   arg1 = (Dali::Vector3 *)jarg1;
5378   arg2 = (Dali::Vector3 *)jarg2;
5379   if (!arg2) {
5380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5381     return 0;
5382   }
5383   {
5384     try {
5385       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5386     } catch (std::out_of_range& e) {
5387       {
5388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5389       };
5390     } catch (std::exception& e) {
5391       {
5392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5393       };
5394     } catch (...) {
5395       {
5396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5397       };
5398     }
5399   }
5400   jresult = (void *)result;
5401   return jresult;
5402 }
5403
5404
5405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5406   void * jresult ;
5407   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5408   Dali::Vector3 *arg2 = 0 ;
5409   Dali::Vector3 result;
5410
5411   arg1 = (Dali::Vector3 *)jarg1;
5412   arg2 = (Dali::Vector3 *)jarg2;
5413   if (!arg2) {
5414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5415     return 0;
5416   }
5417   {
5418     try {
5419       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5420     } catch (std::out_of_range& e) {
5421       {
5422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5423       };
5424     } catch (std::exception& e) {
5425       {
5426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5427       };
5428     } catch (...) {
5429       {
5430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5431       };
5432     }
5433   }
5434   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5435   return jresult;
5436 }
5437
5438
5439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5440   void * jresult ;
5441   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5442   Dali::Vector3 *arg2 = 0 ;
5443   Dali::Vector3 *result = 0 ;
5444
5445   arg1 = (Dali::Vector3 *)jarg1;
5446   arg2 = (Dali::Vector3 *)jarg2;
5447   if (!arg2) {
5448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5449     return 0;
5450   }
5451   {
5452     try {
5453       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5454     } catch (std::out_of_range& e) {
5455       {
5456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5457       };
5458     } catch (std::exception& e) {
5459       {
5460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5461       };
5462     } catch (...) {
5463       {
5464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5465       };
5466     }
5467   }
5468   jresult = (void *)result;
5469   return jresult;
5470 }
5471
5472
5473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5474   void * jresult ;
5475   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5476   Dali::Vector3 *arg2 = 0 ;
5477   Dali::Vector3 result;
5478
5479   arg1 = (Dali::Vector3 *)jarg1;
5480   arg2 = (Dali::Vector3 *)jarg2;
5481   if (!arg2) {
5482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5483     return 0;
5484   }
5485   {
5486     try {
5487       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5488     } catch (std::out_of_range& e) {
5489       {
5490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5491       };
5492     } catch (std::exception& e) {
5493       {
5494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5495       };
5496     } catch (...) {
5497       {
5498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5499       };
5500     }
5501   }
5502   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5503   return jresult;
5504 }
5505
5506
5507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5508   void * jresult ;
5509   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5510   float arg2 ;
5511   Dali::Vector3 result;
5512
5513   arg1 = (Dali::Vector3 *)jarg1;
5514   arg2 = (float)jarg2;
5515   {
5516     try {
5517       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5518     } catch (std::out_of_range& e) {
5519       {
5520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5521       };
5522     } catch (std::exception& e) {
5523       {
5524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5525       };
5526     } catch (...) {
5527       {
5528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5529       };
5530     }
5531   }
5532   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5533   return jresult;
5534 }
5535
5536
5537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5538   void * jresult ;
5539   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5540   Dali::Vector3 *arg2 = 0 ;
5541   Dali::Vector3 *result = 0 ;
5542
5543   arg1 = (Dali::Vector3 *)jarg1;
5544   arg2 = (Dali::Vector3 *)jarg2;
5545   if (!arg2) {
5546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5547     return 0;
5548   }
5549   {
5550     try {
5551       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5552     } catch (std::out_of_range& e) {
5553       {
5554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5555       };
5556     } catch (std::exception& e) {
5557       {
5558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5559       };
5560     } catch (...) {
5561       {
5562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5563       };
5564     }
5565   }
5566   jresult = (void *)result;
5567   return jresult;
5568 }
5569
5570
5571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5572   void * jresult ;
5573   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5574   float arg2 ;
5575   Dali::Vector3 *result = 0 ;
5576
5577   arg1 = (Dali::Vector3 *)jarg1;
5578   arg2 = (float)jarg2;
5579   {
5580     try {
5581       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5582     } catch (std::out_of_range& e) {
5583       {
5584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5585       };
5586     } catch (std::exception& e) {
5587       {
5588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5589       };
5590     } catch (...) {
5591       {
5592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5593       };
5594     }
5595   }
5596   jresult = (void *)result;
5597   return jresult;
5598 }
5599
5600
5601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5602   void * jresult ;
5603   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5604   Dali::Quaternion *arg2 = 0 ;
5605   Dali::Vector3 *result = 0 ;
5606
5607   arg1 = (Dali::Vector3 *)jarg1;
5608   arg2 = (Dali::Quaternion *)jarg2;
5609   if (!arg2) {
5610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5611     return 0;
5612   }
5613   {
5614     try {
5615       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5616     } catch (std::out_of_range& e) {
5617       {
5618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5619       };
5620     } catch (std::exception& e) {
5621       {
5622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5623       };
5624     } catch (...) {
5625       {
5626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5627       };
5628     }
5629   }
5630   jresult = (void *)result;
5631   return jresult;
5632 }
5633
5634
5635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5636   void * jresult ;
5637   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5638   Dali::Vector3 *arg2 = 0 ;
5639   Dali::Vector3 result;
5640
5641   arg1 = (Dali::Vector3 *)jarg1;
5642   arg2 = (Dali::Vector3 *)jarg2;
5643   if (!arg2) {
5644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5645     return 0;
5646   }
5647   {
5648     try {
5649       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5650     } catch (std::out_of_range& e) {
5651       {
5652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5653       };
5654     } catch (std::exception& e) {
5655       {
5656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5657       };
5658     } catch (...) {
5659       {
5660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5661       };
5662     }
5663   }
5664   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5665   return jresult;
5666 }
5667
5668
5669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5670   void * jresult ;
5671   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5672   float arg2 ;
5673   Dali::Vector3 result;
5674
5675   arg1 = (Dali::Vector3 *)jarg1;
5676   arg2 = (float)jarg2;
5677   {
5678     try {
5679       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5680     } catch (std::out_of_range& e) {
5681       {
5682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5683       };
5684     } catch (std::exception& e) {
5685       {
5686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5687       };
5688     } catch (...) {
5689       {
5690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5691       };
5692     }
5693   }
5694   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5695   return jresult;
5696 }
5697
5698
5699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5700   void * jresult ;
5701   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5702   Dali::Vector3 *arg2 = 0 ;
5703   Dali::Vector3 *result = 0 ;
5704
5705   arg1 = (Dali::Vector3 *)jarg1;
5706   arg2 = (Dali::Vector3 *)jarg2;
5707   if (!arg2) {
5708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5709     return 0;
5710   }
5711   {
5712     try {
5713       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5714     } catch (std::out_of_range& e) {
5715       {
5716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5717       };
5718     } catch (std::exception& e) {
5719       {
5720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5721       };
5722     } catch (...) {
5723       {
5724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5725       };
5726     }
5727   }
5728   jresult = (void *)result;
5729   return jresult;
5730 }
5731
5732
5733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5734   void * jresult ;
5735   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5736   float arg2 ;
5737   Dali::Vector3 *result = 0 ;
5738
5739   arg1 = (Dali::Vector3 *)jarg1;
5740   arg2 = (float)jarg2;
5741   {
5742     try {
5743       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5744     } catch (std::out_of_range& e) {
5745       {
5746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5747       };
5748     } catch (std::exception& e) {
5749       {
5750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5751       };
5752     } catch (...) {
5753       {
5754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5755       };
5756     }
5757   }
5758   jresult = (void *)result;
5759   return jresult;
5760 }
5761
5762
5763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5764   void * jresult ;
5765   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5766   Dali::Vector3 result;
5767
5768   arg1 = (Dali::Vector3 *)jarg1;
5769   {
5770     try {
5771       result = ((Dali::Vector3 const *)arg1)->operator -();
5772     } catch (std::out_of_range& e) {
5773       {
5774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5775       };
5776     } catch (std::exception& e) {
5777       {
5778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5779       };
5780     } catch (...) {
5781       {
5782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5783       };
5784     }
5785   }
5786   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5787   return jresult;
5788 }
5789
5790
5791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5792   unsigned int jresult ;
5793   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5794   Dali::Vector3 *arg2 = 0 ;
5795   bool result;
5796
5797   arg1 = (Dali::Vector3 *)jarg1;
5798   arg2 = (Dali::Vector3 *)jarg2;
5799   if (!arg2) {
5800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5801     return 0;
5802   }
5803   {
5804     try {
5805       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5806     } catch (std::out_of_range& e) {
5807       {
5808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5809       };
5810     } catch (std::exception& e) {
5811       {
5812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5813       };
5814     } catch (...) {
5815       {
5816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5817       };
5818     }
5819   }
5820   jresult = result;
5821   return jresult;
5822 }
5823
5824
5825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5826   unsigned int jresult ;
5827   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5828   Dali::Vector3 *arg2 = 0 ;
5829   bool result;
5830
5831   arg1 = (Dali::Vector3 *)jarg1;
5832   arg2 = (Dali::Vector3 *)jarg2;
5833   if (!arg2) {
5834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5835     return 0;
5836   }
5837   {
5838     try {
5839       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5840     } catch (std::out_of_range& e) {
5841       {
5842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5843       };
5844     } catch (std::exception& e) {
5845       {
5846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5847       };
5848     } catch (...) {
5849       {
5850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5851       };
5852     }
5853   }
5854   jresult = result;
5855   return jresult;
5856 }
5857
5858
5859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5860   float jresult ;
5861   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5862   unsigned int arg2 ;
5863   float *result = 0 ;
5864
5865   arg1 = (Dali::Vector3 *)jarg1;
5866   arg2 = (unsigned int)jarg2;
5867   {
5868     try {
5869       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5870     } catch (std::out_of_range& e) {
5871       {
5872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5873       };
5874     } catch (std::exception& e) {
5875       {
5876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5877       };
5878     } catch (...) {
5879       {
5880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5881       };
5882     }
5883   }
5884   jresult = *result;
5885   return jresult;
5886 }
5887
5888
5889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5890   float jresult ;
5891   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5892   Dali::Vector3 *arg2 = 0 ;
5893   float result;
5894
5895   arg1 = (Dali::Vector3 *)jarg1;
5896   arg2 = (Dali::Vector3 *)jarg2;
5897   if (!arg2) {
5898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5899     return 0;
5900   }
5901   {
5902     try {
5903       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5904     } catch (std::out_of_range& e) {
5905       {
5906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5907       };
5908     } catch (std::exception& e) {
5909       {
5910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5911       };
5912     } catch (...) {
5913       {
5914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5915       };
5916     }
5917   }
5918   jresult = result;
5919   return jresult;
5920 }
5921
5922
5923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5924   void * jresult ;
5925   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5926   Dali::Vector3 *arg2 = 0 ;
5927   Dali::Vector3 result;
5928
5929   arg1 = (Dali::Vector3 *)jarg1;
5930   arg2 = (Dali::Vector3 *)jarg2;
5931   if (!arg2) {
5932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5933     return 0;
5934   }
5935   {
5936     try {
5937       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5938     } catch (std::out_of_range& e) {
5939       {
5940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5941       };
5942     } catch (std::exception& e) {
5943       {
5944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5945       };
5946     } catch (...) {
5947       {
5948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5949       };
5950     }
5951   }
5952   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5953   return jresult;
5954 }
5955
5956
5957 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
5958   float jresult ;
5959   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5960   float result;
5961
5962   arg1 = (Dali::Vector3 *)jarg1;
5963   {
5964     try {
5965       result = (float)((Dali::Vector3 const *)arg1)->Length();
5966     } catch (std::out_of_range& e) {
5967       {
5968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5969       };
5970     } catch (std::exception& e) {
5971       {
5972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5973       };
5974     } catch (...) {
5975       {
5976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5977       };
5978     }
5979   }
5980   jresult = result;
5981   return jresult;
5982 }
5983
5984
5985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
5986   float jresult ;
5987   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5988   float result;
5989
5990   arg1 = (Dali::Vector3 *)jarg1;
5991   {
5992     try {
5993       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5994     } catch (std::out_of_range& e) {
5995       {
5996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5997       };
5998     } catch (std::exception& e) {
5999       {
6000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6001       };
6002     } catch (...) {
6003       {
6004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6005       };
6006     }
6007   }
6008   jresult = result;
6009   return jresult;
6010 }
6011
6012
6013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6014   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6015
6016   arg1 = (Dali::Vector3 *)jarg1;
6017   {
6018     try {
6019       (arg1)->Normalize();
6020     } catch (std::out_of_range& e) {
6021       {
6022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6023       };
6024     } catch (std::exception& e) {
6025       {
6026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6027       };
6028     } catch (...) {
6029       {
6030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6031       };
6032     }
6033   }
6034 }
6035
6036
6037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6038   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6039   Dali::Vector3 *arg2 = 0 ;
6040   Dali::Vector3 *arg3 = 0 ;
6041
6042   arg1 = (Dali::Vector3 *)jarg1;
6043   arg2 = (Dali::Vector3 *)jarg2;
6044   if (!arg2) {
6045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6046     return ;
6047   }
6048   arg3 = (Dali::Vector3 *)jarg3;
6049   if (!arg3) {
6050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6051     return ;
6052   }
6053   {
6054     try {
6055       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6056     } catch (std::out_of_range& e) {
6057       {
6058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6059       };
6060     } catch (std::exception& e) {
6061       {
6062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6063       };
6064     } catch (...) {
6065       {
6066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6067       };
6068     }
6069   }
6070 }
6071
6072
6073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6074   void * jresult ;
6075   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6076   float *result = 0 ;
6077
6078   arg1 = (Dali::Vector3 *)jarg1;
6079   {
6080     try {
6081       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6082     } catch (std::out_of_range& e) {
6083       {
6084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6085       };
6086     } catch (std::exception& e) {
6087       {
6088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6089       };
6090     } catch (...) {
6091       {
6092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6093       };
6094     }
6095   }
6096   jresult = (void *)result;
6097   return jresult;
6098 }
6099
6100
6101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6102   void * jresult ;
6103   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6104   Dali::Vector2 *result = 0 ;
6105
6106   arg1 = (Dali::Vector3 *)jarg1;
6107   {
6108     try {
6109       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6110     } catch (std::out_of_range& e) {
6111       {
6112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6113       };
6114     } catch (std::exception& e) {
6115       {
6116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6117       };
6118     } catch (...) {
6119       {
6120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6121       };
6122     }
6123   }
6124   jresult = (void *)result;
6125   return jresult;
6126 }
6127
6128
6129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6130   void * jresult ;
6131   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6132   Dali::Vector2 *result = 0 ;
6133
6134   arg1 = (Dali::Vector3 *)jarg1;
6135   {
6136     try {
6137       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6138     } catch (std::out_of_range& e) {
6139       {
6140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6141       };
6142     } catch (std::exception& e) {
6143       {
6144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6145       };
6146     } catch (...) {
6147       {
6148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6149       };
6150     }
6151   }
6152   jresult = (void *)result;
6153   return jresult;
6154 }
6155
6156
6157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6158   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6159   float arg2 ;
6160
6161   arg1 = (Dali::Vector3 *)jarg1;
6162   arg2 = (float)jarg2;
6163   if (arg1) (arg1)->x = arg2;
6164 }
6165
6166
6167 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6168   float jresult ;
6169   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6170   float result;
6171
6172   arg1 = (Dali::Vector3 *)jarg1;
6173   result = (float) ((arg1)->x);
6174   jresult = result;
6175   return jresult;
6176 }
6177
6178
6179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6180   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6181   float arg2 ;
6182
6183   arg1 = (Dali::Vector3 *)jarg1;
6184   arg2 = (float)jarg2;
6185   if (arg1) (arg1)->width = arg2;
6186 }
6187
6188
6189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6190   float jresult ;
6191   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6192   float result;
6193
6194   arg1 = (Dali::Vector3 *)jarg1;
6195   result = (float) ((arg1)->width);
6196   jresult = result;
6197   return jresult;
6198 }
6199
6200
6201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6202   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6203   float arg2 ;
6204
6205   arg1 = (Dali::Vector3 *)jarg1;
6206   arg2 = (float)jarg2;
6207   if (arg1) (arg1)->r = arg2;
6208 }
6209
6210
6211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6212   float jresult ;
6213   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6214   float result;
6215
6216   arg1 = (Dali::Vector3 *)jarg1;
6217   result = (float) ((arg1)->r);
6218   jresult = result;
6219   return jresult;
6220 }
6221
6222
6223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6224   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6225   float arg2 ;
6226
6227   arg1 = (Dali::Vector3 *)jarg1;
6228   arg2 = (float)jarg2;
6229   if (arg1) (arg1)->y = arg2;
6230 }
6231
6232
6233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6234   float jresult ;
6235   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6236   float result;
6237
6238   arg1 = (Dali::Vector3 *)jarg1;
6239   result = (float) ((arg1)->y);
6240   jresult = result;
6241   return jresult;
6242 }
6243
6244
6245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6246   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6247   float arg2 ;
6248
6249   arg1 = (Dali::Vector3 *)jarg1;
6250   arg2 = (float)jarg2;
6251   if (arg1) (arg1)->height = arg2;
6252 }
6253
6254
6255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6256   float jresult ;
6257   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6258   float result;
6259
6260   arg1 = (Dali::Vector3 *)jarg1;
6261   result = (float) ((arg1)->height);
6262   jresult = result;
6263   return jresult;
6264 }
6265
6266
6267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6268   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6269   float arg2 ;
6270
6271   arg1 = (Dali::Vector3 *)jarg1;
6272   arg2 = (float)jarg2;
6273   if (arg1) (arg1)->g = arg2;
6274 }
6275
6276
6277 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6278   float jresult ;
6279   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6280   float result;
6281
6282   arg1 = (Dali::Vector3 *)jarg1;
6283   result = (float) ((arg1)->g);
6284   jresult = result;
6285   return jresult;
6286 }
6287
6288
6289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6290   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6291   float arg2 ;
6292
6293   arg1 = (Dali::Vector3 *)jarg1;
6294   arg2 = (float)jarg2;
6295   if (arg1) (arg1)->z = arg2;
6296 }
6297
6298
6299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6300   float jresult ;
6301   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6302   float result;
6303
6304   arg1 = (Dali::Vector3 *)jarg1;
6305   result = (float) ((arg1)->z);
6306   jresult = result;
6307   return jresult;
6308 }
6309
6310
6311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6312   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6313   float arg2 ;
6314
6315   arg1 = (Dali::Vector3 *)jarg1;
6316   arg2 = (float)jarg2;
6317   if (arg1) (arg1)->depth = arg2;
6318 }
6319
6320
6321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6322   float jresult ;
6323   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6324   float result;
6325
6326   arg1 = (Dali::Vector3 *)jarg1;
6327   result = (float) ((arg1)->depth);
6328   jresult = result;
6329   return jresult;
6330 }
6331
6332
6333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6334   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6335   float arg2 ;
6336
6337   arg1 = (Dali::Vector3 *)jarg1;
6338   arg2 = (float)jarg2;
6339   if (arg1) (arg1)->b = arg2;
6340 }
6341
6342
6343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6344   float jresult ;
6345   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6346   float result;
6347
6348   arg1 = (Dali::Vector3 *)jarg1;
6349   result = (float) ((arg1)->b);
6350   jresult = result;
6351   return jresult;
6352 }
6353
6354
6355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6356   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6357
6358   arg1 = (Dali::Vector3 *)jarg1;
6359   {
6360     try {
6361       delete arg1;
6362     } catch (std::out_of_range& e) {
6363       {
6364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6365       };
6366     } catch (std::exception& e) {
6367       {
6368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6369       };
6370     } catch (...) {
6371       {
6372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6373       };
6374     }
6375   }
6376 }
6377
6378
6379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6380   void * jresult ;
6381   Dali::Vector3 *arg1 = 0 ;
6382   Dali::Vector3 *arg2 = 0 ;
6383   Dali::Vector3 result;
6384
6385   arg1 = (Dali::Vector3 *)jarg1;
6386   if (!arg1) {
6387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6388     return 0;
6389   }
6390   arg2 = (Dali::Vector3 *)jarg2;
6391   if (!arg2) {
6392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6393     return 0;
6394   }
6395   {
6396     try {
6397       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6398     } catch (std::out_of_range& e) {
6399       {
6400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6401       };
6402     } catch (std::exception& e) {
6403       {
6404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6405       };
6406     } catch (...) {
6407       {
6408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6409       };
6410     }
6411   }
6412   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6413   return jresult;
6414 }
6415
6416
6417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6418   void * jresult ;
6419   Dali::Vector3 *arg1 = 0 ;
6420   Dali::Vector3 *arg2 = 0 ;
6421   Dali::Vector3 result;
6422
6423   arg1 = (Dali::Vector3 *)jarg1;
6424   if (!arg1) {
6425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6426     return 0;
6427   }
6428   arg2 = (Dali::Vector3 *)jarg2;
6429   if (!arg2) {
6430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6431     return 0;
6432   }
6433   {
6434     try {
6435       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6436     } catch (std::out_of_range& e) {
6437       {
6438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6439       };
6440     } catch (std::exception& e) {
6441       {
6442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6443       };
6444     } catch (...) {
6445       {
6446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6447       };
6448     }
6449   }
6450   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6451   return jresult;
6452 }
6453
6454
6455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6456   void * jresult ;
6457   Dali::Vector3 *arg1 = 0 ;
6458   float *arg2 = 0 ;
6459   float *arg3 = 0 ;
6460   float temp2 ;
6461   float temp3 ;
6462   Dali::Vector3 result;
6463
6464   arg1 = (Dali::Vector3 *)jarg1;
6465   if (!arg1) {
6466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6467     return 0;
6468   }
6469   temp2 = (float)jarg2;
6470   arg2 = &temp2;
6471   temp3 = (float)jarg3;
6472   arg3 = &temp3;
6473   {
6474     try {
6475       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6476     } catch (std::out_of_range& e) {
6477       {
6478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6479       };
6480     } catch (std::exception& e) {
6481       {
6482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6483       };
6484     } catch (...) {
6485       {
6486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6487       };
6488     }
6489   }
6490   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6491   return jresult;
6492 }
6493
6494
6495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6496   void * jresult ;
6497   Dali::Vector4 *result = 0 ;
6498
6499   {
6500     try {
6501       result = (Dali::Vector4 *)new Dali::Vector4();
6502     } catch (std::out_of_range& e) {
6503       {
6504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6505       };
6506     } catch (std::exception& e) {
6507       {
6508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6509       };
6510     } catch (...) {
6511       {
6512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6513       };
6514     }
6515   }
6516   jresult = (void *)result;
6517   return jresult;
6518 }
6519
6520
6521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6522   void * jresult ;
6523   float arg1 ;
6524   float arg2 ;
6525   float arg3 ;
6526   float arg4 ;
6527   Dali::Vector4 *result = 0 ;
6528
6529   arg1 = (float)jarg1;
6530   arg2 = (float)jarg2;
6531   arg3 = (float)jarg3;
6532   arg4 = (float)jarg4;
6533   {
6534     try {
6535       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6536     } catch (std::out_of_range& e) {
6537       {
6538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6539       };
6540     } catch (std::exception& e) {
6541       {
6542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6543       };
6544     } catch (...) {
6545       {
6546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6547       };
6548     }
6549   }
6550   jresult = (void *)result;
6551   return jresult;
6552 }
6553
6554
6555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6556   void * jresult ;
6557   float *arg1 = (float *) 0 ;
6558   Dali::Vector4 *result = 0 ;
6559
6560   arg1 = jarg1;
6561   {
6562     try {
6563       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6564     } catch (std::out_of_range& e) {
6565       {
6566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6567       };
6568     } catch (std::exception& e) {
6569       {
6570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6571       };
6572     } catch (...) {
6573       {
6574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6575       };
6576     }
6577   }
6578   jresult = (void *)result;
6579
6580
6581   return jresult;
6582 }
6583
6584
6585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6586   void * jresult ;
6587   Dali::Vector2 *arg1 = 0 ;
6588   Dali::Vector4 *result = 0 ;
6589
6590   arg1 = (Dali::Vector2 *)jarg1;
6591   if (!arg1) {
6592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6593     return 0;
6594   }
6595   {
6596     try {
6597       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6598     } catch (std::out_of_range& e) {
6599       {
6600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6601       };
6602     } catch (std::exception& e) {
6603       {
6604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6605       };
6606     } catch (...) {
6607       {
6608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6609       };
6610     }
6611   }
6612   jresult = (void *)result;
6613   return jresult;
6614 }
6615
6616
6617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6618   void * jresult ;
6619   Dali::Vector3 *arg1 = 0 ;
6620   Dali::Vector4 *result = 0 ;
6621
6622   arg1 = (Dali::Vector3 *)jarg1;
6623   if (!arg1) {
6624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6625     return 0;
6626   }
6627   {
6628     try {
6629       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6630     } catch (std::out_of_range& e) {
6631       {
6632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6633       };
6634     } catch (std::exception& e) {
6635       {
6636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6637       };
6638     } catch (...) {
6639       {
6640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6641       };
6642     }
6643   }
6644   jresult = (void *)result;
6645   return jresult;
6646 }
6647
6648
6649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6650   void * jresult ;
6651   Dali::Vector4 *result = 0 ;
6652
6653   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6654   jresult = (void *)result;
6655   return jresult;
6656 }
6657
6658
6659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6660   void * jresult ;
6661   Dali::Vector4 *result = 0 ;
6662
6663   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6664   jresult = (void *)result;
6665   return jresult;
6666 }
6667
6668
6669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6670   void * jresult ;
6671   Dali::Vector4 *result = 0 ;
6672
6673   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6674   jresult = (void *)result;
6675   return jresult;
6676 }
6677
6678
6679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6680   void * jresult ;
6681   Dali::Vector4 *result = 0 ;
6682
6683   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6684   jresult = (void *)result;
6685   return jresult;
6686 }
6687
6688
6689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6690   void * jresult ;
6691   Dali::Vector4 *result = 0 ;
6692
6693   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6694   jresult = (void *)result;
6695   return jresult;
6696 }
6697
6698
6699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6700   void * jresult ;
6701   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6702   float *arg2 = (float *) 0 ;
6703   Dali::Vector4 *result = 0 ;
6704
6705   arg1 = (Dali::Vector4 *)jarg1;
6706   arg2 = jarg2;
6707   {
6708     try {
6709       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6710     } catch (std::out_of_range& e) {
6711       {
6712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6713       };
6714     } catch (std::exception& e) {
6715       {
6716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6717       };
6718     } catch (...) {
6719       {
6720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6721       };
6722     }
6723   }
6724   jresult = (void *)result;
6725
6726
6727   return jresult;
6728 }
6729
6730
6731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6732   void * jresult ;
6733   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6734   Dali::Vector2 *arg2 = 0 ;
6735   Dali::Vector4 *result = 0 ;
6736
6737   arg1 = (Dali::Vector4 *)jarg1;
6738   arg2 = (Dali::Vector2 *)jarg2;
6739   if (!arg2) {
6740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6741     return 0;
6742   }
6743   {
6744     try {
6745       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6746     } catch (std::out_of_range& e) {
6747       {
6748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6749       };
6750     } catch (std::exception& e) {
6751       {
6752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6753       };
6754     } catch (...) {
6755       {
6756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6757       };
6758     }
6759   }
6760   jresult = (void *)result;
6761   return jresult;
6762 }
6763
6764
6765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6766   void * jresult ;
6767   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6768   Dali::Vector3 *arg2 = 0 ;
6769   Dali::Vector4 *result = 0 ;
6770
6771   arg1 = (Dali::Vector4 *)jarg1;
6772   arg2 = (Dali::Vector3 *)jarg2;
6773   if (!arg2) {
6774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6775     return 0;
6776   }
6777   {
6778     try {
6779       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6780     } catch (std::out_of_range& e) {
6781       {
6782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6783       };
6784     } catch (std::exception& e) {
6785       {
6786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6787       };
6788     } catch (...) {
6789       {
6790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6791       };
6792     }
6793   }
6794   jresult = (void *)result;
6795   return jresult;
6796 }
6797
6798
6799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6800   void * jresult ;
6801   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6802   Dali::Vector4 *arg2 = 0 ;
6803   Dali::Vector4 result;
6804
6805   arg1 = (Dali::Vector4 *)jarg1;
6806   arg2 = (Dali::Vector4 *)jarg2;
6807   if (!arg2) {
6808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6809     return 0;
6810   }
6811   {
6812     try {
6813       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6814     } catch (std::out_of_range& e) {
6815       {
6816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6817       };
6818     } catch (std::exception& e) {
6819       {
6820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6821       };
6822     } catch (...) {
6823       {
6824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6825       };
6826     }
6827   }
6828   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6829   return jresult;
6830 }
6831
6832
6833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6834   void * jresult ;
6835   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6836   Dali::Vector4 *arg2 = 0 ;
6837   Dali::Vector4 *result = 0 ;
6838
6839   arg1 = (Dali::Vector4 *)jarg1;
6840   arg2 = (Dali::Vector4 *)jarg2;
6841   if (!arg2) {
6842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6843     return 0;
6844   }
6845   {
6846     try {
6847       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6848     } catch (std::out_of_range& e) {
6849       {
6850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6851       };
6852     } catch (std::exception& e) {
6853       {
6854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6855       };
6856     } catch (...) {
6857       {
6858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6859       };
6860     }
6861   }
6862   jresult = (void *)result;
6863   return jresult;
6864 }
6865
6866
6867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6868   void * jresult ;
6869   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6870   Dali::Vector4 *arg2 = 0 ;
6871   Dali::Vector4 result;
6872
6873   arg1 = (Dali::Vector4 *)jarg1;
6874   arg2 = (Dali::Vector4 *)jarg2;
6875   if (!arg2) {
6876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6877     return 0;
6878   }
6879   {
6880     try {
6881       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6882     } catch (std::out_of_range& e) {
6883       {
6884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6885       };
6886     } catch (std::exception& e) {
6887       {
6888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6889       };
6890     } catch (...) {
6891       {
6892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6893       };
6894     }
6895   }
6896   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6897   return jresult;
6898 }
6899
6900
6901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6902   void * jresult ;
6903   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6904   Dali::Vector4 *arg2 = 0 ;
6905   Dali::Vector4 *result = 0 ;
6906
6907   arg1 = (Dali::Vector4 *)jarg1;
6908   arg2 = (Dali::Vector4 *)jarg2;
6909   if (!arg2) {
6910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6911     return 0;
6912   }
6913   {
6914     try {
6915       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6916     } catch (std::out_of_range& e) {
6917       {
6918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6919       };
6920     } catch (std::exception& e) {
6921       {
6922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6923       };
6924     } catch (...) {
6925       {
6926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6927       };
6928     }
6929   }
6930   jresult = (void *)result;
6931   return jresult;
6932 }
6933
6934
6935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6936   void * jresult ;
6937   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6938   Dali::Vector4 *arg2 = 0 ;
6939   Dali::Vector4 result;
6940
6941   arg1 = (Dali::Vector4 *)jarg1;
6942   arg2 = (Dali::Vector4 *)jarg2;
6943   if (!arg2) {
6944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6945     return 0;
6946   }
6947   {
6948     try {
6949       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6950     } catch (std::out_of_range& e) {
6951       {
6952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6953       };
6954     } catch (std::exception& e) {
6955       {
6956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6957       };
6958     } catch (...) {
6959       {
6960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6961       };
6962     }
6963   }
6964   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6965   return jresult;
6966 }
6967
6968
6969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6970   void * jresult ;
6971   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6972   float arg2 ;
6973   Dali::Vector4 result;
6974
6975   arg1 = (Dali::Vector4 *)jarg1;
6976   arg2 = (float)jarg2;
6977   {
6978     try {
6979       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
6980     } catch (std::out_of_range& e) {
6981       {
6982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6983       };
6984     } catch (std::exception& e) {
6985       {
6986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6987       };
6988     } catch (...) {
6989       {
6990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6991       };
6992     }
6993   }
6994   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6995   return jresult;
6996 }
6997
6998
6999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7000   void * jresult ;
7001   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7002   Dali::Vector4 *arg2 = 0 ;
7003   Dali::Vector4 *result = 0 ;
7004
7005   arg1 = (Dali::Vector4 *)jarg1;
7006   arg2 = (Dali::Vector4 *)jarg2;
7007   if (!arg2) {
7008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7009     return 0;
7010   }
7011   {
7012     try {
7013       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7014     } catch (std::out_of_range& e) {
7015       {
7016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7017       };
7018     } catch (std::exception& e) {
7019       {
7020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7021       };
7022     } catch (...) {
7023       {
7024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7025       };
7026     }
7027   }
7028   jresult = (void *)result;
7029   return jresult;
7030 }
7031
7032
7033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7034   void * jresult ;
7035   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7036   float arg2 ;
7037   Dali::Vector4 *result = 0 ;
7038
7039   arg1 = (Dali::Vector4 *)jarg1;
7040   arg2 = (float)jarg2;
7041   {
7042     try {
7043       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7044     } catch (std::out_of_range& e) {
7045       {
7046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7047       };
7048     } catch (std::exception& e) {
7049       {
7050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7051       };
7052     } catch (...) {
7053       {
7054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7055       };
7056     }
7057   }
7058   jresult = (void *)result;
7059   return jresult;
7060 }
7061
7062
7063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7064   void * jresult ;
7065   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7066   Dali::Vector4 *arg2 = 0 ;
7067   Dali::Vector4 result;
7068
7069   arg1 = (Dali::Vector4 *)jarg1;
7070   arg2 = (Dali::Vector4 *)jarg2;
7071   if (!arg2) {
7072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7073     return 0;
7074   }
7075   {
7076     try {
7077       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7078     } catch (std::out_of_range& e) {
7079       {
7080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7081       };
7082     } catch (std::exception& e) {
7083       {
7084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7085       };
7086     } catch (...) {
7087       {
7088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7089       };
7090     }
7091   }
7092   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7093   return jresult;
7094 }
7095
7096
7097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7098   void * jresult ;
7099   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7100   float arg2 ;
7101   Dali::Vector4 result;
7102
7103   arg1 = (Dali::Vector4 *)jarg1;
7104   arg2 = (float)jarg2;
7105   {
7106     try {
7107       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7108     } catch (std::out_of_range& e) {
7109       {
7110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7111       };
7112     } catch (std::exception& e) {
7113       {
7114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7115       };
7116     } catch (...) {
7117       {
7118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7119       };
7120     }
7121   }
7122   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7123   return jresult;
7124 }
7125
7126
7127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7128   void * jresult ;
7129   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7130   Dali::Vector4 *arg2 = 0 ;
7131   Dali::Vector4 *result = 0 ;
7132
7133   arg1 = (Dali::Vector4 *)jarg1;
7134   arg2 = (Dali::Vector4 *)jarg2;
7135   if (!arg2) {
7136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7137     return 0;
7138   }
7139   {
7140     try {
7141       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7142     } catch (std::out_of_range& e) {
7143       {
7144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7145       };
7146     } catch (std::exception& e) {
7147       {
7148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7149       };
7150     } catch (...) {
7151       {
7152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7153       };
7154     }
7155   }
7156   jresult = (void *)result;
7157   return jresult;
7158 }
7159
7160
7161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7162   void * jresult ;
7163   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7164   float arg2 ;
7165   Dali::Vector4 *result = 0 ;
7166
7167   arg1 = (Dali::Vector4 *)jarg1;
7168   arg2 = (float)jarg2;
7169   {
7170     try {
7171       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7172     } catch (std::out_of_range& e) {
7173       {
7174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7175       };
7176     } catch (std::exception& e) {
7177       {
7178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7179       };
7180     } catch (...) {
7181       {
7182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7183       };
7184     }
7185   }
7186   jresult = (void *)result;
7187   return jresult;
7188 }
7189
7190
7191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7192   void * jresult ;
7193   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7194   Dali::Vector4 result;
7195
7196   arg1 = (Dali::Vector4 *)jarg1;
7197   {
7198     try {
7199       result = ((Dali::Vector4 const *)arg1)->operator -();
7200     } catch (std::out_of_range& e) {
7201       {
7202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7203       };
7204     } catch (std::exception& e) {
7205       {
7206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7207       };
7208     } catch (...) {
7209       {
7210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7211       };
7212     }
7213   }
7214   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7215   return jresult;
7216 }
7217
7218
7219 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7220   unsigned int jresult ;
7221   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7222   Dali::Vector4 *arg2 = 0 ;
7223   bool result;
7224
7225   arg1 = (Dali::Vector4 *)jarg1;
7226   arg2 = (Dali::Vector4 *)jarg2;
7227   if (!arg2) {
7228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7229     return 0;
7230   }
7231   {
7232     try {
7233       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7234     } catch (std::out_of_range& e) {
7235       {
7236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7237       };
7238     } catch (std::exception& e) {
7239       {
7240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7241       };
7242     } catch (...) {
7243       {
7244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7245       };
7246     }
7247   }
7248   jresult = result;
7249   return jresult;
7250 }
7251
7252
7253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7254   unsigned int jresult ;
7255   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7256   Dali::Vector4 *arg2 = 0 ;
7257   bool result;
7258
7259   arg1 = (Dali::Vector4 *)jarg1;
7260   arg2 = (Dali::Vector4 *)jarg2;
7261   if (!arg2) {
7262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7263     return 0;
7264   }
7265   {
7266     try {
7267       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7268     } catch (std::out_of_range& e) {
7269       {
7270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7271       };
7272     } catch (std::exception& e) {
7273       {
7274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7275       };
7276     } catch (...) {
7277       {
7278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7279       };
7280     }
7281   }
7282   jresult = result;
7283   return jresult;
7284 }
7285
7286
7287 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7288   float jresult ;
7289   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7290   unsigned int arg2 ;
7291   float *result = 0 ;
7292
7293   arg1 = (Dali::Vector4 *)jarg1;
7294   arg2 = (unsigned int)jarg2;
7295   {
7296     try {
7297       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7298     } catch (std::out_of_range& e) {
7299       {
7300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7301       };
7302     } catch (std::exception& e) {
7303       {
7304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7305       };
7306     } catch (...) {
7307       {
7308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7309       };
7310     }
7311   }
7312   jresult = *result;
7313   return jresult;
7314 }
7315
7316
7317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7318   float jresult ;
7319   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7320   Dali::Vector3 *arg2 = 0 ;
7321   float result;
7322
7323   arg1 = (Dali::Vector4 *)jarg1;
7324   arg2 = (Dali::Vector3 *)jarg2;
7325   if (!arg2) {
7326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7327     return 0;
7328   }
7329   {
7330     try {
7331       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7332     } catch (std::out_of_range& e) {
7333       {
7334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7335       };
7336     } catch (std::exception& e) {
7337       {
7338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7339       };
7340     } catch (...) {
7341       {
7342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7343       };
7344     }
7345   }
7346   jresult = result;
7347   return jresult;
7348 }
7349
7350
7351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7352   float jresult ;
7353   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7354   Dali::Vector4 *arg2 = 0 ;
7355   float result;
7356
7357   arg1 = (Dali::Vector4 *)jarg1;
7358   arg2 = (Dali::Vector4 *)jarg2;
7359   if (!arg2) {
7360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7361     return 0;
7362   }
7363   {
7364     try {
7365       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7366     } catch (std::out_of_range& e) {
7367       {
7368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7369       };
7370     } catch (std::exception& e) {
7371       {
7372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7373       };
7374     } catch (...) {
7375       {
7376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7377       };
7378     }
7379   }
7380   jresult = result;
7381   return jresult;
7382 }
7383
7384
7385 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7386   float jresult ;
7387   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7388   Dali::Vector4 *arg2 = 0 ;
7389   float result;
7390
7391   arg1 = (Dali::Vector4 *)jarg1;
7392   arg2 = (Dali::Vector4 *)jarg2;
7393   if (!arg2) {
7394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7395     return 0;
7396   }
7397   {
7398     try {
7399       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7400     } catch (std::out_of_range& e) {
7401       {
7402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7403       };
7404     } catch (std::exception& e) {
7405       {
7406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7407       };
7408     } catch (...) {
7409       {
7410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7411       };
7412     }
7413   }
7414   jresult = result;
7415   return jresult;
7416 }
7417
7418
7419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7420   void * jresult ;
7421   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7422   Dali::Vector4 *arg2 = 0 ;
7423   Dali::Vector4 result;
7424
7425   arg1 = (Dali::Vector4 *)jarg1;
7426   arg2 = (Dali::Vector4 *)jarg2;
7427   if (!arg2) {
7428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7429     return 0;
7430   }
7431   {
7432     try {
7433       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7434     } catch (std::out_of_range& e) {
7435       {
7436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7437       };
7438     } catch (std::exception& e) {
7439       {
7440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7441       };
7442     } catch (...) {
7443       {
7444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7445       };
7446     }
7447   }
7448   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7449   return jresult;
7450 }
7451
7452
7453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7454   float jresult ;
7455   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7456   float result;
7457
7458   arg1 = (Dali::Vector4 *)jarg1;
7459   {
7460     try {
7461       result = (float)((Dali::Vector4 const *)arg1)->Length();
7462     } catch (std::out_of_range& e) {
7463       {
7464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7465       };
7466     } catch (std::exception& e) {
7467       {
7468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7469       };
7470     } catch (...) {
7471       {
7472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7473       };
7474     }
7475   }
7476   jresult = result;
7477   return jresult;
7478 }
7479
7480
7481 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7482   float jresult ;
7483   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7484   float result;
7485
7486   arg1 = (Dali::Vector4 *)jarg1;
7487   {
7488     try {
7489       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7490     } catch (std::out_of_range& e) {
7491       {
7492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7493       };
7494     } catch (std::exception& e) {
7495       {
7496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7497       };
7498     } catch (...) {
7499       {
7500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7501       };
7502     }
7503   }
7504   jresult = result;
7505   return jresult;
7506 }
7507
7508
7509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7510   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7511
7512   arg1 = (Dali::Vector4 *)jarg1;
7513   {
7514     try {
7515       (arg1)->Normalize();
7516     } catch (std::out_of_range& e) {
7517       {
7518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7519       };
7520     } catch (std::exception& e) {
7521       {
7522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7523       };
7524     } catch (...) {
7525       {
7526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7527       };
7528     }
7529   }
7530 }
7531
7532
7533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7534   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7535   Dali::Vector4 *arg2 = 0 ;
7536   Dali::Vector4 *arg3 = 0 ;
7537
7538   arg1 = (Dali::Vector4 *)jarg1;
7539   arg2 = (Dali::Vector4 *)jarg2;
7540   if (!arg2) {
7541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7542     return ;
7543   }
7544   arg3 = (Dali::Vector4 *)jarg3;
7545   if (!arg3) {
7546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7547     return ;
7548   }
7549   {
7550     try {
7551       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7552     } catch (std::out_of_range& e) {
7553       {
7554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7555       };
7556     } catch (std::exception& e) {
7557       {
7558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7559       };
7560     } catch (...) {
7561       {
7562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7563       };
7564     }
7565   }
7566 }
7567
7568
7569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7570   void * jresult ;
7571   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7572   float *result = 0 ;
7573
7574   arg1 = (Dali::Vector4 *)jarg1;
7575   {
7576     try {
7577       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7578     } catch (std::out_of_range& e) {
7579       {
7580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7581       };
7582     } catch (std::exception& e) {
7583       {
7584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7585       };
7586     } catch (...) {
7587       {
7588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7589       };
7590     }
7591   }
7592   jresult = (void *)result;
7593   return jresult;
7594 }
7595
7596
7597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7598   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7599   float arg2 ;
7600
7601   arg1 = (Dali::Vector4 *)jarg1;
7602   arg2 = (float)jarg2;
7603   if (arg1) (arg1)->x = arg2;
7604 }
7605
7606
7607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7608   float jresult ;
7609   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7610   float result;
7611
7612   arg1 = (Dali::Vector4 *)jarg1;
7613   result = (float) ((arg1)->x);
7614   jresult = result;
7615   return jresult;
7616 }
7617
7618
7619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7620   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7621   float arg2 ;
7622
7623   arg1 = (Dali::Vector4 *)jarg1;
7624   arg2 = (float)jarg2;
7625   if (arg1) (arg1)->r = arg2;
7626 }
7627
7628
7629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7630   float jresult ;
7631   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7632   float result;
7633
7634   arg1 = (Dali::Vector4 *)jarg1;
7635   result = (float) ((arg1)->r);
7636   jresult = result;
7637   return jresult;
7638 }
7639
7640
7641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7642   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7643   float arg2 ;
7644
7645   arg1 = (Dali::Vector4 *)jarg1;
7646   arg2 = (float)jarg2;
7647   if (arg1) (arg1)->s = arg2;
7648 }
7649
7650
7651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7652   float jresult ;
7653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7654   float result;
7655
7656   arg1 = (Dali::Vector4 *)jarg1;
7657   result = (float) ((arg1)->s);
7658   jresult = result;
7659   return jresult;
7660 }
7661
7662
7663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7664   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7665   float arg2 ;
7666
7667   arg1 = (Dali::Vector4 *)jarg1;
7668   arg2 = (float)jarg2;
7669   if (arg1) (arg1)->y = arg2;
7670 }
7671
7672
7673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7674   float jresult ;
7675   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7676   float result;
7677
7678   arg1 = (Dali::Vector4 *)jarg1;
7679   result = (float) ((arg1)->y);
7680   jresult = result;
7681   return jresult;
7682 }
7683
7684
7685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7686   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7687   float arg2 ;
7688
7689   arg1 = (Dali::Vector4 *)jarg1;
7690   arg2 = (float)jarg2;
7691   if (arg1) (arg1)->g = arg2;
7692 }
7693
7694
7695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7696   float jresult ;
7697   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7698   float result;
7699
7700   arg1 = (Dali::Vector4 *)jarg1;
7701   result = (float) ((arg1)->g);
7702   jresult = result;
7703   return jresult;
7704 }
7705
7706
7707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7708   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7709   float arg2 ;
7710
7711   arg1 = (Dali::Vector4 *)jarg1;
7712   arg2 = (float)jarg2;
7713   if (arg1) (arg1)->t = arg2;
7714 }
7715
7716
7717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7718   float jresult ;
7719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7720   float result;
7721
7722   arg1 = (Dali::Vector4 *)jarg1;
7723   result = (float) ((arg1)->t);
7724   jresult = result;
7725   return jresult;
7726 }
7727
7728
7729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7731   float arg2 ;
7732
7733   arg1 = (Dali::Vector4 *)jarg1;
7734   arg2 = (float)jarg2;
7735   if (arg1) (arg1)->z = arg2;
7736 }
7737
7738
7739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7740   float jresult ;
7741   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7742   float result;
7743
7744   arg1 = (Dali::Vector4 *)jarg1;
7745   result = (float) ((arg1)->z);
7746   jresult = result;
7747   return jresult;
7748 }
7749
7750
7751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7752   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7753   float arg2 ;
7754
7755   arg1 = (Dali::Vector4 *)jarg1;
7756   arg2 = (float)jarg2;
7757   if (arg1) (arg1)->b = arg2;
7758 }
7759
7760
7761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7762   float jresult ;
7763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7764   float result;
7765
7766   arg1 = (Dali::Vector4 *)jarg1;
7767   result = (float) ((arg1)->b);
7768   jresult = result;
7769   return jresult;
7770 }
7771
7772
7773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7774   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7775   float arg2 ;
7776
7777   arg1 = (Dali::Vector4 *)jarg1;
7778   arg2 = (float)jarg2;
7779   if (arg1) (arg1)->p = arg2;
7780 }
7781
7782
7783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7784   float jresult ;
7785   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7786   float result;
7787
7788   arg1 = (Dali::Vector4 *)jarg1;
7789   result = (float) ((arg1)->p);
7790   jresult = result;
7791   return jresult;
7792 }
7793
7794
7795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7796   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7797   float arg2 ;
7798
7799   arg1 = (Dali::Vector4 *)jarg1;
7800   arg2 = (float)jarg2;
7801   if (arg1) (arg1)->w = arg2;
7802 }
7803
7804
7805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7806   float jresult ;
7807   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7808   float result;
7809
7810   arg1 = (Dali::Vector4 *)jarg1;
7811   result = (float) ((arg1)->w);
7812   jresult = result;
7813   return jresult;
7814 }
7815
7816
7817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7818   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7819   float arg2 ;
7820
7821   arg1 = (Dali::Vector4 *)jarg1;
7822   arg2 = (float)jarg2;
7823   if (arg1) (arg1)->a = arg2;
7824 }
7825
7826
7827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7828   float jresult ;
7829   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7830   float result;
7831
7832   arg1 = (Dali::Vector4 *)jarg1;
7833   result = (float) ((arg1)->a);
7834   jresult = result;
7835   return jresult;
7836 }
7837
7838
7839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7840   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7841   float arg2 ;
7842
7843   arg1 = (Dali::Vector4 *)jarg1;
7844   arg2 = (float)jarg2;
7845   if (arg1) (arg1)->q = arg2;
7846 }
7847
7848
7849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7850   float jresult ;
7851   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7852   float result;
7853
7854   arg1 = (Dali::Vector4 *)jarg1;
7855   result = (float) ((arg1)->q);
7856   jresult = result;
7857   return jresult;
7858 }
7859
7860
7861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7862   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7863
7864   arg1 = (Dali::Vector4 *)jarg1;
7865   {
7866     try {
7867       delete arg1;
7868     } catch (std::out_of_range& e) {
7869       {
7870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7871       };
7872     } catch (std::exception& e) {
7873       {
7874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7875       };
7876     } catch (...) {
7877       {
7878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7879       };
7880     }
7881   }
7882 }
7883
7884
7885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7886   void * jresult ;
7887   Dali::Vector4 *arg1 = 0 ;
7888   Dali::Vector4 *arg2 = 0 ;
7889   Dali::Vector4 result;
7890
7891   arg1 = (Dali::Vector4 *)jarg1;
7892   if (!arg1) {
7893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7894     return 0;
7895   }
7896   arg2 = (Dali::Vector4 *)jarg2;
7897   if (!arg2) {
7898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7899     return 0;
7900   }
7901   {
7902     try {
7903       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7904     } catch (std::out_of_range& e) {
7905       {
7906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7907       };
7908     } catch (std::exception& e) {
7909       {
7910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7911       };
7912     } catch (...) {
7913       {
7914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7915       };
7916     }
7917   }
7918   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7919   return jresult;
7920 }
7921
7922
7923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7924   void * jresult ;
7925   Dali::Vector4 *arg1 = 0 ;
7926   Dali::Vector4 *arg2 = 0 ;
7927   Dali::Vector4 result;
7928
7929   arg1 = (Dali::Vector4 *)jarg1;
7930   if (!arg1) {
7931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7932     return 0;
7933   }
7934   arg2 = (Dali::Vector4 *)jarg2;
7935   if (!arg2) {
7936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7937     return 0;
7938   }
7939   {
7940     try {
7941       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7942     } catch (std::out_of_range& e) {
7943       {
7944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7945       };
7946     } catch (std::exception& e) {
7947       {
7948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7949       };
7950     } catch (...) {
7951       {
7952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7953       };
7954     }
7955   }
7956   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7957   return jresult;
7958 }
7959
7960
7961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7962   void * jresult ;
7963   Dali::Vector4 *arg1 = 0 ;
7964   float *arg2 = 0 ;
7965   float *arg3 = 0 ;
7966   float temp2 ;
7967   float temp3 ;
7968   Dali::Vector4 result;
7969
7970   arg1 = (Dali::Vector4 *)jarg1;
7971   if (!arg1) {
7972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7973     return 0;
7974   }
7975   temp2 = (float)jarg2;
7976   arg2 = &temp2;
7977   temp3 = (float)jarg3;
7978   arg3 = &temp3;
7979   {
7980     try {
7981       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7982     } catch (std::out_of_range& e) {
7983       {
7984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7985       };
7986     } catch (std::exception& e) {
7987       {
7988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7989       };
7990     } catch (...) {
7991       {
7992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7993       };
7994     }
7995   }
7996   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7997   return jresult;
7998 }
7999
8000
8001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8002   void * jresult ;
8003   Dali::Uint16Pair *result = 0 ;
8004
8005   {
8006     try {
8007       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8008     } catch (std::out_of_range& e) {
8009       {
8010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8011       };
8012     } catch (std::exception& e) {
8013       {
8014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8015       };
8016     } catch (...) {
8017       {
8018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8019       };
8020     }
8021   }
8022   jresult = (void *)result;
8023   return jresult;
8024 }
8025
8026
8027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8028   void * jresult ;
8029   uint32_t arg1 ;
8030   uint32_t arg2 ;
8031   Dali::Uint16Pair *result = 0 ;
8032
8033   arg1 = (uint32_t)jarg1;
8034   arg2 = (uint32_t)jarg2;
8035   {
8036     try {
8037       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8038     } catch (std::out_of_range& e) {
8039       {
8040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8041       };
8042     } catch (std::exception& e) {
8043       {
8044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8045       };
8046     } catch (...) {
8047       {
8048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8049       };
8050     }
8051   }
8052   jresult = (void *)result;
8053   return jresult;
8054 }
8055
8056
8057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8058   void * jresult ;
8059   Dali::Uint16Pair *arg1 = 0 ;
8060   Dali::Uint16Pair *result = 0 ;
8061
8062   arg1 = (Dali::Uint16Pair *)jarg1;
8063   if (!arg1) {
8064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8065     return 0;
8066   }
8067   {
8068     try {
8069       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8070     } catch (std::out_of_range& e) {
8071       {
8072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8073       };
8074     } catch (std::exception& e) {
8075       {
8076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8077       };
8078     } catch (...) {
8079       {
8080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8081       };
8082     }
8083   }
8084   jresult = (void *)result;
8085   return jresult;
8086 }
8087
8088
8089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8090   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8091   uint16_t arg2 ;
8092
8093   arg1 = (Dali::Uint16Pair *)jarg1;
8094   arg2 = (uint16_t)jarg2;
8095   {
8096     try {
8097       (arg1)->SetWidth(arg2);
8098     } catch (std::out_of_range& e) {
8099       {
8100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8101       };
8102     } catch (std::exception& e) {
8103       {
8104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8105       };
8106     } catch (...) {
8107       {
8108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8109       };
8110     }
8111   }
8112 }
8113
8114
8115 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8116   unsigned short jresult ;
8117   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8118   uint16_t result;
8119
8120   arg1 = (Dali::Uint16Pair *)jarg1;
8121   {
8122     try {
8123       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8124     } catch (std::out_of_range& e) {
8125       {
8126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8127       };
8128     } catch (std::exception& e) {
8129       {
8130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8131       };
8132     } catch (...) {
8133       {
8134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8135       };
8136     }
8137   }
8138   jresult = result;
8139   return jresult;
8140 }
8141
8142
8143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8144   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8145   uint16_t arg2 ;
8146
8147   arg1 = (Dali::Uint16Pair *)jarg1;
8148   arg2 = (uint16_t)jarg2;
8149   {
8150     try {
8151       (arg1)->SetHeight(arg2);
8152     } catch (std::out_of_range& e) {
8153       {
8154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8155       };
8156     } catch (std::exception& e) {
8157       {
8158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8159       };
8160     } catch (...) {
8161       {
8162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8163       };
8164     }
8165   }
8166 }
8167
8168
8169 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8170   unsigned short jresult ;
8171   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8172   uint16_t result;
8173
8174   arg1 = (Dali::Uint16Pair *)jarg1;
8175   {
8176     try {
8177       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8178     } catch (std::out_of_range& e) {
8179       {
8180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8181       };
8182     } catch (std::exception& e) {
8183       {
8184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8185       };
8186     } catch (...) {
8187       {
8188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8189       };
8190     }
8191   }
8192   jresult = result;
8193   return jresult;
8194 }
8195
8196
8197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8198   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8199   uint16_t arg2 ;
8200
8201   arg1 = (Dali::Uint16Pair *)jarg1;
8202   arg2 = (uint16_t)jarg2;
8203   {
8204     try {
8205       (arg1)->SetX(arg2);
8206     } catch (std::out_of_range& e) {
8207       {
8208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8209       };
8210     } catch (std::exception& e) {
8211       {
8212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8213       };
8214     } catch (...) {
8215       {
8216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8217       };
8218     }
8219   }
8220 }
8221
8222
8223 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8224   unsigned short jresult ;
8225   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8226   uint16_t result;
8227
8228   arg1 = (Dali::Uint16Pair *)jarg1;
8229   {
8230     try {
8231       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8232     } catch (std::out_of_range& e) {
8233       {
8234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8235       };
8236     } catch (std::exception& e) {
8237       {
8238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8239       };
8240     } catch (...) {
8241       {
8242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8243       };
8244     }
8245   }
8246   jresult = result;
8247   return jresult;
8248 }
8249
8250
8251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8252   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8253   uint16_t arg2 ;
8254
8255   arg1 = (Dali::Uint16Pair *)jarg1;
8256   arg2 = (uint16_t)jarg2;
8257   {
8258     try {
8259       (arg1)->SetY(arg2);
8260     } catch (std::out_of_range& e) {
8261       {
8262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8263       };
8264     } catch (std::exception& e) {
8265       {
8266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8267       };
8268     } catch (...) {
8269       {
8270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8271       };
8272     }
8273   }
8274 }
8275
8276
8277 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8278   unsigned short jresult ;
8279   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8280   uint16_t result;
8281
8282   arg1 = (Dali::Uint16Pair *)jarg1;
8283   {
8284     try {
8285       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8286     } catch (std::out_of_range& e) {
8287       {
8288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8289       };
8290     } catch (std::exception& e) {
8291       {
8292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8293       };
8294     } catch (...) {
8295       {
8296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8297       };
8298     }
8299   }
8300   jresult = result;
8301   return jresult;
8302 }
8303
8304
8305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8306   void * jresult ;
8307   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8308   Dali::Uint16Pair *arg2 = 0 ;
8309   Dali::Uint16Pair *result = 0 ;
8310
8311   arg1 = (Dali::Uint16Pair *)jarg1;
8312   arg2 = (Dali::Uint16Pair *)jarg2;
8313   if (!arg2) {
8314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8315     return 0;
8316   }
8317   {
8318     try {
8319       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8320     } catch (std::out_of_range& e) {
8321       {
8322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8323       };
8324     } catch (std::exception& e) {
8325       {
8326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8327       };
8328     } catch (...) {
8329       {
8330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8331       };
8332     }
8333   }
8334   jresult = (void *)result;
8335   return jresult;
8336 }
8337
8338
8339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8340   unsigned int jresult ;
8341   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8342   Dali::Uint16Pair *arg2 = 0 ;
8343   bool result;
8344
8345   arg1 = (Dali::Uint16Pair *)jarg1;
8346   arg2 = (Dali::Uint16Pair *)jarg2;
8347   if (!arg2) {
8348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8349     return 0;
8350   }
8351   {
8352     try {
8353       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8354     } catch (std::out_of_range& e) {
8355       {
8356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8357       };
8358     } catch (std::exception& e) {
8359       {
8360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8361       };
8362     } catch (...) {
8363       {
8364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8365       };
8366     }
8367   }
8368   jresult = result;
8369   return jresult;
8370 }
8371
8372
8373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8374   unsigned int jresult ;
8375   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8376   Dali::Uint16Pair *arg2 = 0 ;
8377   bool result;
8378
8379   arg1 = (Dali::Uint16Pair *)jarg1;
8380   arg2 = (Dali::Uint16Pair *)jarg2;
8381   if (!arg2) {
8382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8383     return 0;
8384   }
8385   {
8386     try {
8387       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8388     } catch (std::out_of_range& e) {
8389       {
8390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8391       };
8392     } catch (std::exception& e) {
8393       {
8394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8395       };
8396     } catch (...) {
8397       {
8398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8399       };
8400     }
8401   }
8402   jresult = result;
8403   return jresult;
8404 }
8405
8406
8407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8408   unsigned int jresult ;
8409   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8410   Dali::Uint16Pair *arg2 = 0 ;
8411   bool result;
8412
8413   arg1 = (Dali::Uint16Pair *)jarg1;
8414   arg2 = (Dali::Uint16Pair *)jarg2;
8415   if (!arg2) {
8416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8417     return 0;
8418   }
8419   {
8420     try {
8421       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8422     } catch (std::out_of_range& e) {
8423       {
8424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8425       };
8426     } catch (std::exception& e) {
8427       {
8428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8429       };
8430     } catch (...) {
8431       {
8432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8433       };
8434     }
8435   }
8436   jresult = result;
8437   return jresult;
8438 }
8439
8440
8441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8442   unsigned int jresult ;
8443   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8444   Dali::Uint16Pair *arg2 = 0 ;
8445   bool result;
8446
8447   arg1 = (Dali::Uint16Pair *)jarg1;
8448   arg2 = (Dali::Uint16Pair *)jarg2;
8449   if (!arg2) {
8450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8451     return 0;
8452   }
8453   {
8454     try {
8455       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8456     } catch (std::out_of_range& e) {
8457       {
8458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8459       };
8460     } catch (std::exception& e) {
8461       {
8462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8463       };
8464     } catch (...) {
8465       {
8466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8467       };
8468     }
8469   }
8470   jresult = result;
8471   return jresult;
8472 }
8473
8474
8475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8476   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8477
8478   arg1 = (Dali::Uint16Pair *)jarg1;
8479   {
8480     try {
8481       delete arg1;
8482     } catch (std::out_of_range& e) {
8483       {
8484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8485       };
8486     } catch (std::exception& e) {
8487       {
8488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8489       };
8490     } catch (...) {
8491       {
8492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8493       };
8494     }
8495   }
8496 }
8497
8498
8499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8500   void * jresult ;
8501   Dali::Degree *result = 0 ;
8502
8503   {
8504     try {
8505       result = (Dali::Degree *)new Dali::Degree();
8506     } catch (std::out_of_range& e) {
8507       {
8508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8509       };
8510     } catch (std::exception& e) {
8511       {
8512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8513       };
8514     } catch (...) {
8515       {
8516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8517       };
8518     }
8519   }
8520   jresult = (void *)result;
8521   return jresult;
8522 }
8523
8524
8525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8526   void * jresult ;
8527   float arg1 ;
8528   Dali::Degree *result = 0 ;
8529
8530   arg1 = (float)jarg1;
8531   {
8532     try {
8533       result = (Dali::Degree *)new Dali::Degree(arg1);
8534     } catch (std::out_of_range& e) {
8535       {
8536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8537       };
8538     } catch (std::exception& e) {
8539       {
8540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8541       };
8542     } catch (...) {
8543       {
8544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8545       };
8546     }
8547   }
8548   jresult = (void *)result;
8549   return jresult;
8550 }
8551
8552
8553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8554   void * jresult ;
8555   Dali::Radian arg1 ;
8556   Dali::Radian *argp1 ;
8557   Dali::Degree *result = 0 ;
8558
8559   argp1 = (Dali::Radian *)jarg1;
8560   if (!argp1) {
8561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8562     return 0;
8563   }
8564   arg1 = *argp1;
8565   {
8566     try {
8567       result = (Dali::Degree *)new Dali::Degree(arg1);
8568     } catch (std::out_of_range& e) {
8569       {
8570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8571       };
8572     } catch (std::exception& e) {
8573       {
8574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8575       };
8576     } catch (...) {
8577       {
8578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8579       };
8580     }
8581   }
8582   jresult = (void *)result;
8583   return jresult;
8584 }
8585
8586
8587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8588   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8589   float arg2 ;
8590
8591   arg1 = (Dali::Degree *)jarg1;
8592   arg2 = (float)jarg2;
8593   if (arg1) (arg1)->degree = arg2;
8594 }
8595
8596
8597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8598   float jresult ;
8599   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8600   float result;
8601
8602   arg1 = (Dali::Degree *)jarg1;
8603   result = (float) ((arg1)->degree);
8604   jresult = result;
8605   return jresult;
8606 }
8607
8608
8609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8610   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8611
8612   arg1 = (Dali::Degree *)jarg1;
8613   {
8614     try {
8615       delete arg1;
8616     } catch (std::out_of_range& e) {
8617       {
8618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8619       };
8620     } catch (std::exception& e) {
8621       {
8622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8623       };
8624     } catch (...) {
8625       {
8626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8627       };
8628     }
8629   }
8630 }
8631
8632
8633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8634   void * jresult ;
8635   Dali::Radian *result = 0 ;
8636
8637   result = (Dali::Radian *)&Dali::ANGLE_360;
8638   jresult = (void *)result;
8639   return jresult;
8640 }
8641
8642
8643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8644   void * jresult ;
8645   Dali::Radian *result = 0 ;
8646
8647   result = (Dali::Radian *)&Dali::ANGLE_315;
8648   jresult = (void *)result;
8649   return jresult;
8650 }
8651
8652
8653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8654   void * jresult ;
8655   Dali::Radian *result = 0 ;
8656
8657   result = (Dali::Radian *)&Dali::ANGLE_270;
8658   jresult = (void *)result;
8659   return jresult;
8660 }
8661
8662
8663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8664   void * jresult ;
8665   Dali::Radian *result = 0 ;
8666
8667   result = (Dali::Radian *)&Dali::ANGLE_225;
8668   jresult = (void *)result;
8669   return jresult;
8670 }
8671
8672
8673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8674   void * jresult ;
8675   Dali::Radian *result = 0 ;
8676
8677   result = (Dali::Radian *)&Dali::ANGLE_180;
8678   jresult = (void *)result;
8679   return jresult;
8680 }
8681
8682
8683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8684   void * jresult ;
8685   Dali::Radian *result = 0 ;
8686
8687   result = (Dali::Radian *)&Dali::ANGLE_135;
8688   jresult = (void *)result;
8689   return jresult;
8690 }
8691
8692
8693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8694   void * jresult ;
8695   Dali::Radian *result = 0 ;
8696
8697   result = (Dali::Radian *)&Dali::ANGLE_120;
8698   jresult = (void *)result;
8699   return jresult;
8700 }
8701
8702
8703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8704   void * jresult ;
8705   Dali::Radian *result = 0 ;
8706
8707   result = (Dali::Radian *)&Dali::ANGLE_90;
8708   jresult = (void *)result;
8709   return jresult;
8710 }
8711
8712
8713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8714   void * jresult ;
8715   Dali::Radian *result = 0 ;
8716
8717   result = (Dali::Radian *)&Dali::ANGLE_60;
8718   jresult = (void *)result;
8719   return jresult;
8720 }
8721
8722
8723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8724   void * jresult ;
8725   Dali::Radian *result = 0 ;
8726
8727   result = (Dali::Radian *)&Dali::ANGLE_45;
8728   jresult = (void *)result;
8729   return jresult;
8730 }
8731
8732
8733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8734   void * jresult ;
8735   Dali::Radian *result = 0 ;
8736
8737   result = (Dali::Radian *)&Dali::ANGLE_30;
8738   jresult = (void *)result;
8739   return jresult;
8740 }
8741
8742
8743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8744   void * jresult ;
8745   Dali::Radian *result = 0 ;
8746
8747   result = (Dali::Radian *)&Dali::ANGLE_0;
8748   jresult = (void *)result;
8749   return jresult;
8750 }
8751
8752
8753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8754   unsigned int jresult ;
8755   Dali::Degree *arg1 = 0 ;
8756   Dali::Degree *arg2 = 0 ;
8757   bool result;
8758
8759   arg1 = (Dali::Degree *)jarg1;
8760   if (!arg1) {
8761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8762     return 0;
8763   }
8764   arg2 = (Dali::Degree *)jarg2;
8765   if (!arg2) {
8766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8767     return 0;
8768   }
8769   {
8770     try {
8771       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8772     } catch (std::out_of_range& e) {
8773       {
8774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8775       };
8776     } catch (std::exception& e) {
8777       {
8778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8779       };
8780     } catch (...) {
8781       {
8782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8783       };
8784     }
8785   }
8786   jresult = result;
8787   return jresult;
8788 }
8789
8790
8791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8792   unsigned int jresult ;
8793   Dali::Degree *arg1 = 0 ;
8794   Dali::Degree *arg2 = 0 ;
8795   bool result;
8796
8797   arg1 = (Dali::Degree *)jarg1;
8798   if (!arg1) {
8799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8800     return 0;
8801   }
8802   arg2 = (Dali::Degree *)jarg2;
8803   if (!arg2) {
8804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8805     return 0;
8806   }
8807   {
8808     try {
8809       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8810     } catch (std::out_of_range& e) {
8811       {
8812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8813       };
8814     } catch (std::exception& e) {
8815       {
8816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8817       };
8818     } catch (...) {
8819       {
8820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8821       };
8822     }
8823   }
8824   jresult = result;
8825   return jresult;
8826 }
8827
8828
8829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8830   void * jresult ;
8831   Dali::Degree arg1 ;
8832   float arg2 ;
8833   float arg3 ;
8834   Dali::Degree *argp1 ;
8835   Dali::Degree result;
8836
8837   argp1 = (Dali::Degree *)jarg1;
8838   if (!argp1) {
8839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8840     return 0;
8841   }
8842   arg1 = *argp1;
8843   arg2 = (float)jarg2;
8844   arg3 = (float)jarg3;
8845   {
8846     try {
8847       result = Dali::Clamp(arg1,arg2,arg3);
8848     } catch (std::out_of_range& e) {
8849       {
8850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8851       };
8852     } catch (std::exception& e) {
8853       {
8854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8855       };
8856     } catch (...) {
8857       {
8858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8859       };
8860     }
8861   }
8862   jresult = new Dali::Degree((const Dali::Degree &)result);
8863   return jresult;
8864 }
8865
8866
8867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8868   void * jresult ;
8869   Dali::Radian *result = 0 ;
8870
8871   {
8872     try {
8873       result = (Dali::Radian *)new Dali::Radian();
8874     } catch (std::out_of_range& e) {
8875       {
8876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8877       };
8878     } catch (std::exception& e) {
8879       {
8880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8881       };
8882     } catch (...) {
8883       {
8884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8885       };
8886     }
8887   }
8888   jresult = (void *)result;
8889   return jresult;
8890 }
8891
8892
8893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8894   void * jresult ;
8895   float arg1 ;
8896   Dali::Radian *result = 0 ;
8897
8898   arg1 = (float)jarg1;
8899   {
8900     try {
8901       result = (Dali::Radian *)new Dali::Radian(arg1);
8902     } catch (std::out_of_range& e) {
8903       {
8904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8905       };
8906     } catch (std::exception& e) {
8907       {
8908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8909       };
8910     } catch (...) {
8911       {
8912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8913       };
8914     }
8915   }
8916   jresult = (void *)result;
8917   return jresult;
8918 }
8919
8920
8921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8922   void * jresult ;
8923   Dali::Degree arg1 ;
8924   Dali::Degree *argp1 ;
8925   Dali::Radian *result = 0 ;
8926
8927   argp1 = (Dali::Degree *)jarg1;
8928   if (!argp1) {
8929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8930     return 0;
8931   }
8932   arg1 = *argp1;
8933   {
8934     try {
8935       result = (Dali::Radian *)new Dali::Radian(arg1);
8936     } catch (std::out_of_range& e) {
8937       {
8938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8939       };
8940     } catch (std::exception& e) {
8941       {
8942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8943       };
8944     } catch (...) {
8945       {
8946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8947       };
8948     }
8949   }
8950   jresult = (void *)result;
8951   return jresult;
8952 }
8953
8954
8955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8956   void * jresult ;
8957   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8958   float arg2 ;
8959   Dali::Radian *result = 0 ;
8960
8961   arg1 = (Dali::Radian *)jarg1;
8962   arg2 = (float)jarg2;
8963   {
8964     try {
8965       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8966     } catch (std::out_of_range& e) {
8967       {
8968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8969       };
8970     } catch (std::exception& e) {
8971       {
8972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8973       };
8974     } catch (...) {
8975       {
8976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8977       };
8978     }
8979   }
8980   jresult = (void *)result;
8981   return jresult;
8982 }
8983
8984
8985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8986   void * jresult ;
8987   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8988   Dali::Degree arg2 ;
8989   Dali::Degree *argp2 ;
8990   Dali::Radian *result = 0 ;
8991
8992   arg1 = (Dali::Radian *)jarg1;
8993   argp2 = (Dali::Degree *)jarg2;
8994   if (!argp2) {
8995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8996     return 0;
8997   }
8998   arg2 = *argp2;
8999   {
9000     try {
9001       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9002     } catch (std::out_of_range& e) {
9003       {
9004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9005       };
9006     } catch (std::exception& e) {
9007       {
9008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9009       };
9010     } catch (...) {
9011       {
9012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9013       };
9014     }
9015   }
9016   jresult = (void *)result;
9017   return jresult;
9018 }
9019
9020
9021 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9022   float jresult ;
9023   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9024   float result;
9025
9026   arg1 = (Dali::Radian *)jarg1;
9027   {
9028     try {
9029       result = (float)((Dali::Radian const *)arg1)->operator float();
9030     } catch (std::out_of_range& e) {
9031       {
9032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9033       };
9034     } catch (std::exception& e) {
9035       {
9036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9037       };
9038     } catch (...) {
9039       {
9040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9041       };
9042     }
9043   }
9044   jresult = result;
9045   return jresult;
9046 }
9047
9048
9049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9050   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9051   float arg2 ;
9052
9053   arg1 = (Dali::Radian *)jarg1;
9054   arg2 = (float)jarg2;
9055   if (arg1) (arg1)->radian = arg2;
9056 }
9057
9058
9059 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9060   float jresult ;
9061   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9062   float result;
9063
9064   arg1 = (Dali::Radian *)jarg1;
9065   result = (float) ((arg1)->radian);
9066   jresult = result;
9067   return jresult;
9068 }
9069
9070
9071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9072   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9073
9074   arg1 = (Dali::Radian *)jarg1;
9075   {
9076     try {
9077       delete arg1;
9078     } catch (std::out_of_range& e) {
9079       {
9080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9081       };
9082     } catch (std::exception& e) {
9083       {
9084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9085       };
9086     } catch (...) {
9087       {
9088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9089       };
9090     }
9091   }
9092 }
9093
9094
9095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9096   unsigned int jresult ;
9097   Dali::Radian arg1 ;
9098   Dali::Radian arg2 ;
9099   Dali::Radian *argp1 ;
9100   Dali::Radian *argp2 ;
9101   bool result;
9102
9103   argp1 = (Dali::Radian *)jarg1;
9104   if (!argp1) {
9105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9106     return 0;
9107   }
9108   arg1 = *argp1;
9109   argp2 = (Dali::Radian *)jarg2;
9110   if (!argp2) {
9111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9112     return 0;
9113   }
9114   arg2 = *argp2;
9115   {
9116     try {
9117       result = (bool)Dali::operator ==(arg1,arg2);
9118     } catch (std::out_of_range& e) {
9119       {
9120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9121       };
9122     } catch (std::exception& e) {
9123       {
9124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9125       };
9126     } catch (...) {
9127       {
9128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9129       };
9130     }
9131   }
9132   jresult = result;
9133   return jresult;
9134 }
9135
9136
9137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9138   unsigned int jresult ;
9139   Dali::Radian arg1 ;
9140   Dali::Radian arg2 ;
9141   Dali::Radian *argp1 ;
9142   Dali::Radian *argp2 ;
9143   bool result;
9144
9145   argp1 = (Dali::Radian *)jarg1;
9146   if (!argp1) {
9147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9148     return 0;
9149   }
9150   arg1 = *argp1;
9151   argp2 = (Dali::Radian *)jarg2;
9152   if (!argp2) {
9153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9154     return 0;
9155   }
9156   arg2 = *argp2;
9157   {
9158     try {
9159       result = (bool)Dali::operator !=(arg1,arg2);
9160     } catch (std::out_of_range& e) {
9161       {
9162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9163       };
9164     } catch (std::exception& e) {
9165       {
9166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9167       };
9168     } catch (...) {
9169       {
9170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9171       };
9172     }
9173   }
9174   jresult = result;
9175   return jresult;
9176 }
9177
9178
9179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9180   unsigned int jresult ;
9181   Dali::Radian arg1 ;
9182   Dali::Degree arg2 ;
9183   Dali::Radian *argp1 ;
9184   Dali::Degree *argp2 ;
9185   bool result;
9186
9187   argp1 = (Dali::Radian *)jarg1;
9188   if (!argp1) {
9189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9190     return 0;
9191   }
9192   arg1 = *argp1;
9193   argp2 = (Dali::Degree *)jarg2;
9194   if (!argp2) {
9195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9196     return 0;
9197   }
9198   arg2 = *argp2;
9199   {
9200     try {
9201       result = (bool)Dali::operator ==(arg1,arg2);
9202     } catch (std::out_of_range& e) {
9203       {
9204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9205       };
9206     } catch (std::exception& e) {
9207       {
9208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9209       };
9210     } catch (...) {
9211       {
9212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9213       };
9214     }
9215   }
9216   jresult = result;
9217   return jresult;
9218 }
9219
9220
9221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9222   unsigned int jresult ;
9223   Dali::Radian arg1 ;
9224   Dali::Degree arg2 ;
9225   Dali::Radian *argp1 ;
9226   Dali::Degree *argp2 ;
9227   bool result;
9228
9229   argp1 = (Dali::Radian *)jarg1;
9230   if (!argp1) {
9231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9232     return 0;
9233   }
9234   arg1 = *argp1;
9235   argp2 = (Dali::Degree *)jarg2;
9236   if (!argp2) {
9237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9238     return 0;
9239   }
9240   arg2 = *argp2;
9241   {
9242     try {
9243       result = (bool)Dali::operator !=(arg1,arg2);
9244     } catch (std::out_of_range& e) {
9245       {
9246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9247       };
9248     } catch (std::exception& e) {
9249       {
9250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9251       };
9252     } catch (...) {
9253       {
9254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9255       };
9256     }
9257   }
9258   jresult = result;
9259   return jresult;
9260 }
9261
9262
9263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9264   unsigned int jresult ;
9265   Dali::Degree arg1 ;
9266   Dali::Radian arg2 ;
9267   Dali::Degree *argp1 ;
9268   Dali::Radian *argp2 ;
9269   bool result;
9270
9271   argp1 = (Dali::Degree *)jarg1;
9272   if (!argp1) {
9273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9274     return 0;
9275   }
9276   arg1 = *argp1;
9277   argp2 = (Dali::Radian *)jarg2;
9278   if (!argp2) {
9279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9280     return 0;
9281   }
9282   arg2 = *argp2;
9283   {
9284     try {
9285       result = (bool)Dali::operator ==(arg1,arg2);
9286     } catch (std::out_of_range& e) {
9287       {
9288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9289       };
9290     } catch (std::exception& e) {
9291       {
9292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9293       };
9294     } catch (...) {
9295       {
9296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9297       };
9298     }
9299   }
9300   jresult = result;
9301   return jresult;
9302 }
9303
9304
9305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9306   unsigned int jresult ;
9307   Dali::Degree arg1 ;
9308   Dali::Radian arg2 ;
9309   Dali::Degree *argp1 ;
9310   Dali::Radian *argp2 ;
9311   bool result;
9312
9313   argp1 = (Dali::Degree *)jarg1;
9314   if (!argp1) {
9315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9316     return 0;
9317   }
9318   arg1 = *argp1;
9319   argp2 = (Dali::Radian *)jarg2;
9320   if (!argp2) {
9321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9322     return 0;
9323   }
9324   arg2 = *argp2;
9325   {
9326     try {
9327       result = (bool)Dali::operator !=(arg1,arg2);
9328     } catch (std::out_of_range& e) {
9329       {
9330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9331       };
9332     } catch (std::exception& e) {
9333       {
9334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9335       };
9336     } catch (...) {
9337       {
9338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9339       };
9340     }
9341   }
9342   jresult = result;
9343   return jresult;
9344 }
9345
9346
9347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9348   unsigned int jresult ;
9349   Dali::Radian arg1 ;
9350   Dali::Radian arg2 ;
9351   Dali::Radian *argp1 ;
9352   Dali::Radian *argp2 ;
9353   bool result;
9354
9355   argp1 = (Dali::Radian *)jarg1;
9356   if (!argp1) {
9357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9358     return 0;
9359   }
9360   arg1 = *argp1;
9361   argp2 = (Dali::Radian *)jarg2;
9362   if (!argp2) {
9363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9364     return 0;
9365   }
9366   arg2 = *argp2;
9367   {
9368     try {
9369       result = (bool)Dali::operator >(arg1,arg2);
9370     } catch (std::out_of_range& e) {
9371       {
9372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9373       };
9374     } catch (std::exception& e) {
9375       {
9376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9377       };
9378     } catch (...) {
9379       {
9380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9381       };
9382     }
9383   }
9384   jresult = result;
9385   return jresult;
9386 }
9387
9388
9389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9390   unsigned int jresult ;
9391   Dali::Radian arg1 ;
9392   Dali::Degree arg2 ;
9393   Dali::Radian *argp1 ;
9394   Dali::Degree *argp2 ;
9395   bool result;
9396
9397   argp1 = (Dali::Radian *)jarg1;
9398   if (!argp1) {
9399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9400     return 0;
9401   }
9402   arg1 = *argp1;
9403   argp2 = (Dali::Degree *)jarg2;
9404   if (!argp2) {
9405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9406     return 0;
9407   }
9408   arg2 = *argp2;
9409   {
9410     try {
9411       result = (bool)Dali::operator >(arg1,arg2);
9412     } catch (std::out_of_range& e) {
9413       {
9414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9415       };
9416     } catch (std::exception& e) {
9417       {
9418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9419       };
9420     } catch (...) {
9421       {
9422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9423       };
9424     }
9425   }
9426   jresult = result;
9427   return jresult;
9428 }
9429
9430
9431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9432   unsigned int jresult ;
9433   Dali::Degree arg1 ;
9434   Dali::Radian arg2 ;
9435   Dali::Degree *argp1 ;
9436   Dali::Radian *argp2 ;
9437   bool result;
9438
9439   argp1 = (Dali::Degree *)jarg1;
9440   if (!argp1) {
9441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9442     return 0;
9443   }
9444   arg1 = *argp1;
9445   argp2 = (Dali::Radian *)jarg2;
9446   if (!argp2) {
9447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9448     return 0;
9449   }
9450   arg2 = *argp2;
9451   {
9452     try {
9453       result = (bool)Dali::operator >(arg1,arg2);
9454     } catch (std::out_of_range& e) {
9455       {
9456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9457       };
9458     } catch (std::exception& e) {
9459       {
9460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9461       };
9462     } catch (...) {
9463       {
9464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9465       };
9466     }
9467   }
9468   jresult = result;
9469   return jresult;
9470 }
9471
9472
9473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9474   unsigned int jresult ;
9475   Dali::Radian arg1 ;
9476   Dali::Radian arg2 ;
9477   Dali::Radian *argp1 ;
9478   Dali::Radian *argp2 ;
9479   bool result;
9480
9481   argp1 = (Dali::Radian *)jarg1;
9482   if (!argp1) {
9483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9484     return 0;
9485   }
9486   arg1 = *argp1;
9487   argp2 = (Dali::Radian *)jarg2;
9488   if (!argp2) {
9489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9490     return 0;
9491   }
9492   arg2 = *argp2;
9493   {
9494     try {
9495       result = (bool)Dali::operator <(arg1,arg2);
9496     } catch (std::out_of_range& e) {
9497       {
9498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9499       };
9500     } catch (std::exception& e) {
9501       {
9502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9503       };
9504     } catch (...) {
9505       {
9506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9507       };
9508     }
9509   }
9510   jresult = result;
9511   return jresult;
9512 }
9513
9514
9515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9516   unsigned int jresult ;
9517   Dali::Radian arg1 ;
9518   Dali::Degree arg2 ;
9519   Dali::Radian *argp1 ;
9520   Dali::Degree *argp2 ;
9521   bool result;
9522
9523   argp1 = (Dali::Radian *)jarg1;
9524   if (!argp1) {
9525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9526     return 0;
9527   }
9528   arg1 = *argp1;
9529   argp2 = (Dali::Degree *)jarg2;
9530   if (!argp2) {
9531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9532     return 0;
9533   }
9534   arg2 = *argp2;
9535   {
9536     try {
9537       result = (bool)Dali::operator <(arg1,arg2);
9538     } catch (std::out_of_range& e) {
9539       {
9540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9541       };
9542     } catch (std::exception& e) {
9543       {
9544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9545       };
9546     } catch (...) {
9547       {
9548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9549       };
9550     }
9551   }
9552   jresult = result;
9553   return jresult;
9554 }
9555
9556
9557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9558   unsigned int jresult ;
9559   Dali::Degree arg1 ;
9560   Dali::Radian arg2 ;
9561   Dali::Degree *argp1 ;
9562   Dali::Radian *argp2 ;
9563   bool result;
9564
9565   argp1 = (Dali::Degree *)jarg1;
9566   if (!argp1) {
9567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9568     return 0;
9569   }
9570   arg1 = *argp1;
9571   argp2 = (Dali::Radian *)jarg2;
9572   if (!argp2) {
9573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9574     return 0;
9575   }
9576   arg2 = *argp2;
9577   {
9578     try {
9579       result = (bool)Dali::operator <(arg1,arg2);
9580     } catch (std::out_of_range& e) {
9581       {
9582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9583       };
9584     } catch (std::exception& e) {
9585       {
9586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9587       };
9588     } catch (...) {
9589       {
9590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9591       };
9592     }
9593   }
9594   jresult = result;
9595   return jresult;
9596 }
9597
9598
9599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9600   void * jresult ;
9601   Dali::Radian arg1 ;
9602   float arg2 ;
9603   Dali::Radian *argp1 ;
9604   Dali::Radian result;
9605
9606   argp1 = (Dali::Radian *)jarg1;
9607   if (!argp1) {
9608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9609     return 0;
9610   }
9611   arg1 = *argp1;
9612   arg2 = (float)jarg2;
9613   {
9614     try {
9615       result = Dali::operator *(arg1,arg2);
9616     } catch (std::out_of_range& e) {
9617       {
9618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9619       };
9620     } catch (std::exception& e) {
9621       {
9622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9623       };
9624     } catch (...) {
9625       {
9626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9627       };
9628     }
9629   }
9630   jresult = new Dali::Radian((const Dali::Radian &)result);
9631   return jresult;
9632 }
9633
9634
9635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9636   void * jresult ;
9637   Dali::Radian arg1 ;
9638   Dali::Radian *argp1 ;
9639   Dali::Radian result;
9640
9641   argp1 = (Dali::Radian *)jarg1;
9642   if (!argp1) {
9643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9644     return 0;
9645   }
9646   arg1 = *argp1;
9647   {
9648     try {
9649       result = Dali::operator -(arg1);
9650     } catch (std::out_of_range& e) {
9651       {
9652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9653       };
9654     } catch (std::exception& e) {
9655       {
9656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9657       };
9658     } catch (...) {
9659       {
9660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9661       };
9662     }
9663   }
9664   jresult = new Dali::Radian((const Dali::Radian &)result);
9665   return jresult;
9666 }
9667
9668
9669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9670   void * jresult ;
9671   Dali::Radian arg1 ;
9672   float arg2 ;
9673   float arg3 ;
9674   Dali::Radian *argp1 ;
9675   Dali::Radian result;
9676
9677   argp1 = (Dali::Radian *)jarg1;
9678   if (!argp1) {
9679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9680     return 0;
9681   }
9682   arg1 = *argp1;
9683   arg2 = (float)jarg2;
9684   arg3 = (float)jarg3;
9685   {
9686     try {
9687       result = Dali::Clamp(arg1,arg2,arg3);
9688     } catch (std::out_of_range& e) {
9689       {
9690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9691       };
9692     } catch (std::exception& e) {
9693       {
9694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9695       };
9696     } catch (...) {
9697       {
9698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9699       };
9700     }
9701   }
9702   jresult = new Dali::Radian((const Dali::Radian &)result);
9703   return jresult;
9704 }
9705
9706
9707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9708   void * jresult ;
9709   Dali::Quaternion *result = 0 ;
9710
9711   {
9712     try {
9713       result = (Dali::Quaternion *)new Dali::Quaternion();
9714     } catch (std::out_of_range& e) {
9715       {
9716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9717       };
9718     } catch (std::exception& e) {
9719       {
9720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9721       };
9722     } catch (...) {
9723       {
9724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9725       };
9726     }
9727   }
9728   jresult = (void *)result;
9729   return jresult;
9730 }
9731
9732
9733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9734   void * jresult ;
9735   Dali::Radian arg1 ;
9736   Dali::Vector3 *arg2 = 0 ;
9737   Dali::Radian *argp1 ;
9738   Dali::Quaternion *result = 0 ;
9739
9740   argp1 = (Dali::Radian *)jarg1;
9741   if (!argp1) {
9742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9743     return 0;
9744   }
9745   arg1 = *argp1;
9746   arg2 = (Dali::Vector3 *)jarg2;
9747   if (!arg2) {
9748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9749     return 0;
9750   }
9751   {
9752     try {
9753       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9754     } catch (std::out_of_range& e) {
9755       {
9756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9757       };
9758     } catch (std::exception& e) {
9759       {
9760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9761       };
9762     } catch (...) {
9763       {
9764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9765       };
9766     }
9767   }
9768   jresult = (void *)result;
9769   return jresult;
9770 }
9771
9772
9773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9774   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9775
9776   arg1 = (Dali::Quaternion *)jarg1;
9777   {
9778     try {
9779       delete arg1;
9780     } catch (std::out_of_range& e) {
9781       {
9782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9783       };
9784     } catch (std::exception& e) {
9785       {
9786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9787       };
9788     } catch (...) {
9789       {
9790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9791       };
9792     }
9793   }
9794 }
9795
9796
9797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9798   void * jresult ;
9799   Dali::Quaternion *result = 0 ;
9800
9801   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9802   jresult = (void *)result;
9803   return jresult;
9804 }
9805
9806
9807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9808   unsigned int jresult ;
9809   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9810   bool result;
9811
9812   arg1 = (Dali::Quaternion *)jarg1;
9813   {
9814     try {
9815       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9816     } catch (std::out_of_range& e) {
9817       {
9818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9819       };
9820     } catch (std::exception& e) {
9821       {
9822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9823       };
9824     } catch (...) {
9825       {
9826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9827       };
9828     }
9829   }
9830   jresult = result;
9831   return jresult;
9832 }
9833
9834
9835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9836   unsigned int jresult ;
9837   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9838   Dali::Vector3 *arg2 = 0 ;
9839   Dali::Radian *arg3 = 0 ;
9840   bool result;
9841
9842   arg1 = (Dali::Quaternion *)jarg1;
9843   arg2 = (Dali::Vector3 *)jarg2;
9844   if (!arg2) {
9845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9846     return 0;
9847   }
9848   arg3 = (Dali::Radian *)jarg3;
9849   if (!arg3) {
9850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9851     return 0;
9852   }
9853   {
9854     try {
9855       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9856     } catch (std::out_of_range& e) {
9857       {
9858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9859       };
9860     } catch (std::exception& e) {
9861       {
9862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9863       };
9864     } catch (...) {
9865       {
9866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9867       };
9868     }
9869   }
9870   jresult = result;
9871   return jresult;
9872 }
9873
9874
9875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9876   void * jresult ;
9877   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9878   Dali::Quaternion *arg2 = 0 ;
9879   Dali::Quaternion result;
9880
9881   arg1 = (Dali::Quaternion *)jarg1;
9882   arg2 = (Dali::Quaternion *)jarg2;
9883   if (!arg2) {
9884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9885     return 0;
9886   }
9887   {
9888     try {
9889       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9890     } catch (std::out_of_range& e) {
9891       {
9892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9893       };
9894     } catch (std::exception& e) {
9895       {
9896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9897       };
9898     } catch (...) {
9899       {
9900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9901       };
9902     }
9903   }
9904   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9905   return jresult;
9906 }
9907
9908
9909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9910   void * jresult ;
9911   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9912   Dali::Quaternion *arg2 = 0 ;
9913   Dali::Quaternion result;
9914
9915   arg1 = (Dali::Quaternion *)jarg1;
9916   arg2 = (Dali::Quaternion *)jarg2;
9917   if (!arg2) {
9918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9919     return 0;
9920   }
9921   {
9922     try {
9923       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9924     } catch (std::out_of_range& e) {
9925       {
9926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9927       };
9928     } catch (std::exception& e) {
9929       {
9930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9931       };
9932     } catch (...) {
9933       {
9934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9935       };
9936     }
9937   }
9938   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9939   return jresult;
9940 }
9941
9942
9943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
9944   void * jresult ;
9945   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9946   Dali::Quaternion *arg2 = 0 ;
9947   Dali::Quaternion result;
9948
9949   arg1 = (Dali::Quaternion *)jarg1;
9950   arg2 = (Dali::Quaternion *)jarg2;
9951   if (!arg2) {
9952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9953     return 0;
9954   }
9955   {
9956     try {
9957       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
9958     } catch (std::out_of_range& e) {
9959       {
9960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9961       };
9962     } catch (std::exception& e) {
9963       {
9964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9965       };
9966     } catch (...) {
9967       {
9968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9969       };
9970     }
9971   }
9972   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9973   return jresult;
9974 }
9975
9976
9977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
9978   void * jresult ;
9979   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9980   Dali::Vector3 *arg2 = 0 ;
9981   Dali::Vector3 result;
9982
9983   arg1 = (Dali::Quaternion *)jarg1;
9984   arg2 = (Dali::Vector3 *)jarg2;
9985   if (!arg2) {
9986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9987     return 0;
9988   }
9989   {
9990     try {
9991       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
9992     } catch (std::out_of_range& e) {
9993       {
9994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9995       };
9996     } catch (std::exception& e) {
9997       {
9998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9999       };
10000     } catch (...) {
10001       {
10002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10003       };
10004     }
10005   }
10006   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10007   return jresult;
10008 }
10009
10010
10011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10012   void * jresult ;
10013   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10014   Dali::Quaternion *arg2 = 0 ;
10015   Dali::Quaternion result;
10016
10017   arg1 = (Dali::Quaternion *)jarg1;
10018   arg2 = (Dali::Quaternion *)jarg2;
10019   if (!arg2) {
10020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10021     return 0;
10022   }
10023   {
10024     try {
10025       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10026     } catch (std::out_of_range& e) {
10027       {
10028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10029       };
10030     } catch (std::exception& e) {
10031       {
10032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10033       };
10034     } catch (...) {
10035       {
10036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10037       };
10038     }
10039   }
10040   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10041   return jresult;
10042 }
10043
10044
10045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10046   void * jresult ;
10047   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10048   float arg2 ;
10049   Dali::Quaternion result;
10050
10051   arg1 = (Dali::Quaternion *)jarg1;
10052   arg2 = (float)jarg2;
10053   {
10054     try {
10055       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10056     } catch (std::out_of_range& e) {
10057       {
10058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10059       };
10060     } catch (std::exception& e) {
10061       {
10062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10063       };
10064     } catch (...) {
10065       {
10066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10067       };
10068     }
10069   }
10070   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10071   return jresult;
10072 }
10073
10074
10075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10076   void * jresult ;
10077   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10078   float arg2 ;
10079   Dali::Quaternion result;
10080
10081   arg1 = (Dali::Quaternion *)jarg1;
10082   arg2 = (float)jarg2;
10083   {
10084     try {
10085       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10086     } catch (std::out_of_range& e) {
10087       {
10088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10089       };
10090     } catch (std::exception& e) {
10091       {
10092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10093       };
10094     } catch (...) {
10095       {
10096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10097       };
10098     }
10099   }
10100   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10101   return jresult;
10102 }
10103
10104
10105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10106   void * jresult ;
10107   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10108   Dali::Quaternion result;
10109
10110   arg1 = (Dali::Quaternion *)jarg1;
10111   {
10112     try {
10113       result = ((Dali::Quaternion const *)arg1)->operator -();
10114     } catch (std::out_of_range& e) {
10115       {
10116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10117       };
10118     } catch (std::exception& e) {
10119       {
10120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10121       };
10122     } catch (...) {
10123       {
10124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10125       };
10126     }
10127   }
10128   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10129   return jresult;
10130 }
10131
10132
10133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10134   void * jresult ;
10135   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10136   Dali::Quaternion *arg2 = 0 ;
10137   Dali::Quaternion *result = 0 ;
10138
10139   arg1 = (Dali::Quaternion *)jarg1;
10140   arg2 = (Dali::Quaternion *)jarg2;
10141   if (!arg2) {
10142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10143     return 0;
10144   }
10145   {
10146     try {
10147       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10148     } catch (std::out_of_range& e) {
10149       {
10150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10151       };
10152     } catch (std::exception& e) {
10153       {
10154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10155       };
10156     } catch (...) {
10157       {
10158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10159       };
10160     }
10161   }
10162   jresult = (void *)result;
10163   return jresult;
10164 }
10165
10166
10167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10168   void * jresult ;
10169   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10170   Dali::Quaternion *arg2 = 0 ;
10171   Dali::Quaternion *result = 0 ;
10172
10173   arg1 = (Dali::Quaternion *)jarg1;
10174   arg2 = (Dali::Quaternion *)jarg2;
10175   if (!arg2) {
10176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10177     return 0;
10178   }
10179   {
10180     try {
10181       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10182     } catch (std::out_of_range& e) {
10183       {
10184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10185       };
10186     } catch (std::exception& e) {
10187       {
10188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10189       };
10190     } catch (...) {
10191       {
10192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10193       };
10194     }
10195   }
10196   jresult = (void *)result;
10197   return jresult;
10198 }
10199
10200
10201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10202   void * jresult ;
10203   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10204   Dali::Quaternion *arg2 = 0 ;
10205   Dali::Quaternion *result = 0 ;
10206
10207   arg1 = (Dali::Quaternion *)jarg1;
10208   arg2 = (Dali::Quaternion *)jarg2;
10209   if (!arg2) {
10210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10211     return 0;
10212   }
10213   {
10214     try {
10215       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10216     } catch (std::out_of_range& e) {
10217       {
10218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10219       };
10220     } catch (std::exception& e) {
10221       {
10222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10223       };
10224     } catch (...) {
10225       {
10226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10227       };
10228     }
10229   }
10230   jresult = (void *)result;
10231   return jresult;
10232 }
10233
10234
10235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10236   void * jresult ;
10237   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10238   float arg2 ;
10239   Dali::Quaternion *result = 0 ;
10240
10241   arg1 = (Dali::Quaternion *)jarg1;
10242   arg2 = (float)jarg2;
10243   {
10244     try {
10245       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10246     } catch (std::out_of_range& e) {
10247       {
10248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10249       };
10250     } catch (std::exception& e) {
10251       {
10252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10253       };
10254     } catch (...) {
10255       {
10256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10257       };
10258     }
10259   }
10260   jresult = (void *)result;
10261   return jresult;
10262 }
10263
10264
10265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10266   void * jresult ;
10267   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10268   float arg2 ;
10269   Dali::Quaternion *result = 0 ;
10270
10271   arg1 = (Dali::Quaternion *)jarg1;
10272   arg2 = (float)jarg2;
10273   {
10274     try {
10275       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10276     } catch (std::out_of_range& e) {
10277       {
10278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10279       };
10280     } catch (std::exception& e) {
10281       {
10282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10283       };
10284     } catch (...) {
10285       {
10286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10287       };
10288     }
10289   }
10290   jresult = (void *)result;
10291   return jresult;
10292 }
10293
10294
10295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10296   unsigned int jresult ;
10297   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10298   Dali::Quaternion *arg2 = 0 ;
10299   bool result;
10300
10301   arg1 = (Dali::Quaternion *)jarg1;
10302   arg2 = (Dali::Quaternion *)jarg2;
10303   if (!arg2) {
10304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10305     return 0;
10306   }
10307   {
10308     try {
10309       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10310     } catch (std::out_of_range& e) {
10311       {
10312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10313       };
10314     } catch (std::exception& e) {
10315       {
10316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10317       };
10318     } catch (...) {
10319       {
10320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10321       };
10322     }
10323   }
10324   jresult = result;
10325   return jresult;
10326 }
10327
10328
10329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10330   unsigned int jresult ;
10331   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10332   Dali::Quaternion *arg2 = 0 ;
10333   bool result;
10334
10335   arg1 = (Dali::Quaternion *)jarg1;
10336   arg2 = (Dali::Quaternion *)jarg2;
10337   if (!arg2) {
10338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10339     return 0;
10340   }
10341   {
10342     try {
10343       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10344     } catch (std::out_of_range& e) {
10345       {
10346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10347       };
10348     } catch (std::exception& e) {
10349       {
10350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10351       };
10352     } catch (...) {
10353       {
10354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10355       };
10356     }
10357   }
10358   jresult = result;
10359   return jresult;
10360 }
10361
10362
10363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10364   float jresult ;
10365   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10366   float result;
10367
10368   arg1 = (Dali::Quaternion *)jarg1;
10369   {
10370     try {
10371       result = (float)((Dali::Quaternion const *)arg1)->Length();
10372     } catch (std::out_of_range& e) {
10373       {
10374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10375       };
10376     } catch (std::exception& e) {
10377       {
10378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10379       };
10380     } catch (...) {
10381       {
10382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10383       };
10384     }
10385   }
10386   jresult = result;
10387   return jresult;
10388 }
10389
10390
10391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10392   float jresult ;
10393   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10394   float result;
10395
10396   arg1 = (Dali::Quaternion *)jarg1;
10397   {
10398     try {
10399       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10400     } catch (std::out_of_range& e) {
10401       {
10402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10403       };
10404     } catch (std::exception& e) {
10405       {
10406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10407       };
10408     } catch (...) {
10409       {
10410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10411       };
10412     }
10413   }
10414   jresult = result;
10415   return jresult;
10416 }
10417
10418
10419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10420   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10421
10422   arg1 = (Dali::Quaternion *)jarg1;
10423   {
10424     try {
10425       (arg1)->Normalize();
10426     } catch (std::out_of_range& e) {
10427       {
10428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10429       };
10430     } catch (std::exception& e) {
10431       {
10432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10433       };
10434     } catch (...) {
10435       {
10436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10437       };
10438     }
10439   }
10440 }
10441
10442
10443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10444   void * jresult ;
10445   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10446   Dali::Quaternion result;
10447
10448   arg1 = (Dali::Quaternion *)jarg1;
10449   {
10450     try {
10451       result = ((Dali::Quaternion const *)arg1)->Normalized();
10452     } catch (std::out_of_range& e) {
10453       {
10454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10455       };
10456     } catch (std::exception& e) {
10457       {
10458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10459       };
10460     } catch (...) {
10461       {
10462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10463       };
10464     }
10465   }
10466   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10467   return jresult;
10468 }
10469
10470
10471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10472   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10473
10474   arg1 = (Dali::Quaternion *)jarg1;
10475   {
10476     try {
10477       (arg1)->Conjugate();
10478     } catch (std::out_of_range& e) {
10479       {
10480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10481       };
10482     } catch (std::exception& e) {
10483       {
10484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10485       };
10486     } catch (...) {
10487       {
10488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10489       };
10490     }
10491   }
10492 }
10493
10494
10495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10496   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10497
10498   arg1 = (Dali::Quaternion *)jarg1;
10499   {
10500     try {
10501       (arg1)->Invert();
10502     } catch (std::out_of_range& e) {
10503       {
10504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10505       };
10506     } catch (std::exception& e) {
10507       {
10508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10509       };
10510     } catch (...) {
10511       {
10512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10513       };
10514     }
10515   }
10516 }
10517
10518
10519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10520   void * jresult ;
10521   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10522   Dali::Quaternion result;
10523
10524   arg1 = (Dali::Quaternion *)jarg1;
10525   {
10526     try {
10527       result = ((Dali::Quaternion const *)arg1)->Log();
10528     } catch (std::out_of_range& e) {
10529       {
10530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10531       };
10532     } catch (std::exception& e) {
10533       {
10534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10535       };
10536     } catch (...) {
10537       {
10538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10539       };
10540     }
10541   }
10542   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10543   return jresult;
10544 }
10545
10546
10547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10548   void * jresult ;
10549   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10550   Dali::Quaternion result;
10551
10552   arg1 = (Dali::Quaternion *)jarg1;
10553   {
10554     try {
10555       result = ((Dali::Quaternion const *)arg1)->Exp();
10556     } catch (std::out_of_range& e) {
10557       {
10558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10559       };
10560     } catch (std::exception& e) {
10561       {
10562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10563       };
10564     } catch (...) {
10565       {
10566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10567       };
10568     }
10569   }
10570   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10571   return jresult;
10572 }
10573
10574
10575 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10576   float jresult ;
10577   Dali::Quaternion *arg1 = 0 ;
10578   Dali::Quaternion *arg2 = 0 ;
10579   float result;
10580
10581   arg1 = (Dali::Quaternion *)jarg1;
10582   if (!arg1) {
10583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10584     return 0;
10585   }
10586   arg2 = (Dali::Quaternion *)jarg2;
10587   if (!arg2) {
10588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10589     return 0;
10590   }
10591   {
10592     try {
10593       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10594     } catch (std::out_of_range& e) {
10595       {
10596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10597       };
10598     } catch (std::exception& e) {
10599       {
10600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10601       };
10602     } catch (...) {
10603       {
10604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10605       };
10606     }
10607   }
10608   jresult = result;
10609   return jresult;
10610 }
10611
10612
10613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10614   void * jresult ;
10615   Dali::Quaternion *arg1 = 0 ;
10616   Dali::Quaternion *arg2 = 0 ;
10617   float arg3 ;
10618   Dali::Quaternion result;
10619
10620   arg1 = (Dali::Quaternion *)jarg1;
10621   if (!arg1) {
10622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10623     return 0;
10624   }
10625   arg2 = (Dali::Quaternion *)jarg2;
10626   if (!arg2) {
10627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10628     return 0;
10629   }
10630   arg3 = (float)jarg3;
10631   {
10632     try {
10633       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10634     } catch (std::out_of_range& e) {
10635       {
10636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10637       };
10638     } catch (std::exception& e) {
10639       {
10640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10641       };
10642     } catch (...) {
10643       {
10644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10645       };
10646     }
10647   }
10648   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10649   return jresult;
10650 }
10651
10652
10653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10654   void * jresult ;
10655   Dali::Quaternion *arg1 = 0 ;
10656   Dali::Quaternion *arg2 = 0 ;
10657   float arg3 ;
10658   Dali::Quaternion result;
10659
10660   arg1 = (Dali::Quaternion *)jarg1;
10661   if (!arg1) {
10662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10663     return 0;
10664   }
10665   arg2 = (Dali::Quaternion *)jarg2;
10666   if (!arg2) {
10667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10668     return 0;
10669   }
10670   arg3 = (float)jarg3;
10671   {
10672     try {
10673       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10674     } catch (std::out_of_range& e) {
10675       {
10676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10677       };
10678     } catch (std::exception& e) {
10679       {
10680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10681       };
10682     } catch (...) {
10683       {
10684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10685       };
10686     }
10687   }
10688   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10689   return jresult;
10690 }
10691
10692
10693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10694   void * jresult ;
10695   Dali::Quaternion *arg1 = 0 ;
10696   Dali::Quaternion *arg2 = 0 ;
10697   float arg3 ;
10698   Dali::Quaternion result;
10699
10700   arg1 = (Dali::Quaternion *)jarg1;
10701   if (!arg1) {
10702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10703     return 0;
10704   }
10705   arg2 = (Dali::Quaternion *)jarg2;
10706   if (!arg2) {
10707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10708     return 0;
10709   }
10710   arg3 = (float)jarg3;
10711   {
10712     try {
10713       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10714     } catch (std::out_of_range& e) {
10715       {
10716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10717       };
10718     } catch (std::exception& e) {
10719       {
10720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10721       };
10722     } catch (...) {
10723       {
10724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10725       };
10726     }
10727   }
10728   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10729   return jresult;
10730 }
10731
10732
10733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10734   void * jresult ;
10735   Dali::Quaternion *arg1 = 0 ;
10736   Dali::Quaternion *arg2 = 0 ;
10737   Dali::Quaternion *arg3 = 0 ;
10738   Dali::Quaternion *arg4 = 0 ;
10739   float arg5 ;
10740   Dali::Quaternion result;
10741
10742   arg1 = (Dali::Quaternion *)jarg1;
10743   if (!arg1) {
10744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10745     return 0;
10746   }
10747   arg2 = (Dali::Quaternion *)jarg2;
10748   if (!arg2) {
10749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10750     return 0;
10751   }
10752   arg3 = (Dali::Quaternion *)jarg3;
10753   if (!arg3) {
10754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10755     return 0;
10756   }
10757   arg4 = (Dali::Quaternion *)jarg4;
10758   if (!arg4) {
10759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10760     return 0;
10761   }
10762   arg5 = (float)jarg5;
10763   {
10764     try {
10765       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10766     } catch (std::out_of_range& e) {
10767       {
10768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10769       };
10770     } catch (std::exception& e) {
10771       {
10772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10773       };
10774     } catch (...) {
10775       {
10776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10777       };
10778     }
10779   }
10780   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10781   return jresult;
10782 }
10783
10784
10785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10786   float jresult ;
10787   Dali::Quaternion *arg1 = 0 ;
10788   Dali::Quaternion *arg2 = 0 ;
10789   float result;
10790
10791   arg1 = (Dali::Quaternion *)jarg1;
10792   if (!arg1) {
10793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10794     return 0;
10795   }
10796   arg2 = (Dali::Quaternion *)jarg2;
10797   if (!arg2) {
10798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10799     return 0;
10800   }
10801   {
10802     try {
10803       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10804     } catch (std::out_of_range& e) {
10805       {
10806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10807       };
10808     } catch (std::exception& e) {
10809       {
10810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10811       };
10812     } catch (...) {
10813       {
10814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10815       };
10816     }
10817   }
10818   jresult = result;
10819   return jresult;
10820 }
10821
10822
10823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10824   void * jresult ;
10825   Dali::Matrix *result = 0 ;
10826
10827   {
10828     try {
10829       result = (Dali::Matrix *)new Dali::Matrix();
10830     } catch (std::out_of_range& e) {
10831       {
10832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10833       };
10834     } catch (std::exception& e) {
10835       {
10836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10837       };
10838     } catch (...) {
10839       {
10840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10841       };
10842     }
10843   }
10844   jresult = (void *)result;
10845   return jresult;
10846 }
10847
10848
10849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10850   void * jresult ;
10851   bool arg1 ;
10852   Dali::Matrix *result = 0 ;
10853
10854   arg1 = jarg1 ? true : false;
10855   {
10856     try {
10857       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10858     } catch (std::out_of_range& e) {
10859       {
10860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10861       };
10862     } catch (std::exception& e) {
10863       {
10864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10865       };
10866     } catch (...) {
10867       {
10868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10869       };
10870     }
10871   }
10872   jresult = (void *)result;
10873   return jresult;
10874 }
10875
10876
10877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10878   void * jresult ;
10879   float *arg1 = (float *) 0 ;
10880   Dali::Matrix *result = 0 ;
10881
10882   arg1 = jarg1;
10883   {
10884     try {
10885       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10886     } catch (std::out_of_range& e) {
10887       {
10888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10889       };
10890     } catch (std::exception& e) {
10891       {
10892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10893       };
10894     } catch (...) {
10895       {
10896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10897       };
10898     }
10899   }
10900   jresult = (void *)result;
10901
10902
10903   return jresult;
10904 }
10905
10906
10907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10908   void * jresult ;
10909   Dali::Quaternion *arg1 = 0 ;
10910   Dali::Matrix *result = 0 ;
10911
10912   arg1 = (Dali::Quaternion *)jarg1;
10913   if (!arg1) {
10914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10915     return 0;
10916   }
10917   {
10918     try {
10919       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10920     } catch (std::out_of_range& e) {
10921       {
10922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10923       };
10924     } catch (std::exception& e) {
10925       {
10926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10927       };
10928     } catch (...) {
10929       {
10930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10931       };
10932     }
10933   }
10934   jresult = (void *)result;
10935   return jresult;
10936 }
10937
10938
10939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10940   void * jresult ;
10941   Dali::Matrix *arg1 = 0 ;
10942   Dali::Matrix *result = 0 ;
10943
10944   arg1 = (Dali::Matrix *)jarg1;
10945   if (!arg1) {
10946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10947     return 0;
10948   }
10949   {
10950     try {
10951       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
10952     } catch (std::out_of_range& e) {
10953       {
10954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10955       };
10956     } catch (std::exception& e) {
10957       {
10958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10959       };
10960     } catch (...) {
10961       {
10962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10963       };
10964     }
10965   }
10966   jresult = (void *)result;
10967   return jresult;
10968 }
10969
10970
10971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
10972   void * jresult ;
10973   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
10974   Dali::Matrix *arg2 = 0 ;
10975   Dali::Matrix *result = 0 ;
10976
10977   arg1 = (Dali::Matrix *)jarg1;
10978   arg2 = (Dali::Matrix *)jarg2;
10979   if (!arg2) {
10980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10981     return 0;
10982   }
10983   {
10984     try {
10985       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
10986     } catch (std::out_of_range& e) {
10987       {
10988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10989       };
10990     } catch (std::exception& e) {
10991       {
10992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10993       };
10994     } catch (...) {
10995       {
10996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10997       };
10998     }
10999   }
11000   jresult = (void *)result;
11001   return jresult;
11002 }
11003
11004
11005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11006   void * jresult ;
11007   Dali::Matrix *result = 0 ;
11008
11009   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11010   jresult = (void *)result;
11011   return jresult;
11012 }
11013
11014
11015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11016   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11017
11018   arg1 = (Dali::Matrix *)jarg1;
11019   {
11020     try {
11021       (arg1)->SetIdentity();
11022     } catch (std::out_of_range& e) {
11023       {
11024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11025       };
11026     } catch (std::exception& e) {
11027       {
11028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11029       };
11030     } catch (...) {
11031       {
11032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11033       };
11034     }
11035   }
11036 }
11037
11038
11039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11040   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11041   Dali::Vector3 *arg2 = 0 ;
11042
11043   arg1 = (Dali::Matrix *)jarg1;
11044   arg2 = (Dali::Vector3 *)jarg2;
11045   if (!arg2) {
11046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11047     return ;
11048   }
11049   {
11050     try {
11051       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11052     } catch (std::out_of_range& e) {
11053       {
11054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11055       };
11056     } catch (std::exception& e) {
11057       {
11058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11059       };
11060     } catch (...) {
11061       {
11062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11063       };
11064     }
11065   }
11066 }
11067
11068
11069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11070   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11071   Dali::Matrix *arg2 = 0 ;
11072
11073   arg1 = (Dali::Matrix *)jarg1;
11074   arg2 = (Dali::Matrix *)jarg2;
11075   if (!arg2) {
11076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11077     return ;
11078   }
11079   {
11080     try {
11081       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11082     } catch (std::out_of_range& e) {
11083       {
11084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11085       };
11086     } catch (std::exception& e) {
11087       {
11088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11089       };
11090     } catch (...) {
11091       {
11092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11093       };
11094     }
11095   }
11096 }
11097
11098
11099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11100   unsigned int jresult ;
11101   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11102   bool result;
11103
11104   arg1 = (Dali::Matrix *)jarg1;
11105   {
11106     try {
11107       result = (bool)(arg1)->Invert();
11108     } catch (std::out_of_range& e) {
11109       {
11110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11111       };
11112     } catch (std::exception& e) {
11113       {
11114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11115       };
11116     } catch (...) {
11117       {
11118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11119       };
11120     }
11121   }
11122   jresult = result;
11123   return jresult;
11124 }
11125
11126
11127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11128   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11129
11130   arg1 = (Dali::Matrix *)jarg1;
11131   {
11132     try {
11133       (arg1)->Transpose();
11134     } catch (std::out_of_range& e) {
11135       {
11136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11137       };
11138     } catch (std::exception& e) {
11139       {
11140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11141       };
11142     } catch (...) {
11143       {
11144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11145       };
11146     }
11147   }
11148 }
11149
11150
11151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11152   void * jresult ;
11153   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11154   Dali::Vector3 result;
11155
11156   arg1 = (Dali::Matrix *)jarg1;
11157   {
11158     try {
11159       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11160     } catch (std::out_of_range& e) {
11161       {
11162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11163       };
11164     } catch (std::exception& e) {
11165       {
11166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11167       };
11168     } catch (...) {
11169       {
11170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11171       };
11172     }
11173   }
11174   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11175   return jresult;
11176 }
11177
11178
11179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11180   void * jresult ;
11181   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11182   Dali::Vector3 result;
11183
11184   arg1 = (Dali::Matrix *)jarg1;
11185   {
11186     try {
11187       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11188     } catch (std::out_of_range& e) {
11189       {
11190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11191       };
11192     } catch (std::exception& e) {
11193       {
11194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11195       };
11196     } catch (...) {
11197       {
11198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11199       };
11200     }
11201   }
11202   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11203   return jresult;
11204 }
11205
11206
11207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11208   void * jresult ;
11209   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11210   Dali::Vector3 result;
11211
11212   arg1 = (Dali::Matrix *)jarg1;
11213   {
11214     try {
11215       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11216     } catch (std::out_of_range& e) {
11217       {
11218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11219       };
11220     } catch (std::exception& e) {
11221       {
11222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11223       };
11224     } catch (...) {
11225       {
11226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11227       };
11228     }
11229   }
11230   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11231   return jresult;
11232 }
11233
11234
11235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11236   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11237   Dali::Vector3 *arg2 = 0 ;
11238
11239   arg1 = (Dali::Matrix *)jarg1;
11240   arg2 = (Dali::Vector3 *)jarg2;
11241   if (!arg2) {
11242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11243     return ;
11244   }
11245   {
11246     try {
11247       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11248     } catch (std::out_of_range& e) {
11249       {
11250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11251       };
11252     } catch (std::exception& e) {
11253       {
11254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11255       };
11256     } catch (...) {
11257       {
11258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11259       };
11260     }
11261   }
11262 }
11263
11264
11265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11266   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11267   Dali::Vector3 *arg2 = 0 ;
11268
11269   arg1 = (Dali::Matrix *)jarg1;
11270   arg2 = (Dali::Vector3 *)jarg2;
11271   if (!arg2) {
11272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11273     return ;
11274   }
11275   {
11276     try {
11277       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11278     } catch (std::out_of_range& e) {
11279       {
11280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11281       };
11282     } catch (std::exception& e) {
11283       {
11284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11285       };
11286     } catch (...) {
11287       {
11288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11289       };
11290     }
11291   }
11292 }
11293
11294
11295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11296   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11297   Dali::Vector3 *arg2 = 0 ;
11298
11299   arg1 = (Dali::Matrix *)jarg1;
11300   arg2 = (Dali::Vector3 *)jarg2;
11301   if (!arg2) {
11302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11303     return ;
11304   }
11305   {
11306     try {
11307       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11308     } catch (std::out_of_range& e) {
11309       {
11310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11311       };
11312     } catch (std::exception& e) {
11313       {
11314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11315       };
11316     } catch (...) {
11317       {
11318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11319       };
11320     }
11321   }
11322 }
11323
11324
11325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11326   void * jresult ;
11327   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11328   Dali::Vector4 *result = 0 ;
11329
11330   arg1 = (Dali::Matrix *)jarg1;
11331   {
11332     try {
11333       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11334     } catch (std::out_of_range& e) {
11335       {
11336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11337       };
11338     } catch (std::exception& e) {
11339       {
11340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11341       };
11342     } catch (...) {
11343       {
11344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11345       };
11346     }
11347   }
11348   jresult = (void *)result;
11349   return jresult;
11350 }
11351
11352
11353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11354   void * jresult ;
11355   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11356   Dali::Vector3 *result = 0 ;
11357
11358   arg1 = (Dali::Matrix *)jarg1;
11359   {
11360     try {
11361       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11362     } catch (std::out_of_range& e) {
11363       {
11364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11365       };
11366     } catch (std::exception& e) {
11367       {
11368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11369       };
11370     } catch (...) {
11371       {
11372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11373       };
11374     }
11375   }
11376   jresult = (void *)result;
11377   return jresult;
11378 }
11379
11380
11381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11382   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11383   Dali::Vector4 *arg2 = 0 ;
11384
11385   arg1 = (Dali::Matrix *)jarg1;
11386   arg2 = (Dali::Vector4 *)jarg2;
11387   if (!arg2) {
11388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11389     return ;
11390   }
11391   {
11392     try {
11393       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11394     } catch (std::out_of_range& e) {
11395       {
11396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11397       };
11398     } catch (std::exception& e) {
11399       {
11400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11401       };
11402     } catch (...) {
11403       {
11404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11405       };
11406     }
11407   }
11408 }
11409
11410
11411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11412   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11413   Dali::Vector3 *arg2 = 0 ;
11414
11415   arg1 = (Dali::Matrix *)jarg1;
11416   arg2 = (Dali::Vector3 *)jarg2;
11417   if (!arg2) {
11418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11419     return ;
11420   }
11421   {
11422     try {
11423       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11424     } catch (std::out_of_range& e) {
11425       {
11426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11427       };
11428     } catch (std::exception& e) {
11429       {
11430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11431       };
11432     } catch (...) {
11433       {
11434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11435       };
11436     }
11437   }
11438 }
11439
11440
11441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11442   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11443
11444   arg1 = (Dali::Matrix *)jarg1;
11445   {
11446     try {
11447       (arg1)->OrthoNormalize();
11448     } catch (std::out_of_range& e) {
11449       {
11450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11451       };
11452     } catch (std::exception& e) {
11453       {
11454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11455       };
11456     } catch (...) {
11457       {
11458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11459       };
11460     }
11461   }
11462 }
11463
11464
11465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11466   void * jresult ;
11467   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11468   float *result = 0 ;
11469
11470   arg1 = (Dali::Matrix *)jarg1;
11471   {
11472     try {
11473       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11474     } catch (std::out_of_range& e) {
11475       {
11476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11477       };
11478     } catch (std::exception& e) {
11479       {
11480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11481       };
11482     } catch (...) {
11483       {
11484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11485       };
11486     }
11487   }
11488   jresult = (void *)result;
11489   return jresult;
11490 }
11491
11492
11493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11494   Dali::Matrix *arg1 = 0 ;
11495   Dali::Matrix *arg2 = 0 ;
11496   Dali::Matrix *arg3 = 0 ;
11497
11498   arg1 = (Dali::Matrix *)jarg1;
11499   if (!arg1) {
11500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11501     return ;
11502   }
11503   arg2 = (Dali::Matrix *)jarg2;
11504   if (!arg2) {
11505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11506     return ;
11507   }
11508   arg3 = (Dali::Matrix *)jarg3;
11509   if (!arg3) {
11510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11511     return ;
11512   }
11513   {
11514     try {
11515       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11516     } catch (std::out_of_range& e) {
11517       {
11518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11519       };
11520     } catch (std::exception& e) {
11521       {
11522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11523       };
11524     } catch (...) {
11525       {
11526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11527       };
11528     }
11529   }
11530 }
11531
11532
11533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11534   Dali::Matrix *arg1 = 0 ;
11535   Dali::Matrix *arg2 = 0 ;
11536   Dali::Quaternion *arg3 = 0 ;
11537
11538   arg1 = (Dali::Matrix *)jarg1;
11539   if (!arg1) {
11540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11541     return ;
11542   }
11543   arg2 = (Dali::Matrix *)jarg2;
11544   if (!arg2) {
11545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11546     return ;
11547   }
11548   arg3 = (Dali::Quaternion *)jarg3;
11549   if (!arg3) {
11550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11551     return ;
11552   }
11553   {
11554     try {
11555       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11556     } catch (std::out_of_range& e) {
11557       {
11558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11559       };
11560     } catch (std::exception& e) {
11561       {
11562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11563       };
11564     } catch (...) {
11565       {
11566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11567       };
11568     }
11569   }
11570 }
11571
11572
11573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11574   void * jresult ;
11575   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11576   Dali::Vector4 *arg2 = 0 ;
11577   Dali::Vector4 result;
11578
11579   arg1 = (Dali::Matrix *)jarg1;
11580   arg2 = (Dali::Vector4 *)jarg2;
11581   if (!arg2) {
11582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11583     return 0;
11584   }
11585   {
11586     try {
11587       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11588     } catch (std::out_of_range& e) {
11589       {
11590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11591       };
11592     } catch (std::exception& e) {
11593       {
11594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11595       };
11596     } catch (...) {
11597       {
11598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11599       };
11600     }
11601   }
11602   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11603   return jresult;
11604 }
11605
11606
11607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11608   unsigned int jresult ;
11609   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11610   Dali::Matrix *arg2 = 0 ;
11611   bool result;
11612
11613   arg1 = (Dali::Matrix *)jarg1;
11614   arg2 = (Dali::Matrix *)jarg2;
11615   if (!arg2) {
11616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11617     return 0;
11618   }
11619   {
11620     try {
11621       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11622     } catch (std::out_of_range& e) {
11623       {
11624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11625       };
11626     } catch (std::exception& e) {
11627       {
11628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11629       };
11630     } catch (...) {
11631       {
11632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11633       };
11634     }
11635   }
11636   jresult = result;
11637   return jresult;
11638 }
11639
11640
11641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11642   unsigned int jresult ;
11643   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11644   Dali::Matrix *arg2 = 0 ;
11645   bool result;
11646
11647   arg1 = (Dali::Matrix *)jarg1;
11648   arg2 = (Dali::Matrix *)jarg2;
11649   if (!arg2) {
11650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11651     return 0;
11652   }
11653   {
11654     try {
11655       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11656     } catch (std::out_of_range& e) {
11657       {
11658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11659       };
11660     } catch (std::exception& e) {
11661       {
11662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11663       };
11664     } catch (...) {
11665       {
11666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11667       };
11668     }
11669   }
11670   jresult = result;
11671   return jresult;
11672 }
11673
11674
11675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11676   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11677   Dali::Vector3 *arg2 = 0 ;
11678   Dali::Quaternion *arg3 = 0 ;
11679   Dali::Vector3 *arg4 = 0 ;
11680
11681   arg1 = (Dali::Matrix *)jarg1;
11682   arg2 = (Dali::Vector3 *)jarg2;
11683   if (!arg2) {
11684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11685     return ;
11686   }
11687   arg3 = (Dali::Quaternion *)jarg3;
11688   if (!arg3) {
11689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11690     return ;
11691   }
11692   arg4 = (Dali::Vector3 *)jarg4;
11693   if (!arg4) {
11694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11695     return ;
11696   }
11697   {
11698     try {
11699       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11700     } catch (std::out_of_range& e) {
11701       {
11702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11703       };
11704     } catch (std::exception& e) {
11705       {
11706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11707       };
11708     } catch (...) {
11709       {
11710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11711       };
11712     }
11713   }
11714 }
11715
11716
11717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11718   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11719   Dali::Vector3 *arg2 = 0 ;
11720   Dali::Quaternion *arg3 = 0 ;
11721   Dali::Vector3 *arg4 = 0 ;
11722
11723   arg1 = (Dali::Matrix *)jarg1;
11724   arg2 = (Dali::Vector3 *)jarg2;
11725   if (!arg2) {
11726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11727     return ;
11728   }
11729   arg3 = (Dali::Quaternion *)jarg3;
11730   if (!arg3) {
11731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11732     return ;
11733   }
11734   arg4 = (Dali::Vector3 *)jarg4;
11735   if (!arg4) {
11736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11737     return ;
11738   }
11739   {
11740     try {
11741       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11742     } catch (std::out_of_range& e) {
11743       {
11744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11745       };
11746     } catch (std::exception& e) {
11747       {
11748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11749       };
11750     } catch (...) {
11751       {
11752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11753       };
11754     }
11755   }
11756 }
11757
11758
11759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11760   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11761   Dali::Vector3 *arg2 = 0 ;
11762   Dali::Vector3 *arg3 = 0 ;
11763   Dali::Vector3 *arg4 = 0 ;
11764   Dali::Vector3 *arg5 = 0 ;
11765
11766   arg1 = (Dali::Matrix *)jarg1;
11767   arg2 = (Dali::Vector3 *)jarg2;
11768   if (!arg2) {
11769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11770     return ;
11771   }
11772   arg3 = (Dali::Vector3 *)jarg3;
11773   if (!arg3) {
11774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11775     return ;
11776   }
11777   arg4 = (Dali::Vector3 *)jarg4;
11778   if (!arg4) {
11779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11780     return ;
11781   }
11782   arg5 = (Dali::Vector3 *)jarg5;
11783   if (!arg5) {
11784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11785     return ;
11786   }
11787   {
11788     try {
11789       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11790     } catch (std::out_of_range& e) {
11791       {
11792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11793       };
11794     } catch (std::exception& e) {
11795       {
11796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11797       };
11798     } catch (...) {
11799       {
11800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11801       };
11802     }
11803   }
11804 }
11805
11806
11807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11808   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11809   Dali::Vector3 *arg2 = 0 ;
11810   Dali::Quaternion *arg3 = 0 ;
11811   Dali::Vector3 *arg4 = 0 ;
11812
11813   arg1 = (Dali::Matrix *)jarg1;
11814   arg2 = (Dali::Vector3 *)jarg2;
11815   if (!arg2) {
11816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11817     return ;
11818   }
11819   arg3 = (Dali::Quaternion *)jarg3;
11820   if (!arg3) {
11821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11822     return ;
11823   }
11824   arg4 = (Dali::Vector3 *)jarg4;
11825   if (!arg4) {
11826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11827     return ;
11828   }
11829   {
11830     try {
11831       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11832     } catch (std::out_of_range& e) {
11833       {
11834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11835       };
11836     } catch (std::exception& e) {
11837       {
11838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11839       };
11840     } catch (...) {
11841       {
11842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11843       };
11844     }
11845   }
11846 }
11847
11848
11849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11850   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11851
11852   arg1 = (Dali::Matrix *)jarg1;
11853   {
11854     try {
11855       delete arg1;
11856     } catch (std::out_of_range& e) {
11857       {
11858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11859       };
11860     } catch (std::exception& e) {
11861       {
11862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11863       };
11864     } catch (...) {
11865       {
11866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11867       };
11868     }
11869   }
11870 }
11871
11872
11873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11874   void * jresult ;
11875   Dali::Matrix3 *result = 0 ;
11876
11877   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11878   jresult = (void *)result;
11879   return jresult;
11880 }
11881
11882
11883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11884   void * jresult ;
11885   Dali::Matrix3 *result = 0 ;
11886
11887   {
11888     try {
11889       result = (Dali::Matrix3 *)new Dali::Matrix3();
11890     } catch (std::out_of_range& e) {
11891       {
11892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11893       };
11894     } catch (std::exception& e) {
11895       {
11896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11897       };
11898     } catch (...) {
11899       {
11900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11901       };
11902     }
11903   }
11904   jresult = (void *)result;
11905   return jresult;
11906 }
11907
11908
11909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11910   void * jresult ;
11911   Dali::Matrix3 *arg1 = 0 ;
11912   Dali::Matrix3 *result = 0 ;
11913
11914   arg1 = (Dali::Matrix3 *)jarg1;
11915   if (!arg1) {
11916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11917     return 0;
11918   }
11919   {
11920     try {
11921       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11922     } catch (std::out_of_range& e) {
11923       {
11924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11925       };
11926     } catch (std::exception& e) {
11927       {
11928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11929       };
11930     } catch (...) {
11931       {
11932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11933       };
11934     }
11935   }
11936   jresult = (void *)result;
11937   return jresult;
11938 }
11939
11940
11941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
11942   void * jresult ;
11943   Dali::Matrix *arg1 = 0 ;
11944   Dali::Matrix3 *result = 0 ;
11945
11946   arg1 = (Dali::Matrix *)jarg1;
11947   if (!arg1) {
11948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11949     return 0;
11950   }
11951   {
11952     try {
11953       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
11954     } catch (std::out_of_range& e) {
11955       {
11956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11957       };
11958     } catch (std::exception& e) {
11959       {
11960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11961       };
11962     } catch (...) {
11963       {
11964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11965       };
11966     }
11967   }
11968   jresult = (void *)result;
11969   return jresult;
11970 }
11971
11972
11973 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) {
11974   void * jresult ;
11975   float arg1 ;
11976   float arg2 ;
11977   float arg3 ;
11978   float arg4 ;
11979   float arg5 ;
11980   float arg6 ;
11981   float arg7 ;
11982   float arg8 ;
11983   float arg9 ;
11984   Dali::Matrix3 *result = 0 ;
11985
11986   arg1 = (float)jarg1;
11987   arg2 = (float)jarg2;
11988   arg3 = (float)jarg3;
11989   arg4 = (float)jarg4;
11990   arg5 = (float)jarg5;
11991   arg6 = (float)jarg6;
11992   arg7 = (float)jarg7;
11993   arg8 = (float)jarg8;
11994   arg9 = (float)jarg9;
11995   {
11996     try {
11997       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
11998     } catch (std::out_of_range& e) {
11999       {
12000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12001       };
12002     } catch (std::exception& e) {
12003       {
12004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12005       };
12006     } catch (...) {
12007       {
12008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12009       };
12010     }
12011   }
12012   jresult = (void *)result;
12013   return jresult;
12014 }
12015
12016
12017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12018   void * jresult ;
12019   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12020   Dali::Matrix3 *arg2 = 0 ;
12021   Dali::Matrix3 *result = 0 ;
12022
12023   arg1 = (Dali::Matrix3 *)jarg1;
12024   arg2 = (Dali::Matrix3 *)jarg2;
12025   if (!arg2) {
12026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12027     return 0;
12028   }
12029   {
12030     try {
12031       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12032     } catch (std::out_of_range& e) {
12033       {
12034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12035       };
12036     } catch (std::exception& e) {
12037       {
12038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12039       };
12040     } catch (...) {
12041       {
12042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12043       };
12044     }
12045   }
12046   jresult = (void *)result;
12047   return jresult;
12048 }
12049
12050
12051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12052   void * jresult ;
12053   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12054   Dali::Matrix *arg2 = 0 ;
12055   Dali::Matrix3 *result = 0 ;
12056
12057   arg1 = (Dali::Matrix3 *)jarg1;
12058   arg2 = (Dali::Matrix *)jarg2;
12059   if (!arg2) {
12060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12061     return 0;
12062   }
12063   {
12064     try {
12065       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12066     } catch (std::out_of_range& e) {
12067       {
12068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12069       };
12070     } catch (std::exception& e) {
12071       {
12072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12073       };
12074     } catch (...) {
12075       {
12076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12077       };
12078     }
12079   }
12080   jresult = (void *)result;
12081   return jresult;
12082 }
12083
12084
12085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12086   unsigned int jresult ;
12087   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12088   Dali::Matrix3 *arg2 = 0 ;
12089   bool result;
12090
12091   arg1 = (Dali::Matrix3 *)jarg1;
12092   arg2 = (Dali::Matrix3 *)jarg2;
12093   if (!arg2) {
12094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12095     return 0;
12096   }
12097   {
12098     try {
12099       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12100     } catch (std::out_of_range& e) {
12101       {
12102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12103       };
12104     } catch (std::exception& e) {
12105       {
12106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12107       };
12108     } catch (...) {
12109       {
12110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12111       };
12112     }
12113   }
12114   jresult = result;
12115   return jresult;
12116 }
12117
12118
12119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12120   unsigned int jresult ;
12121   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12122   Dali::Matrix3 *arg2 = 0 ;
12123   bool result;
12124
12125   arg1 = (Dali::Matrix3 *)jarg1;
12126   arg2 = (Dali::Matrix3 *)jarg2;
12127   if (!arg2) {
12128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12129     return 0;
12130   }
12131   {
12132     try {
12133       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12134     } catch (std::out_of_range& e) {
12135       {
12136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12137       };
12138     } catch (std::exception& e) {
12139       {
12140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12141       };
12142     } catch (...) {
12143       {
12144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12145       };
12146     }
12147   }
12148   jresult = result;
12149   return jresult;
12150 }
12151
12152
12153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12154   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12155
12156   arg1 = (Dali::Matrix3 *)jarg1;
12157   {
12158     try {
12159       delete arg1;
12160     } catch (std::out_of_range& e) {
12161       {
12162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12163       };
12164     } catch (std::exception& e) {
12165       {
12166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12167       };
12168     } catch (...) {
12169       {
12170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12171       };
12172     }
12173   }
12174 }
12175
12176
12177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12178   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12179
12180   arg1 = (Dali::Matrix3 *)jarg1;
12181   {
12182     try {
12183       (arg1)->SetIdentity();
12184     } catch (std::out_of_range& e) {
12185       {
12186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12187       };
12188     } catch (std::exception& e) {
12189       {
12190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12191       };
12192     } catch (...) {
12193       {
12194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12195       };
12196     }
12197   }
12198 }
12199
12200
12201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12202   void * jresult ;
12203   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12204   float *result = 0 ;
12205
12206   arg1 = (Dali::Matrix3 *)jarg1;
12207   {
12208     try {
12209       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12210     } catch (std::out_of_range& e) {
12211       {
12212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12213       };
12214     } catch (std::exception& e) {
12215       {
12216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12217       };
12218     } catch (...) {
12219       {
12220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12221       };
12222     }
12223   }
12224   jresult = (void *)result;
12225   return jresult;
12226 }
12227
12228
12229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12230   unsigned int jresult ;
12231   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12232   bool result;
12233
12234   arg1 = (Dali::Matrix3 *)jarg1;
12235   {
12236     try {
12237       result = (bool)(arg1)->Invert();
12238     } catch (std::out_of_range& e) {
12239       {
12240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12241       };
12242     } catch (std::exception& e) {
12243       {
12244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12245       };
12246     } catch (...) {
12247       {
12248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12249       };
12250     }
12251   }
12252   jresult = result;
12253   return jresult;
12254 }
12255
12256
12257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12258   unsigned int jresult ;
12259   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12260   bool result;
12261
12262   arg1 = (Dali::Matrix3 *)jarg1;
12263   {
12264     try {
12265       result = (bool)(arg1)->Transpose();
12266     } catch (std::out_of_range& e) {
12267       {
12268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12269       };
12270     } catch (std::exception& e) {
12271       {
12272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12273       };
12274     } catch (...) {
12275       {
12276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12277       };
12278     }
12279   }
12280   jresult = result;
12281   return jresult;
12282 }
12283
12284
12285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12286   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12287   float arg2 ;
12288
12289   arg1 = (Dali::Matrix3 *)jarg1;
12290   arg2 = (float)jarg2;
12291   {
12292     try {
12293       (arg1)->Scale(arg2);
12294     } catch (std::out_of_range& e) {
12295       {
12296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12297       };
12298     } catch (std::exception& e) {
12299       {
12300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12301       };
12302     } catch (...) {
12303       {
12304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12305       };
12306     }
12307   }
12308 }
12309
12310
12311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12312   float jresult ;
12313   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12314   float result;
12315
12316   arg1 = (Dali::Matrix3 *)jarg1;
12317   {
12318     try {
12319       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12320     } catch (std::out_of_range& e) {
12321       {
12322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12323       };
12324     } catch (std::exception& e) {
12325       {
12326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12327       };
12328     } catch (...) {
12329       {
12330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12331       };
12332     }
12333   }
12334   jresult = result;
12335   return jresult;
12336 }
12337
12338
12339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12340   unsigned int jresult ;
12341   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12342   bool result;
12343
12344   arg1 = (Dali::Matrix3 *)jarg1;
12345   {
12346     try {
12347       result = (bool)(arg1)->ScaledInverseTranspose();
12348     } catch (std::out_of_range& e) {
12349       {
12350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12351       };
12352     } catch (std::exception& e) {
12353       {
12354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12355       };
12356     } catch (...) {
12357       {
12358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12359       };
12360     }
12361   }
12362   jresult = result;
12363   return jresult;
12364 }
12365
12366
12367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12368   Dali::Matrix3 *arg1 = 0 ;
12369   Dali::Matrix3 *arg2 = 0 ;
12370   Dali::Matrix3 *arg3 = 0 ;
12371
12372   arg1 = (Dali::Matrix3 *)jarg1;
12373   if (!arg1) {
12374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12375     return ;
12376   }
12377   arg2 = (Dali::Matrix3 *)jarg2;
12378   if (!arg2) {
12379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12380     return ;
12381   }
12382   arg3 = (Dali::Matrix3 *)jarg3;
12383   if (!arg3) {
12384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12385     return ;
12386   }
12387   {
12388     try {
12389       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12390     } catch (std::out_of_range& e) {
12391       {
12392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12393       };
12394     } catch (std::exception& e) {
12395       {
12396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12397       };
12398     } catch (...) {
12399       {
12400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12401       };
12402     }
12403   }
12404 }
12405
12406
12407 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12408   float jresult ;
12409   float arg1 ;
12410   float arg2 ;
12411   float result;
12412
12413   arg1 = (float)jarg1;
12414   arg2 = (float)jarg2;
12415   {
12416     try {
12417       result = (float)Dali::Random::Range(arg1,arg2);
12418     } catch (std::out_of_range& e) {
12419       {
12420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12421       };
12422     } catch (std::exception& e) {
12423       {
12424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12425       };
12426     } catch (...) {
12427       {
12428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12429       };
12430     }
12431   }
12432   jresult = result;
12433   return jresult;
12434 }
12435
12436
12437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12438   void * jresult ;
12439   Dali::Vector4 result;
12440
12441   {
12442     try {
12443       result = Dali::Random::Axis();
12444     } catch (std::out_of_range& e) {
12445       {
12446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12447       };
12448     } catch (std::exception& e) {
12449       {
12450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12451       };
12452     } catch (...) {
12453       {
12454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12455       };
12456     }
12457   }
12458   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12459   return jresult;
12460 }
12461
12462
12463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12464   void * jresult ;
12465   Dali::AngleAxis *result = 0 ;
12466
12467   {
12468     try {
12469       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12470     } catch (std::out_of_range& e) {
12471       {
12472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12473       };
12474     } catch (std::exception& e) {
12475       {
12476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12477       };
12478     } catch (...) {
12479       {
12480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12481       };
12482     }
12483   }
12484   jresult = (void *)result;
12485   return jresult;
12486 }
12487
12488
12489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12490   void * jresult ;
12491   Dali::Radian arg1 ;
12492   Dali::Vector3 *arg2 = 0 ;
12493   Dali::Radian *argp1 ;
12494   Dali::AngleAxis *result = 0 ;
12495
12496   argp1 = (Dali::Radian *)jarg1;
12497   if (!argp1) {
12498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12499     return 0;
12500   }
12501   arg1 = *argp1;
12502   arg2 = (Dali::Vector3 *)jarg2;
12503   if (!arg2) {
12504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12505     return 0;
12506   }
12507   {
12508     try {
12509       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12510     } catch (std::out_of_range& e) {
12511       {
12512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12513       };
12514     } catch (std::exception& e) {
12515       {
12516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12517       };
12518     } catch (...) {
12519       {
12520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12521       };
12522     }
12523   }
12524   jresult = (void *)result;
12525   return jresult;
12526 }
12527
12528
12529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12530   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12531   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12532
12533   arg1 = (Dali::AngleAxis *)jarg1;
12534   arg2 = (Dali::Radian *)jarg2;
12535   if (arg1) (arg1)->angle = *arg2;
12536 }
12537
12538
12539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12540   void * jresult ;
12541   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12542   Dali::Radian *result = 0 ;
12543
12544   arg1 = (Dali::AngleAxis *)jarg1;
12545   result = (Dali::Radian *)& ((arg1)->angle);
12546   jresult = (void *)result;
12547   return jresult;
12548 }
12549
12550
12551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12552   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12553   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12554
12555   arg1 = (Dali::AngleAxis *)jarg1;
12556   arg2 = (Dali::Vector3 *)jarg2;
12557   if (arg1) (arg1)->axis = *arg2;
12558 }
12559
12560
12561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12562   void * jresult ;
12563   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12564   Dali::Vector3 *result = 0 ;
12565
12566   arg1 = (Dali::AngleAxis *)jarg1;
12567   result = (Dali::Vector3 *)& ((arg1)->axis);
12568   jresult = (void *)result;
12569   return jresult;
12570 }
12571
12572
12573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12574   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12575
12576   arg1 = (Dali::AngleAxis *)jarg1;
12577   {
12578     try {
12579       delete arg1;
12580     } catch (std::out_of_range& e) {
12581       {
12582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12583       };
12584     } catch (std::exception& e) {
12585       {
12586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12587       };
12588     } catch (...) {
12589       {
12590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12591       };
12592     }
12593   }
12594 }
12595
12596
12597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12598   unsigned int jresult ;
12599   Dali::AngleAxis *arg1 = 0 ;
12600   Dali::AngleAxis *arg2 = 0 ;
12601   bool result;
12602
12603   arg1 = (Dali::AngleAxis *)jarg1;
12604   if (!arg1) {
12605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12606     return 0;
12607   }
12608   arg2 = (Dali::AngleAxis *)jarg2;
12609   if (!arg2) {
12610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12611     return 0;
12612   }
12613   {
12614     try {
12615       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12616     } catch (std::out_of_range& e) {
12617       {
12618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12619       };
12620     } catch (std::exception& e) {
12621       {
12622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12623       };
12624     } catch (...) {
12625       {
12626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12627       };
12628     }
12629   }
12630   jresult = result;
12631   return jresult;
12632 }
12633
12634
12635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12636   unsigned int jresult ;
12637   unsigned int arg1 ;
12638   unsigned int result;
12639
12640   arg1 = (unsigned int)jarg1;
12641   {
12642     try {
12643       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12644     } catch (std::out_of_range& e) {
12645       {
12646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12647       };
12648     } catch (std::exception& e) {
12649       {
12650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12651       };
12652     } catch (...) {
12653       {
12654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12655       };
12656     }
12657   }
12658   jresult = result;
12659   return jresult;
12660 }
12661
12662
12663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12664   unsigned int jresult ;
12665   unsigned int arg1 ;
12666   bool result;
12667
12668   arg1 = (unsigned int)jarg1;
12669   {
12670     try {
12671       result = (bool)Dali::IsPowerOfTwo(arg1);
12672     } catch (std::out_of_range& e) {
12673       {
12674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12675       };
12676     } catch (std::exception& e) {
12677       {
12678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12679       };
12680     } catch (...) {
12681       {
12682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12683       };
12684     }
12685   }
12686   jresult = result;
12687   return jresult;
12688 }
12689
12690
12691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12692   float jresult ;
12693   float arg1 ;
12694   float arg2 ;
12695   float result;
12696
12697   arg1 = (float)jarg1;
12698   arg2 = (float)jarg2;
12699   {
12700     try {
12701       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12702     } catch (std::out_of_range& e) {
12703       {
12704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12705       };
12706     } catch (std::exception& e) {
12707       {
12708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12709       };
12710     } catch (...) {
12711       {
12712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12713       };
12714     }
12715   }
12716   jresult = result;
12717   return jresult;
12718 }
12719
12720
12721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12722   unsigned int jresult ;
12723   float arg1 ;
12724   bool result;
12725
12726   arg1 = (float)jarg1;
12727   {
12728     try {
12729       result = (bool)Dali::EqualsZero(arg1);
12730     } catch (std::out_of_range& e) {
12731       {
12732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12733       };
12734     } catch (std::exception& e) {
12735       {
12736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12737       };
12738     } catch (...) {
12739       {
12740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12741       };
12742     }
12743   }
12744   jresult = result;
12745   return jresult;
12746 }
12747
12748
12749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12750   unsigned int jresult ;
12751   float arg1 ;
12752   float arg2 ;
12753   bool result;
12754
12755   arg1 = (float)jarg1;
12756   arg2 = (float)jarg2;
12757   {
12758     try {
12759       result = (bool)Dali::Equals(arg1,arg2);
12760     } catch (std::out_of_range& e) {
12761       {
12762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12763       };
12764     } catch (std::exception& e) {
12765       {
12766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12767       };
12768     } catch (...) {
12769       {
12770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12771       };
12772     }
12773   }
12774   jresult = result;
12775   return jresult;
12776 }
12777
12778
12779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12780   unsigned int jresult ;
12781   float arg1 ;
12782   float arg2 ;
12783   float arg3 ;
12784   bool result;
12785
12786   arg1 = (float)jarg1;
12787   arg2 = (float)jarg2;
12788   arg3 = (float)jarg3;
12789   {
12790     try {
12791       result = (bool)Dali::Equals(arg1,arg2,arg3);
12792     } catch (std::out_of_range& e) {
12793       {
12794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12795       };
12796     } catch (std::exception& e) {
12797       {
12798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12799       };
12800     } catch (...) {
12801       {
12802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12803       };
12804     }
12805   }
12806   jresult = result;
12807   return jresult;
12808 }
12809
12810
12811 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12812   float jresult ;
12813   float arg1 ;
12814   int arg2 ;
12815   float result;
12816
12817   arg1 = (float)jarg1;
12818   arg2 = (int)jarg2;
12819   {
12820     try {
12821       result = (float)Dali::Round(arg1,arg2);
12822     } catch (std::out_of_range& e) {
12823       {
12824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12825       };
12826     } catch (std::exception& e) {
12827       {
12828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12829       };
12830     } catch (...) {
12831       {
12832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12833       };
12834     }
12835   }
12836   jresult = result;
12837   return jresult;
12838 }
12839
12840
12841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12842   float jresult ;
12843   float arg1 ;
12844   float arg2 ;
12845   float arg3 ;
12846   float result;
12847
12848   arg1 = (float)jarg1;
12849   arg2 = (float)jarg2;
12850   arg3 = (float)jarg3;
12851   {
12852     try {
12853       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12854     } catch (std::out_of_range& e) {
12855       {
12856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12857       };
12858     } catch (std::exception& e) {
12859       {
12860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12861       };
12862     } catch (...) {
12863       {
12864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12865       };
12866     }
12867   }
12868   jresult = result;
12869   return jresult;
12870 }
12871
12872
12873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12874   float jresult ;
12875   float arg1 ;
12876   float arg2 ;
12877   float arg3 ;
12878   float arg4 ;
12879   float result;
12880
12881   arg1 = (float)jarg1;
12882   arg2 = (float)jarg2;
12883   arg3 = (float)jarg3;
12884   arg4 = (float)jarg4;
12885   {
12886     try {
12887       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12888     } catch (std::out_of_range& e) {
12889       {
12890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12891       };
12892     } catch (std::exception& e) {
12893       {
12894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12895       };
12896     } catch (...) {
12897       {
12898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12899       };
12900     }
12901   }
12902   jresult = result;
12903   return jresult;
12904 }
12905
12906
12907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12908   int jresult ;
12909   int result;
12910
12911   result = (int)(int)Dali::Property::INVALID_INDEX;
12912   jresult = result;
12913   return jresult;
12914 }
12915
12916
12917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12918   int jresult ;
12919   int result;
12920
12921   result = (int)(int)Dali::Property::INVALID_KEY;
12922   jresult = result;
12923   return jresult;
12924 }
12925
12926
12927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12928   int jresult ;
12929   int result;
12930
12931   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12932   jresult = result;
12933   return jresult;
12934 }
12935
12936
12937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12938   void * jresult ;
12939   Dali::Handle *arg1 = 0 ;
12940   Dali::Property::Index arg2 ;
12941   Dali::Property *result = 0 ;
12942
12943   arg1 = (Dali::Handle *)jarg1;
12944   if (!arg1) {
12945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12946     return 0;
12947   }
12948   arg2 = (Dali::Property::Index)jarg2;
12949   {
12950     try {
12951       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
12952     } catch (std::out_of_range& e) {
12953       {
12954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12955       };
12956     } catch (std::exception& e) {
12957       {
12958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12959       };
12960     } catch (...) {
12961       {
12962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12963       };
12964     }
12965   }
12966   jresult = (void *)result;
12967   return jresult;
12968 }
12969
12970
12971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
12972   void * jresult ;
12973   Dali::Handle *arg1 = 0 ;
12974   Dali::Property::Index arg2 ;
12975   int arg3 ;
12976   Dali::Property *result = 0 ;
12977
12978   arg1 = (Dali::Handle *)jarg1;
12979   if (!arg1) {
12980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12981     return 0;
12982   }
12983   arg2 = (Dali::Property::Index)jarg2;
12984   arg3 = (int)jarg3;
12985   {
12986     try {
12987       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
12988     } catch (std::out_of_range& e) {
12989       {
12990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12991       };
12992     } catch (std::exception& e) {
12993       {
12994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12995       };
12996     } catch (...) {
12997       {
12998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12999       };
13000     }
13001   }
13002   jresult = (void *)result;
13003   return jresult;
13004 }
13005
13006
13007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13008   void * jresult ;
13009   Dali::Handle *arg1 = 0 ;
13010   std::string *arg2 = 0 ;
13011   Dali::Property *result = 0 ;
13012
13013   arg1 = (Dali::Handle *)jarg1;
13014   if (!arg1) {
13015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13016     return 0;
13017   }
13018   if (!jarg2) {
13019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13020     return 0;
13021   }
13022   std::string arg2_str(jarg2);
13023   arg2 = &arg2_str;
13024   {
13025     try {
13026       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13027     } catch (std::out_of_range& e) {
13028       {
13029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13030       };
13031     } catch (std::exception& e) {
13032       {
13033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13034       };
13035     } catch (...) {
13036       {
13037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13038       };
13039     }
13040   }
13041   jresult = (void *)result;
13042
13043   //argout typemap for const std::string&
13044
13045   return jresult;
13046 }
13047
13048
13049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13050   void * jresult ;
13051   Dali::Handle *arg1 = 0 ;
13052   std::string *arg2 = 0 ;
13053   int arg3 ;
13054   Dali::Property *result = 0 ;
13055
13056   arg1 = (Dali::Handle *)jarg1;
13057   if (!arg1) {
13058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13059     return 0;
13060   }
13061   if (!jarg2) {
13062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13063     return 0;
13064   }
13065   std::string arg2_str(jarg2);
13066   arg2 = &arg2_str;
13067   arg3 = (int)jarg3;
13068   {
13069     try {
13070       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13071     } catch (std::out_of_range& e) {
13072       {
13073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13074       };
13075     } catch (std::exception& e) {
13076       {
13077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13078       };
13079     } catch (...) {
13080       {
13081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13082       };
13083     }
13084   }
13085   jresult = (void *)result;
13086
13087   //argout typemap for const std::string&
13088
13089   return jresult;
13090 }
13091
13092
13093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13094   Dali::Property *arg1 = (Dali::Property *) 0 ;
13095
13096   arg1 = (Dali::Property *)jarg1;
13097   {
13098     try {
13099       delete arg1;
13100     } catch (std::out_of_range& e) {
13101       {
13102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13103       };
13104     } catch (std::exception& e) {
13105       {
13106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13107       };
13108     } catch (...) {
13109       {
13110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13111       };
13112     }
13113   }
13114 }
13115
13116
13117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13118   Dali::Property *arg1 = (Dali::Property *) 0 ;
13119   Dali::Handle *arg2 = 0 ;
13120
13121   arg1 = (Dali::Property *)jarg1;
13122   arg2 = (Dali::Handle *)jarg2;
13123   if (!arg2) {
13124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13125     return ;
13126   }
13127   if (arg1) (arg1)->object = *arg2;
13128 }
13129
13130
13131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13132   void * jresult ;
13133   Dali::Property *arg1 = (Dali::Property *) 0 ;
13134   Dali::Handle *result = 0 ;
13135
13136   arg1 = (Dali::Property *)jarg1;
13137   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13138   jresult = (void *)result;
13139   return jresult;
13140 }
13141
13142
13143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13144   Dali::Property *arg1 = (Dali::Property *) 0 ;
13145   Dali::Property::Index arg2 ;
13146
13147   arg1 = (Dali::Property *)jarg1;
13148   arg2 = (Dali::Property::Index)jarg2;
13149   if (arg1) (arg1)->propertyIndex = arg2;
13150 }
13151
13152
13153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13154   int jresult ;
13155   Dali::Property *arg1 = (Dali::Property *) 0 ;
13156   Dali::Property::Index result;
13157
13158   arg1 = (Dali::Property *)jarg1;
13159   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13160   jresult = result;
13161   return jresult;
13162 }
13163
13164
13165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13166   Dali::Property *arg1 = (Dali::Property *) 0 ;
13167   int arg2 ;
13168
13169   arg1 = (Dali::Property *)jarg1;
13170   arg2 = (int)jarg2;
13171   if (arg1) (arg1)->componentIndex = arg2;
13172 }
13173
13174
13175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13176   int jresult ;
13177   Dali::Property *arg1 = (Dali::Property *) 0 ;
13178   int result;
13179
13180   arg1 = (Dali::Property *)jarg1;
13181   result = (int) ((arg1)->componentIndex);
13182   jresult = result;
13183   return jresult;
13184 }
13185
13186
13187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13188   void * jresult ;
13189   Dali::Property::Array *result = 0 ;
13190
13191   {
13192     try {
13193       result = (Dali::Property::Array *)new Dali::Property::Array();
13194     } catch (std::out_of_range& e) {
13195       {
13196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13197       };
13198     } catch (std::exception& e) {
13199       {
13200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13201       };
13202     } catch (...) {
13203       {
13204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13205       };
13206     }
13207   }
13208   jresult = (void *)result;
13209   return jresult;
13210 }
13211
13212
13213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13214   void * jresult ;
13215   Dali::Property::Array *arg1 = 0 ;
13216   Dali::Property::Array *result = 0 ;
13217
13218   arg1 = (Dali::Property::Array *)jarg1;
13219   if (!arg1) {
13220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13221     return 0;
13222   }
13223   {
13224     try {
13225       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13226     } catch (std::out_of_range& e) {
13227       {
13228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13229       };
13230     } catch (std::exception& e) {
13231       {
13232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13233       };
13234     } catch (...) {
13235       {
13236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13237       };
13238     }
13239   }
13240   jresult = (void *)result;
13241   return jresult;
13242 }
13243
13244
13245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13246   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13247
13248   arg1 = (Dali::Property::Array *)jarg1;
13249   {
13250     try {
13251       delete arg1;
13252     } catch (std::out_of_range& e) {
13253       {
13254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13255       };
13256     } catch (std::exception& e) {
13257       {
13258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13259       };
13260     } catch (...) {
13261       {
13262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13263       };
13264     }
13265   }
13266 }
13267
13268
13269 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13270   unsigned long jresult ;
13271   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13272   Dali::Property::Array::SizeType result;
13273
13274   arg1 = (Dali::Property::Array *)jarg1;
13275   {
13276     try {
13277       result = ((Dali::Property::Array const *)arg1)->Size();
13278     } catch (std::out_of_range& e) {
13279       {
13280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13281       };
13282     } catch (std::exception& e) {
13283       {
13284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13285       };
13286     } catch (...) {
13287       {
13288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13289       };
13290     }
13291   }
13292   jresult = (unsigned long)result;
13293   return jresult;
13294 }
13295
13296
13297 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13298   unsigned long jresult ;
13299   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13300   Dali::Property::Array::SizeType result;
13301
13302   arg1 = (Dali::Property::Array *)jarg1;
13303   {
13304     try {
13305       result = ((Dali::Property::Array const *)arg1)->Count();
13306     } catch (std::out_of_range& e) {
13307       {
13308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13309       };
13310     } catch (std::exception& e) {
13311       {
13312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13313       };
13314     } catch (...) {
13315       {
13316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13317       };
13318     }
13319   }
13320   jresult = (unsigned long)result;
13321   return jresult;
13322 }
13323
13324
13325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13326   unsigned int jresult ;
13327   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13328   bool result;
13329
13330   arg1 = (Dali::Property::Array *)jarg1;
13331   {
13332     try {
13333       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13334     } catch (std::out_of_range& e) {
13335       {
13336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13337       };
13338     } catch (std::exception& e) {
13339       {
13340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13341       };
13342     } catch (...) {
13343       {
13344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13345       };
13346     }
13347   }
13348   jresult = result;
13349   return jresult;
13350 }
13351
13352
13353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13354   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13355
13356   arg1 = (Dali::Property::Array *)jarg1;
13357   {
13358     try {
13359       (arg1)->Clear();
13360     } catch (std::out_of_range& e) {
13361       {
13362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13363       };
13364     } catch (std::exception& e) {
13365       {
13366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13367       };
13368     } catch (...) {
13369       {
13370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13371       };
13372     }
13373   }
13374 }
13375
13376
13377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13378   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13379   Dali::Property::Array::SizeType arg2 ;
13380
13381   arg1 = (Dali::Property::Array *)jarg1;
13382   arg2 = (Dali::Property::Array::SizeType)jarg2;
13383   {
13384     try {
13385       (arg1)->Reserve(arg2);
13386     } catch (std::out_of_range& e) {
13387       {
13388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13389       };
13390     } catch (std::exception& e) {
13391       {
13392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13393       };
13394     } catch (...) {
13395       {
13396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13397       };
13398     }
13399   }
13400 }
13401
13402
13403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13404   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13405   Dali::Property::Array::SizeType arg2 ;
13406
13407   arg1 = (Dali::Property::Array *)jarg1;
13408   arg2 = (Dali::Property::Array::SizeType)jarg2;
13409   {
13410     try {
13411       (arg1)->Resize(arg2);
13412     } catch (std::out_of_range& e) {
13413       {
13414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13415       };
13416     } catch (std::exception& e) {
13417       {
13418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13419       };
13420     } catch (...) {
13421       {
13422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13423       };
13424     }
13425   }
13426 }
13427
13428
13429 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13430   unsigned long jresult ;
13431   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13432   Dali::Property::Array::SizeType result;
13433
13434   arg1 = (Dali::Property::Array *)jarg1;
13435   {
13436     try {
13437       result = (arg1)->Capacity();
13438     } catch (std::out_of_range& e) {
13439       {
13440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13441       };
13442     } catch (std::exception& e) {
13443       {
13444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13445       };
13446     } catch (...) {
13447       {
13448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13449       };
13450     }
13451   }
13452   jresult = (unsigned long)result;
13453   return jresult;
13454 }
13455
13456
13457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13458   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13459   Dali::Property::Value *arg2 = 0 ;
13460
13461   arg1 = (Dali::Property::Array *)jarg1;
13462   arg2 = (Dali::Property::Value *)jarg2;
13463   if (!arg2) {
13464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13465     return ;
13466   }
13467   {
13468     try {
13469       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13470     } catch (std::out_of_range& e) {
13471       {
13472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13473       };
13474     } catch (std::exception& e) {
13475       {
13476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13477       };
13478     } catch (...) {
13479       {
13480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13481       };
13482     }
13483   }
13484 }
13485
13486
13487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13488   void * jresult ;
13489   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13490   Dali::Property::Value *arg2 = 0 ;
13491   Dali::Property::Array *result = 0 ;
13492
13493   arg1 = (Dali::Property::Array *)jarg1;
13494   arg2 = (Dali::Property::Value *)jarg2;
13495   if (!arg2) {
13496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13497     return 0;
13498   }
13499   {
13500     try {
13501       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13502     } catch (std::out_of_range& e) {
13503       {
13504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13505       };
13506     } catch (std::exception& e) {
13507       {
13508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13509       };
13510     } catch (...) {
13511       {
13512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13513       };
13514     }
13515   }
13516   jresult = (void *)result;
13517   return jresult;
13518 }
13519
13520
13521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13522   void * jresult ;
13523   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13524   Dali::Property::Array::SizeType arg2 ;
13525   Dali::Property::Value *result = 0 ;
13526
13527   arg1 = (Dali::Property::Array *)jarg1;
13528   arg2 = (Dali::Property::Array::SizeType)jarg2;
13529   {
13530     try {
13531       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13532     } catch (std::out_of_range& e) {
13533       {
13534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13535       };
13536     } catch (std::exception& e) {
13537       {
13538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13539       };
13540     } catch (...) {
13541       {
13542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13543       };
13544     }
13545   }
13546   jresult = (void *)result;
13547   return jresult;
13548 }
13549
13550
13551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13552   void * jresult ;
13553   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13554   Dali::Property::Array::SizeType arg2 ;
13555   Dali::Property::Value *result = 0 ;
13556
13557   arg1 = (Dali::Property::Array *)jarg1;
13558   arg2 = (Dali::Property::Array::SizeType)jarg2;
13559   {
13560     try {
13561       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13562     } catch (std::out_of_range& e) {
13563       {
13564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13565       };
13566     } catch (std::exception& e) {
13567       {
13568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13569       };
13570     } catch (...) {
13571       {
13572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13573       };
13574     }
13575   }
13576   jresult = (void *)result;
13577   return jresult;
13578 }
13579
13580
13581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13582   void * jresult ;
13583   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13584   Dali::Property::Array *arg2 = 0 ;
13585   Dali::Property::Array *result = 0 ;
13586
13587   arg1 = (Dali::Property::Array *)jarg1;
13588   arg2 = (Dali::Property::Array *)jarg2;
13589   if (!arg2) {
13590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13591     return 0;
13592   }
13593   {
13594     try {
13595       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13596     } catch (std::out_of_range& e) {
13597       {
13598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13599       };
13600     } catch (std::exception& e) {
13601       {
13602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13603       };
13604     } catch (...) {
13605       {
13606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13607       };
13608     }
13609   }
13610   jresult = (void *)result;
13611   return jresult;
13612 }
13613
13614
13615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13616   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13617   enum Dali::Property::Key::Type arg2 ;
13618
13619   arg1 = (Dali::Property::Key *)jarg1;
13620   arg2 = (enum Dali::Property::Key::Type)jarg2;
13621   if (arg1) (arg1)->type = arg2;
13622 }
13623
13624
13625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13626   int jresult ;
13627   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13628   enum Dali::Property::Key::Type result;
13629
13630   arg1 = (Dali::Property::Key *)jarg1;
13631   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13632   jresult = (int)result;
13633   return jresult;
13634 }
13635
13636
13637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13638   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13639   Dali::Property::Index arg2 ;
13640
13641   arg1 = (Dali::Property::Key *)jarg1;
13642   arg2 = (Dali::Property::Index)jarg2;
13643   if (arg1) (arg1)->indexKey = arg2;
13644 }
13645
13646
13647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13648   int jresult ;
13649   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13650   Dali::Property::Index result;
13651
13652   arg1 = (Dali::Property::Key *)jarg1;
13653   result = (Dali::Property::Index) ((arg1)->indexKey);
13654   jresult = result;
13655   return jresult;
13656 }
13657
13658
13659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13660   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13661   std::string *arg2 = 0 ;
13662
13663   arg1 = (Dali::Property::Key *)jarg1;
13664   if (!jarg2) {
13665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13666     return ;
13667   }
13668   std::string arg2_str(jarg2);
13669   arg2 = &arg2_str;
13670   if (arg1) (arg1)->stringKey = *arg2;
13671
13672   //argout typemap for const std::string&
13673
13674 }
13675
13676
13677 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13678   char * jresult ;
13679   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13680   std::string *result = 0 ;
13681
13682   arg1 = (Dali::Property::Key *)jarg1;
13683   result = (std::string *) & ((arg1)->stringKey);
13684   jresult = SWIG_csharp_string_callback(result->c_str());
13685   return jresult;
13686 }
13687
13688
13689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13690   void * jresult ;
13691   std::string *arg1 = 0 ;
13692   Dali::Property::Key *result = 0 ;
13693
13694   if (!jarg1) {
13695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13696     return 0;
13697   }
13698   std::string arg1_str(jarg1);
13699   arg1 = &arg1_str;
13700   {
13701     try {
13702       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13703     } catch (std::out_of_range& e) {
13704       {
13705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13706       };
13707     } catch (std::exception& e) {
13708       {
13709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13710       };
13711     } catch (...) {
13712       {
13713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13714       };
13715     }
13716   }
13717   jresult = (void *)result;
13718
13719   //argout typemap for const std::string&
13720
13721   return jresult;
13722 }
13723
13724
13725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13726   void * jresult ;
13727   Dali::Property::Index arg1 ;
13728   Dali::Property::Key *result = 0 ;
13729
13730   arg1 = (Dali::Property::Index)jarg1;
13731   {
13732     try {
13733       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13734     } catch (std::out_of_range& e) {
13735       {
13736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13737       };
13738     } catch (std::exception& e) {
13739       {
13740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13741       };
13742     } catch (...) {
13743       {
13744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13745       };
13746     }
13747   }
13748   jresult = (void *)result;
13749   return jresult;
13750 }
13751
13752
13753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13754   unsigned int jresult ;
13755   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13756   std::string *arg2 = 0 ;
13757   bool result;
13758
13759   arg1 = (Dali::Property::Key *)jarg1;
13760   if (!jarg2) {
13761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13762     return 0;
13763   }
13764   std::string arg2_str(jarg2);
13765   arg2 = &arg2_str;
13766   {
13767     try {
13768       result = (bool)(arg1)->operator ==((std::string const &)*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
13785   //argout typemap for const std::string&
13786
13787   return jresult;
13788 }
13789
13790
13791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13792   unsigned int jresult ;
13793   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13794   Dali::Property::Index arg2 ;
13795   bool result;
13796
13797   arg1 = (Dali::Property::Key *)jarg1;
13798   arg2 = (Dali::Property::Index)jarg2;
13799   {
13800     try {
13801       result = (bool)(arg1)->operator ==(arg2);
13802     } catch (std::out_of_range& e) {
13803       {
13804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13805       };
13806     } catch (std::exception& e) {
13807       {
13808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13809       };
13810     } catch (...) {
13811       {
13812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13813       };
13814     }
13815   }
13816   jresult = result;
13817   return jresult;
13818 }
13819
13820
13821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13822   unsigned int jresult ;
13823   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13824   Dali::Property::Key *arg2 = 0 ;
13825   bool result;
13826
13827   arg1 = (Dali::Property::Key *)jarg1;
13828   arg2 = (Dali::Property::Key *)jarg2;
13829   if (!arg2) {
13830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13831     return 0;
13832   }
13833   {
13834     try {
13835       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13836     } catch (std::out_of_range& e) {
13837       {
13838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13839       };
13840     } catch (std::exception& e) {
13841       {
13842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13843       };
13844     } catch (...) {
13845       {
13846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13847       };
13848     }
13849   }
13850   jresult = result;
13851   return jresult;
13852 }
13853
13854
13855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13856   unsigned int jresult ;
13857   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13858   std::string *arg2 = 0 ;
13859   bool result;
13860
13861   arg1 = (Dali::Property::Key *)jarg1;
13862   if (!jarg2) {
13863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13864     return 0;
13865   }
13866   std::string arg2_str(jarg2);
13867   arg2 = &arg2_str;
13868   {
13869     try {
13870       result = (bool)(arg1)->operator !=((std::string const &)*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
13887   //argout typemap for const std::string&
13888
13889   return jresult;
13890 }
13891
13892
13893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13894   unsigned int jresult ;
13895   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13896   Dali::Property::Index arg2 ;
13897   bool result;
13898
13899   arg1 = (Dali::Property::Key *)jarg1;
13900   arg2 = (Dali::Property::Index)jarg2;
13901   {
13902     try {
13903       result = (bool)(arg1)->operator !=(arg2);
13904     } catch (std::out_of_range& e) {
13905       {
13906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13907       };
13908     } catch (std::exception& e) {
13909       {
13910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13911       };
13912     } catch (...) {
13913       {
13914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13915       };
13916     }
13917   }
13918   jresult = result;
13919   return jresult;
13920 }
13921
13922
13923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13924   unsigned int jresult ;
13925   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13926   Dali::Property::Key *arg2 = 0 ;
13927   bool result;
13928
13929   arg1 = (Dali::Property::Key *)jarg1;
13930   arg2 = (Dali::Property::Key *)jarg2;
13931   if (!arg2) {
13932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13933     return 0;
13934   }
13935   {
13936     try {
13937       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13938     } catch (std::out_of_range& e) {
13939       {
13940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13941       };
13942     } catch (std::exception& e) {
13943       {
13944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13945       };
13946     } catch (...) {
13947       {
13948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13949       };
13950     }
13951   }
13952   jresult = result;
13953   return jresult;
13954 }
13955
13956
13957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
13958   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13959
13960   arg1 = (Dali::Property::Key *)jarg1;
13961   {
13962     try {
13963       delete arg1;
13964     } catch (std::out_of_range& e) {
13965       {
13966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13967       };
13968     } catch (std::exception& e) {
13969       {
13970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13971       };
13972     } catch (...) {
13973       {
13974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13975       };
13976     }
13977   }
13978 }
13979
13980
13981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
13982   void * jresult ;
13983   Dali::Property::Map *result = 0 ;
13984
13985   {
13986     try {
13987       result = (Dali::Property::Map *)new Dali::Property::Map();
13988     } catch (std::out_of_range& e) {
13989       {
13990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13991       };
13992     } catch (std::exception& e) {
13993       {
13994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13995       };
13996     } catch (...) {
13997       {
13998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13999       };
14000     }
14001   }
14002   jresult = (void *)result;
14003   return jresult;
14004 }
14005
14006
14007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14008   void * jresult ;
14009   Dali::Property::Map *arg1 = 0 ;
14010   Dali::Property::Map *result = 0 ;
14011
14012   arg1 = (Dali::Property::Map *)jarg1;
14013   if (!arg1) {
14014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14015     return 0;
14016   }
14017   {
14018     try {
14019       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14020     } catch (std::out_of_range& e) {
14021       {
14022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14023       };
14024     } catch (std::exception& e) {
14025       {
14026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14027       };
14028     } catch (...) {
14029       {
14030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14031       };
14032     }
14033   }
14034   jresult = (void *)result;
14035   return jresult;
14036 }
14037
14038
14039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14040   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14041
14042   arg1 = (Dali::Property::Map *)jarg1;
14043   {
14044     try {
14045       delete arg1;
14046     } catch (std::out_of_range& e) {
14047       {
14048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14049       };
14050     } catch (std::exception& e) {
14051       {
14052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14053       };
14054     } catch (...) {
14055       {
14056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14057       };
14058     }
14059   }
14060 }
14061
14062
14063 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14064   unsigned long jresult ;
14065   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14066   Dali::Property::Map::SizeType result;
14067
14068   arg1 = (Dali::Property::Map *)jarg1;
14069   {
14070     try {
14071       result = ((Dali::Property::Map const *)arg1)->Count();
14072     } catch (std::out_of_range& e) {
14073       {
14074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14075       };
14076     } catch (std::exception& e) {
14077       {
14078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14079       };
14080     } catch (...) {
14081       {
14082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14083       };
14084     }
14085   }
14086   jresult = (unsigned long)result;
14087   return jresult;
14088 }
14089
14090
14091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14092   unsigned int jresult ;
14093   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14094   bool result;
14095
14096   arg1 = (Dali::Property::Map *)jarg1;
14097   {
14098     try {
14099       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14100     } catch (std::out_of_range& e) {
14101       {
14102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14103       };
14104     } catch (std::exception& e) {
14105       {
14106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14107       };
14108     } catch (...) {
14109       {
14110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14111       };
14112     }
14113   }
14114   jresult = result;
14115   return jresult;
14116 }
14117
14118
14119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14120   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14121   char *arg2 = (char *) 0 ;
14122   Dali::Property::Value *arg3 = 0 ;
14123
14124   arg1 = (Dali::Property::Map *)jarg1;
14125   arg2 = (char *)jarg2;
14126   arg3 = (Dali::Property::Value *)jarg3;
14127   if (!arg3) {
14128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14129     return ;
14130   }
14131   {
14132     try {
14133       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14134     } catch (std::out_of_range& e) {
14135       {
14136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14137       };
14138     } catch (std::exception& e) {
14139       {
14140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14141       };
14142     } catch (...) {
14143       {
14144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14145       };
14146     }
14147   }
14148 }
14149
14150
14151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14152   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14153   Dali::Property::Index arg2 ;
14154   Dali::Property::Value *arg3 = 0 ;
14155
14156   arg1 = (Dali::Property::Map *)jarg1;
14157   arg2 = (Dali::Property::Index)jarg2;
14158   arg3 = (Dali::Property::Value *)jarg3;
14159   if (!arg3) {
14160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14161     return ;
14162   }
14163   {
14164     try {
14165       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14166     } catch (std::out_of_range& e) {
14167       {
14168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14169       };
14170     } catch (std::exception& e) {
14171       {
14172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14173       };
14174     } catch (...) {
14175       {
14176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14177       };
14178     }
14179   }
14180 }
14181
14182
14183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14184   void * jresult ;
14185   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14186   char *arg2 = (char *) 0 ;
14187   Dali::Property::Value *arg3 = 0 ;
14188   Dali::Property::Map *result = 0 ;
14189
14190   arg1 = (Dali::Property::Map *)jarg1;
14191   arg2 = (char *)jarg2;
14192   arg3 = (Dali::Property::Value *)jarg3;
14193   if (!arg3) {
14194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14195     return 0;
14196   }
14197   {
14198     try {
14199       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14200     } catch (std::out_of_range& e) {
14201       {
14202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14203       };
14204     } catch (std::exception& e) {
14205       {
14206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14207       };
14208     } catch (...) {
14209       {
14210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14211       };
14212     }
14213   }
14214   jresult = (void *)result;
14215   return jresult;
14216 }
14217
14218
14219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14220   void * jresult ;
14221   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14222   Dali::Property::Index arg2 ;
14223   Dali::Property::Value *arg3 = 0 ;
14224   Dali::Property::Map *result = 0 ;
14225
14226   arg1 = (Dali::Property::Map *)jarg1;
14227   arg2 = (Dali::Property::Index)jarg2;
14228   arg3 = (Dali::Property::Value *)jarg3;
14229   if (!arg3) {
14230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14231     return 0;
14232   }
14233   {
14234     try {
14235       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14236     } catch (std::out_of_range& e) {
14237       {
14238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14239       };
14240     } catch (std::exception& e) {
14241       {
14242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14243       };
14244     } catch (...) {
14245       {
14246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14247       };
14248     }
14249   }
14250   jresult = (void *)result;
14251   return jresult;
14252 }
14253
14254
14255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14256   void * jresult ;
14257   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14258   Dali::Property::Map::SizeType arg2 ;
14259   Dali::Property::Value *result = 0 ;
14260
14261   arg1 = (Dali::Property::Map *)jarg1;
14262   arg2 = (Dali::Property::Map::SizeType)jarg2;
14263   {
14264     try {
14265       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14266     } catch (std::out_of_range& e) {
14267       {
14268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14269       };
14270     } catch (std::exception& e) {
14271       {
14272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14273       };
14274     } catch (...) {
14275       {
14276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14277       };
14278     }
14279   }
14280   jresult = (void *)result;
14281   return jresult;
14282 }
14283
14284
14285 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14286   char * jresult ;
14287   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14288   Dali::Property::Map::SizeType arg2 ;
14289   std::string *result = 0 ;
14290
14291   arg1 = (Dali::Property::Map *)jarg1;
14292   arg2 = (Dali::Property::Map::SizeType)jarg2;
14293   {
14294     try {
14295       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14296     } catch (std::out_of_range& e) {
14297       {
14298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14299       };
14300     } catch (std::exception& e) {
14301       {
14302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14303       };
14304     } catch (...) {
14305       {
14306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14307       };
14308     }
14309   }
14310   jresult = SWIG_csharp_string_callback(result->c_str());
14311   return jresult;
14312 }
14313
14314
14315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14316   void * jresult ;
14317   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14318   Dali::Property::Map::SizeType arg2 ;
14319   SwigValueWrapper< Dali::Property::Key > result;
14320
14321   arg1 = (Dali::Property::Map *)jarg1;
14322   arg2 = (Dali::Property::Map::SizeType)jarg2;
14323   {
14324     try {
14325       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14326     } catch (std::out_of_range& e) {
14327       {
14328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14329       };
14330     } catch (std::exception& e) {
14331       {
14332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14333       };
14334     } catch (...) {
14335       {
14336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14337       };
14338     }
14339   }
14340   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14341   return jresult;
14342 }
14343
14344
14345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14346   void * jresult ;
14347   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14348   Dali::Property::Map::SizeType arg2 ;
14349   StringValuePair *result = 0 ;
14350
14351   arg1 = (Dali::Property::Map *)jarg1;
14352   arg2 = (Dali::Property::Map::SizeType)jarg2;
14353   {
14354     try {
14355       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14356     } catch (std::out_of_range& e) {
14357       {
14358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14359       };
14360     } catch (std::exception& e) {
14361       {
14362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14363       };
14364     } catch (...) {
14365       {
14366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14367       };
14368     }
14369   }
14370   jresult = (void *)result;
14371   return jresult;
14372 }
14373
14374
14375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14376   void * jresult ;
14377   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14378   char *arg2 = (char *) 0 ;
14379   Dali::Property::Value *result = 0 ;
14380
14381   arg1 = (Dali::Property::Map *)jarg1;
14382   arg2 = (char *)jarg2;
14383   {
14384     try {
14385       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14386     } catch (std::out_of_range& e) {
14387       {
14388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14389       };
14390     } catch (std::exception& e) {
14391       {
14392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14393       };
14394     } catch (...) {
14395       {
14396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14397       };
14398     }
14399   }
14400   jresult = (void *)result;
14401   return jresult;
14402 }
14403
14404
14405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14406   void * jresult ;
14407   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14408   Dali::Property::Index arg2 ;
14409   Dali::Property::Value *result = 0 ;
14410
14411   arg1 = (Dali::Property::Map *)jarg1;
14412   arg2 = (Dali::Property::Index)jarg2;
14413   {
14414     try {
14415       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14416     } catch (std::out_of_range& e) {
14417       {
14418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14419       };
14420     } catch (std::exception& e) {
14421       {
14422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14423       };
14424     } catch (...) {
14425       {
14426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14427       };
14428     }
14429   }
14430   jresult = (void *)result;
14431   return jresult;
14432 }
14433
14434
14435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14436   void * jresult ;
14437   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14438   Dali::Property::Index arg2 ;
14439   std::string *arg3 = 0 ;
14440   Dali::Property::Value *result = 0 ;
14441
14442   arg1 = (Dali::Property::Map *)jarg1;
14443   arg2 = (Dali::Property::Index)jarg2;
14444   if (!jarg3) {
14445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14446     return 0;
14447   }
14448   std::string arg3_str(jarg3);
14449   arg3 = &arg3_str;
14450   {
14451     try {
14452       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14453     } catch (std::out_of_range& e) {
14454       {
14455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14456       };
14457     } catch (std::exception& e) {
14458       {
14459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14460       };
14461     } catch (...) {
14462       {
14463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14464       };
14465     }
14466   }
14467   jresult = (void *)result;
14468
14469   //argout typemap for const std::string&
14470
14471   return jresult;
14472 }
14473
14474
14475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14476   void * jresult ;
14477   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14478   std::string *arg2 = 0 ;
14479   Dali::Property::Type arg3 ;
14480   Dali::Property::Value *result = 0 ;
14481
14482   arg1 = (Dali::Property::Map *)jarg1;
14483   if (!jarg2) {
14484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14485     return 0;
14486   }
14487   std::string arg2_str(jarg2);
14488   arg2 = &arg2_str;
14489   arg3 = (Dali::Property::Type)jarg3;
14490   {
14491     try {
14492       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14493     } catch (std::out_of_range& e) {
14494       {
14495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14496       };
14497     } catch (std::exception& e) {
14498       {
14499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14500       };
14501     } catch (...) {
14502       {
14503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14504       };
14505     }
14506   }
14507   jresult = (void *)result;
14508
14509   //argout typemap for const std::string&
14510
14511   return jresult;
14512 }
14513
14514
14515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14516   void * jresult ;
14517   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14518   Dali::Property::Index arg2 ;
14519   Dali::Property::Type arg3 ;
14520   Dali::Property::Value *result = 0 ;
14521
14522   arg1 = (Dali::Property::Map *)jarg1;
14523   arg2 = (Dali::Property::Index)jarg2;
14524   arg3 = (Dali::Property::Type)jarg3;
14525   {
14526     try {
14527       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14528     } catch (std::out_of_range& e) {
14529       {
14530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14531       };
14532     } catch (std::exception& e) {
14533       {
14534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14535       };
14536     } catch (...) {
14537       {
14538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14539       };
14540     }
14541   }
14542   jresult = (void *)result;
14543   return jresult;
14544 }
14545
14546
14547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14548   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14549
14550   arg1 = (Dali::Property::Map *)jarg1;
14551   {
14552     try {
14553       (arg1)->Clear();
14554     } catch (std::out_of_range& e) {
14555       {
14556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14557       };
14558     } catch (std::exception& e) {
14559       {
14560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14561       };
14562     } catch (...) {
14563       {
14564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14565       };
14566     }
14567   }
14568 }
14569
14570
14571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14572   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14573   Dali::Property::Map *arg2 = 0 ;
14574
14575   arg1 = (Dali::Property::Map *)jarg1;
14576   arg2 = (Dali::Property::Map *)jarg2;
14577   if (!arg2) {
14578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14579     return ;
14580   }
14581   {
14582     try {
14583       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14584     } catch (std::out_of_range& e) {
14585       {
14586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14587       };
14588     } catch (std::exception& e) {
14589       {
14590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14591       };
14592     } catch (...) {
14593       {
14594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14595       };
14596     }
14597   }
14598 }
14599
14600
14601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14602   void * jresult ;
14603   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14604   std::string *arg2 = 0 ;
14605   Dali::Property::Value *result = 0 ;
14606
14607   arg1 = (Dali::Property::Map *)jarg1;
14608   if (!jarg2) {
14609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14610     return 0;
14611   }
14612   std::string arg2_str(jarg2);
14613   arg2 = &arg2_str;
14614   {
14615     try {
14616       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*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
14633   //argout typemap for const std::string&
14634
14635   return jresult;
14636 }
14637
14638
14639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14640   void * jresult ;
14641   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14642   Dali::Property::Index arg2 ;
14643   Dali::Property::Value *result = 0 ;
14644
14645   arg1 = (Dali::Property::Map *)jarg1;
14646   arg2 = (Dali::Property::Index)jarg2;
14647   {
14648     try {
14649       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14650     } catch (std::out_of_range& e) {
14651       {
14652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14653       };
14654     } catch (std::exception& e) {
14655       {
14656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14657       };
14658     } catch (...) {
14659       {
14660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14661       };
14662     }
14663   }
14664   jresult = (void *)result;
14665   return jresult;
14666 }
14667
14668
14669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14670   void * jresult ;
14671   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14672   Dali::Property::Map *arg2 = 0 ;
14673   Dali::Property::Map *result = 0 ;
14674
14675   arg1 = (Dali::Property::Map *)jarg1;
14676   arg2 = (Dali::Property::Map *)jarg2;
14677   if (!arg2) {
14678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14679     return 0;
14680   }
14681   {
14682     try {
14683       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14684     } catch (std::out_of_range& e) {
14685       {
14686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14687       };
14688     } catch (std::exception& e) {
14689       {
14690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14691       };
14692     } catch (...) {
14693       {
14694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14695       };
14696     }
14697   }
14698   jresult = (void *)result;
14699   return jresult;
14700 }
14701
14702
14703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14704   void * jresult ;
14705   Dali::Property::Value *result = 0 ;
14706
14707   {
14708     try {
14709       result = (Dali::Property::Value *)new Dali::Property::Value();
14710     } catch (std::out_of_range& e) {
14711       {
14712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14713       };
14714     } catch (std::exception& e) {
14715       {
14716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14717       };
14718     } catch (...) {
14719       {
14720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14721       };
14722     }
14723   }
14724   jresult = (void *)result;
14725   return jresult;
14726 }
14727
14728
14729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14730   void * jresult ;
14731   bool arg1 ;
14732   Dali::Property::Value *result = 0 ;
14733
14734   arg1 = jarg1 ? true : false;
14735   {
14736     try {
14737       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14738     } catch (std::out_of_range& e) {
14739       {
14740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14741       };
14742     } catch (std::exception& e) {
14743       {
14744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14745       };
14746     } catch (...) {
14747       {
14748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14749       };
14750     }
14751   }
14752   jresult = (void *)result;
14753   return jresult;
14754 }
14755
14756
14757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14758   void * jresult ;
14759   int arg1 ;
14760   Dali::Property::Value *result = 0 ;
14761
14762   arg1 = (int)jarg1;
14763   {
14764     try {
14765       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14766     } catch (std::out_of_range& e) {
14767       {
14768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14769       };
14770     } catch (std::exception& e) {
14771       {
14772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14773       };
14774     } catch (...) {
14775       {
14776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14777       };
14778     }
14779   }
14780   jresult = (void *)result;
14781   return jresult;
14782 }
14783
14784
14785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14786   void * jresult ;
14787   float arg1 ;
14788   Dali::Property::Value *result = 0 ;
14789
14790   arg1 = (float)jarg1;
14791   {
14792     try {
14793       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14794     } catch (std::out_of_range& e) {
14795       {
14796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14797       };
14798     } catch (std::exception& e) {
14799       {
14800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14801       };
14802     } catch (...) {
14803       {
14804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14805       };
14806     }
14807   }
14808   jresult = (void *)result;
14809   return jresult;
14810 }
14811
14812
14813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14814   void * jresult ;
14815   Dali::Vector2 *arg1 = 0 ;
14816   Dali::Property::Value *result = 0 ;
14817
14818   arg1 = (Dali::Vector2 *)jarg1;
14819   if (!arg1) {
14820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14821     return 0;
14822   }
14823   {
14824     try {
14825       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14826     } catch (std::out_of_range& e) {
14827       {
14828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14829       };
14830     } catch (std::exception& e) {
14831       {
14832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14833       };
14834     } catch (...) {
14835       {
14836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14837       };
14838     }
14839   }
14840   jresult = (void *)result;
14841   return jresult;
14842 }
14843
14844
14845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14846   void * jresult ;
14847   Dali::Vector3 *arg1 = 0 ;
14848   Dali::Property::Value *result = 0 ;
14849
14850   arg1 = (Dali::Vector3 *)jarg1;
14851   if (!arg1) {
14852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14853     return 0;
14854   }
14855   {
14856     try {
14857       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14858     } catch (std::out_of_range& e) {
14859       {
14860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14861       };
14862     } catch (std::exception& e) {
14863       {
14864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14865       };
14866     } catch (...) {
14867       {
14868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14869       };
14870     }
14871   }
14872   jresult = (void *)result;
14873   return jresult;
14874 }
14875
14876
14877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14878   void * jresult ;
14879   Dali::Vector4 *arg1 = 0 ;
14880   Dali::Property::Value *result = 0 ;
14881
14882   arg1 = (Dali::Vector4 *)jarg1;
14883   if (!arg1) {
14884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14885     return 0;
14886   }
14887   {
14888     try {
14889       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14890     } catch (std::out_of_range& e) {
14891       {
14892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14893       };
14894     } catch (std::exception& e) {
14895       {
14896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14897       };
14898     } catch (...) {
14899       {
14900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14901       };
14902     }
14903   }
14904   jresult = (void *)result;
14905   return jresult;
14906 }
14907
14908
14909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14910   void * jresult ;
14911   Dali::Matrix3 *arg1 = 0 ;
14912   Dali::Property::Value *result = 0 ;
14913
14914   arg1 = (Dali::Matrix3 *)jarg1;
14915   if (!arg1) {
14916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14917     return 0;
14918   }
14919   {
14920     try {
14921       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14922     } catch (std::out_of_range& e) {
14923       {
14924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14925       };
14926     } catch (std::exception& e) {
14927       {
14928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14929       };
14930     } catch (...) {
14931       {
14932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14933       };
14934     }
14935   }
14936   jresult = (void *)result;
14937   return jresult;
14938 }
14939
14940
14941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
14942   void * jresult ;
14943   Dali::Matrix *arg1 = 0 ;
14944   Dali::Property::Value *result = 0 ;
14945
14946   arg1 = (Dali::Matrix *)jarg1;
14947   if (!arg1) {
14948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
14949     return 0;
14950   }
14951   {
14952     try {
14953       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
14954     } catch (std::out_of_range& e) {
14955       {
14956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14957       };
14958     } catch (std::exception& e) {
14959       {
14960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14961       };
14962     } catch (...) {
14963       {
14964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14965       };
14966     }
14967   }
14968   jresult = (void *)result;
14969   return jresult;
14970 }
14971
14972
14973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
14974   void * jresult ;
14975   Dali::Rect< int > *arg1 = 0 ;
14976   Dali::Property::Value *result = 0 ;
14977
14978   arg1 = (Dali::Rect< int > *)jarg1;
14979   if (!arg1) {
14980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
14981     return 0;
14982   }
14983   {
14984     try {
14985       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
14986     } catch (std::out_of_range& e) {
14987       {
14988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14989       };
14990     } catch (std::exception& e) {
14991       {
14992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14993       };
14994     } catch (...) {
14995       {
14996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14997       };
14998     }
14999   }
15000   jresult = (void *)result;
15001   return jresult;
15002 }
15003
15004
15005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15006   void * jresult ;
15007   Dali::AngleAxis *arg1 = 0 ;
15008   Dali::Property::Value *result = 0 ;
15009
15010   arg1 = (Dali::AngleAxis *)jarg1;
15011   if (!arg1) {
15012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15013     return 0;
15014   }
15015   {
15016     try {
15017       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15018     } catch (std::out_of_range& e) {
15019       {
15020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15021       };
15022     } catch (std::exception& e) {
15023       {
15024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15025       };
15026     } catch (...) {
15027       {
15028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15029       };
15030     }
15031   }
15032   jresult = (void *)result;
15033   return jresult;
15034 }
15035
15036
15037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15038   void * jresult ;
15039   Dali::Quaternion *arg1 = 0 ;
15040   Dali::Property::Value *result = 0 ;
15041
15042   arg1 = (Dali::Quaternion *)jarg1;
15043   if (!arg1) {
15044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15045     return 0;
15046   }
15047   {
15048     try {
15049       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion 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   return jresult;
15066 }
15067
15068
15069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15070   void * jresult ;
15071   std::string *arg1 = 0 ;
15072   Dali::Property::Value *result = 0 ;
15073
15074   if (!jarg1) {
15075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15076     return 0;
15077   }
15078   std::string arg1_str(jarg1);
15079   arg1 = &arg1_str;
15080   {
15081     try {
15082       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15083     } catch (std::out_of_range& e) {
15084       {
15085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15086       };
15087     } catch (std::exception& e) {
15088       {
15089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15090       };
15091     } catch (...) {
15092       {
15093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15094       };
15095     }
15096   }
15097   jresult = (void *)result;
15098
15099   //argout typemap for const std::string&
15100
15101   return jresult;
15102 }
15103
15104
15105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15106   void * jresult ;
15107   Dali::Property::Array *arg1 = 0 ;
15108   Dali::Property::Value *result = 0 ;
15109
15110   arg1 = (Dali::Property::Array *)jarg1;
15111   if (!arg1) {
15112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15113     return 0;
15114   }
15115   {
15116     try {
15117       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15118     } catch (std::out_of_range& e) {
15119       {
15120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15121       };
15122     } catch (std::exception& e) {
15123       {
15124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15125       };
15126     } catch (...) {
15127       {
15128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15129       };
15130     }
15131   }
15132   jresult = (void *)result;
15133   return jresult;
15134 }
15135
15136
15137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15138   void * jresult ;
15139   Dali::Property::Map *arg1 = 0 ;
15140   Dali::Property::Value *result = 0 ;
15141
15142   arg1 = (Dali::Property::Map *)jarg1;
15143   if (!arg1) {
15144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15145     return 0;
15146   }
15147   {
15148     try {
15149       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15150     } catch (std::out_of_range& e) {
15151       {
15152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15153       };
15154     } catch (std::exception& e) {
15155       {
15156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15157       };
15158     } catch (...) {
15159       {
15160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15161       };
15162     }
15163   }
15164   jresult = (void *)result;
15165   return jresult;
15166 }
15167
15168
15169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15170   void * jresult ;
15171   Dali::Property::Type arg1 ;
15172   Dali::Property::Value *result = 0 ;
15173
15174   arg1 = (Dali::Property::Type)jarg1;
15175   {
15176     try {
15177       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15178     } catch (std::out_of_range& e) {
15179       {
15180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15181       };
15182     } catch (std::exception& e) {
15183       {
15184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15185       };
15186     } catch (...) {
15187       {
15188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15189       };
15190     }
15191   }
15192   jresult = (void *)result;
15193   return jresult;
15194 }
15195
15196
15197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15198   void * jresult ;
15199   Dali::Property::Value *arg1 = 0 ;
15200   Dali::Property::Value *result = 0 ;
15201
15202   arg1 = (Dali::Property::Value *)jarg1;
15203   if (!arg1) {
15204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15205     return 0;
15206   }
15207   {
15208     try {
15209       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15210     } catch (std::out_of_range& e) {
15211       {
15212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15213       };
15214     } catch (std::exception& e) {
15215       {
15216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15217       };
15218     } catch (...) {
15219       {
15220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15221       };
15222     }
15223   }
15224   jresult = (void *)result;
15225   return jresult;
15226 }
15227
15228
15229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15230   void * jresult ;
15231   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15232   Dali::Property::Value *arg2 = 0 ;
15233   Dali::Property::Value *result = 0 ;
15234
15235   arg1 = (Dali::Property::Value *)jarg1;
15236   arg2 = (Dali::Property::Value *)jarg2;
15237   if (!arg2) {
15238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15239     return 0;
15240   }
15241   {
15242     try {
15243       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15244     } catch (std::out_of_range& e) {
15245       {
15246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15247       };
15248     } catch (std::exception& e) {
15249       {
15250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15251       };
15252     } catch (...) {
15253       {
15254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15255       };
15256     }
15257   }
15258   jresult = (void *)result;
15259   return jresult;
15260 }
15261
15262
15263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15264   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15265
15266   arg1 = (Dali::Property::Value *)jarg1;
15267   {
15268     try {
15269       delete arg1;
15270     } catch (std::out_of_range& e) {
15271       {
15272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15273       };
15274     } catch (std::exception& e) {
15275       {
15276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15277       };
15278     } catch (...) {
15279       {
15280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15281       };
15282     }
15283   }
15284 }
15285
15286
15287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15288   int jresult ;
15289   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15290   Dali::Property::Type result;
15291
15292   arg1 = (Dali::Property::Value *)jarg1;
15293   {
15294     try {
15295       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15296     } catch (std::out_of_range& e) {
15297       {
15298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15299       };
15300     } catch (std::exception& e) {
15301       {
15302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15303       };
15304     } catch (...) {
15305       {
15306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15307       };
15308     }
15309   }
15310   jresult = (int)result;
15311   return jresult;
15312 }
15313
15314
15315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15316   unsigned int jresult ;
15317   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15318   bool *arg2 = 0 ;
15319   bool result;
15320
15321   arg1 = (Dali::Property::Value *)jarg1;
15322   arg2 = (bool *)jarg2;
15323   {
15324     try {
15325       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15326     } catch (std::out_of_range& e) {
15327       {
15328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15329       };
15330     } catch (std::exception& e) {
15331       {
15332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15333       };
15334     } catch (...) {
15335       {
15336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15337       };
15338     }
15339   }
15340   jresult = result;
15341   return jresult;
15342 }
15343
15344
15345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15346   unsigned int jresult ;
15347   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15348   float *arg2 = 0 ;
15349   bool result;
15350
15351   arg1 = (Dali::Property::Value *)jarg1;
15352   arg2 = (float *)jarg2;
15353   {
15354     try {
15355       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15356     } catch (std::out_of_range& e) {
15357       {
15358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15359       };
15360     } catch (std::exception& e) {
15361       {
15362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15363       };
15364     } catch (...) {
15365       {
15366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15367       };
15368     }
15369   }
15370   jresult = result;
15371   return jresult;
15372 }
15373
15374
15375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15376   unsigned int jresult ;
15377   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15378   int *arg2 = 0 ;
15379   bool result;
15380
15381   arg1 = (Dali::Property::Value *)jarg1;
15382   arg2 = (int *)jarg2;
15383   {
15384     try {
15385       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15386     } catch (std::out_of_range& e) {
15387       {
15388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15389       };
15390     } catch (std::exception& e) {
15391       {
15392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15393       };
15394     } catch (...) {
15395       {
15396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15397       };
15398     }
15399   }
15400   jresult = result;
15401   return jresult;
15402 }
15403
15404
15405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15406   unsigned int jresult ;
15407   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15408   Dali::Rect< int > *arg2 = 0 ;
15409   bool result;
15410
15411   arg1 = (Dali::Property::Value *)jarg1;
15412   arg2 = (Dali::Rect< int > *)jarg2;
15413   if (!arg2) {
15414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15415     return 0;
15416   }
15417   {
15418     try {
15419       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15420     } catch (std::out_of_range& e) {
15421       {
15422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15423       };
15424     } catch (std::exception& e) {
15425       {
15426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15427       };
15428     } catch (...) {
15429       {
15430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15431       };
15432     }
15433   }
15434   jresult = result;
15435   return jresult;
15436 }
15437
15438
15439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15440   unsigned int jresult ;
15441   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15442   Dali::Vector2 *arg2 = 0 ;
15443   bool result;
15444
15445   arg1 = (Dali::Property::Value *)jarg1;
15446   arg2 = (Dali::Vector2 *)jarg2;
15447   if (!arg2) {
15448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15449     return 0;
15450   }
15451   {
15452     try {
15453       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15454     } catch (std::out_of_range& e) {
15455       {
15456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15457       };
15458     } catch (std::exception& e) {
15459       {
15460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15461       };
15462     } catch (...) {
15463       {
15464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15465       };
15466     }
15467   }
15468   jresult = result;
15469   return jresult;
15470 }
15471
15472
15473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15474   unsigned int jresult ;
15475   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15476   Dali::Vector3 *arg2 = 0 ;
15477   bool result;
15478
15479   arg1 = (Dali::Property::Value *)jarg1;
15480   arg2 = (Dali::Vector3 *)jarg2;
15481   if (!arg2) {
15482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15483     return 0;
15484   }
15485   {
15486     try {
15487       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15488     } catch (std::out_of_range& e) {
15489       {
15490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15491       };
15492     } catch (std::exception& e) {
15493       {
15494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15495       };
15496     } catch (...) {
15497       {
15498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15499       };
15500     }
15501   }
15502   jresult = result;
15503   return jresult;
15504 }
15505
15506
15507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15508   unsigned int jresult ;
15509   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15510   Dali::Vector4 *arg2 = 0 ;
15511   bool result;
15512
15513   arg1 = (Dali::Property::Value *)jarg1;
15514   arg2 = (Dali::Vector4 *)jarg2;
15515   if (!arg2) {
15516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15517     return 0;
15518   }
15519   {
15520     try {
15521       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15522     } catch (std::out_of_range& e) {
15523       {
15524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15525       };
15526     } catch (std::exception& e) {
15527       {
15528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15529       };
15530     } catch (...) {
15531       {
15532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15533       };
15534     }
15535   }
15536   jresult = result;
15537   return jresult;
15538 }
15539
15540
15541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15542   unsigned int jresult ;
15543   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15544   Dali::Matrix3 *arg2 = 0 ;
15545   bool result;
15546
15547   arg1 = (Dali::Property::Value *)jarg1;
15548   arg2 = (Dali::Matrix3 *)jarg2;
15549   if (!arg2) {
15550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15551     return 0;
15552   }
15553   {
15554     try {
15555       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15556     } catch (std::out_of_range& e) {
15557       {
15558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15559       };
15560     } catch (std::exception& e) {
15561       {
15562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15563       };
15564     } catch (...) {
15565       {
15566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15567       };
15568     }
15569   }
15570   jresult = result;
15571   return jresult;
15572 }
15573
15574
15575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15576   unsigned int jresult ;
15577   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15578   Dali::Matrix *arg2 = 0 ;
15579   bool result;
15580
15581   arg1 = (Dali::Property::Value *)jarg1;
15582   arg2 = (Dali::Matrix *)jarg2;
15583   if (!arg2) {
15584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15585     return 0;
15586   }
15587   {
15588     try {
15589       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15590     } catch (std::out_of_range& e) {
15591       {
15592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15593       };
15594     } catch (std::exception& e) {
15595       {
15596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15597       };
15598     } catch (...) {
15599       {
15600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15601       };
15602     }
15603   }
15604   jresult = result;
15605   return jresult;
15606 }
15607
15608
15609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15610   unsigned int jresult ;
15611   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15612   Dali::AngleAxis *arg2 = 0 ;
15613   bool result;
15614
15615   arg1 = (Dali::Property::Value *)jarg1;
15616   arg2 = (Dali::AngleAxis *)jarg2;
15617   if (!arg2) {
15618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15619     return 0;
15620   }
15621   {
15622     try {
15623       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15624     } catch (std::out_of_range& e) {
15625       {
15626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15627       };
15628     } catch (std::exception& e) {
15629       {
15630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15631       };
15632     } catch (...) {
15633       {
15634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15635       };
15636     }
15637   }
15638   jresult = result;
15639   return jresult;
15640 }
15641
15642
15643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15644   unsigned int jresult ;
15645   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15646   Dali::Quaternion *arg2 = 0 ;
15647   bool result;
15648
15649   arg1 = (Dali::Property::Value *)jarg1;
15650   arg2 = (Dali::Quaternion *)jarg2;
15651   if (!arg2) {
15652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15653     return 0;
15654   }
15655   {
15656     try {
15657       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15658     } catch (std::out_of_range& e) {
15659       {
15660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15661       };
15662     } catch (std::exception& e) {
15663       {
15664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15665       };
15666     } catch (...) {
15667       {
15668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15669       };
15670     }
15671   }
15672   jresult = result;
15673   return jresult;
15674 }
15675
15676
15677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15678   unsigned int jresult ;
15679   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15680   std::string *arg2 = 0 ;
15681   bool result;
15682
15683   arg1 = (Dali::Property::Value *)jarg1;
15684
15685   //typemap in
15686   std::string temp;
15687   arg2 = &temp;
15688
15689   {
15690     try {
15691       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15692     } catch (std::out_of_range& e) {
15693       {
15694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15695       };
15696     } catch (std::exception& e) {
15697       {
15698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15699       };
15700     } catch (...) {
15701       {
15702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15703       };
15704     }
15705   }
15706   jresult = result;
15707
15708   //Typemap argout in c++ file.
15709   //This will convert c++ string to c# string
15710   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15711
15712   return jresult;
15713 }
15714
15715
15716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15717   unsigned int jresult ;
15718   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15719   Dali::Property::Array *arg2 = 0 ;
15720   bool result;
15721
15722   arg1 = (Dali::Property::Value *)jarg1;
15723   arg2 = (Dali::Property::Array *)jarg2;
15724   if (!arg2) {
15725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15726     return 0;
15727   }
15728   {
15729     try {
15730       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15731     } catch (std::out_of_range& e) {
15732       {
15733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15734       };
15735     } catch (std::exception& e) {
15736       {
15737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15738       };
15739     } catch (...) {
15740       {
15741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15742       };
15743     }
15744   }
15745   jresult = result;
15746   return jresult;
15747 }
15748
15749
15750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15751   unsigned int jresult ;
15752   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15753   Dali::Property::Map *arg2 = 0 ;
15754   bool result;
15755
15756   arg1 = (Dali::Property::Value *)jarg1;
15757   arg2 = (Dali::Property::Map *)jarg2;
15758   if (!arg2) {
15759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15760     return 0;
15761   }
15762   {
15763     try {
15764       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15765     } catch (std::out_of_range& e) {
15766       {
15767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15768       };
15769     } catch (std::exception& e) {
15770       {
15771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15772       };
15773     } catch (...) {
15774       {
15775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15776       };
15777     }
15778   }
15779   jresult = result;
15780   return jresult;
15781 }
15782
15783
15784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15785   void * jresult ;
15786   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15787   Dali::Property::Array *result = 0 ;
15788
15789   arg1 = (Dali::Property::Value *)jarg1;
15790   {
15791     try {
15792       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15793     } catch (std::out_of_range& e) {
15794       {
15795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15796       };
15797     } catch (std::exception& e) {
15798       {
15799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15800       };
15801     } catch (...) {
15802       {
15803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15804       };
15805     }
15806   }
15807   jresult = (void *)result;
15808   return jresult;
15809 }
15810
15811
15812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15813   void * jresult ;
15814   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15815   Dali::Property::Map *result = 0 ;
15816
15817   arg1 = (Dali::Property::Value *)jarg1;
15818   {
15819     try {
15820       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15821     } catch (std::out_of_range& e) {
15822       {
15823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15824       };
15825     } catch (std::exception& e) {
15826       {
15827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15828       };
15829     } catch (...) {
15830       {
15831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15832       };
15833     }
15834   }
15835   jresult = (void *)result;
15836   return jresult;
15837 }
15838
15839
15840 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15841   char * jresult ;
15842   Dali::Property::Type arg1 ;
15843   char *result = 0 ;
15844
15845   arg1 = (Dali::Property::Type)jarg1;
15846   {
15847     try {
15848       result = (char *)Dali::PropertyTypes::GetName(arg1);
15849     } catch (std::out_of_range& e) {
15850       {
15851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15852       };
15853     } catch (std::exception& e) {
15854       {
15855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15856       };
15857     } catch (...) {
15858       {
15859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15860       };
15861     }
15862   }
15863   jresult = SWIG_csharp_string_callback((const char *)result);
15864   return jresult;
15865 }
15866
15867
15868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15869   unsigned int jresult ;
15870   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15871   std::string *arg2 = 0 ;
15872   Dali::Property::Map *arg3 = 0 ;
15873   bool result;
15874
15875   arg1 = (Dali::BaseObject *)jarg1;
15876   if (!jarg2) {
15877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15878     return 0;
15879   }
15880   std::string arg2_str(jarg2);
15881   arg2 = &arg2_str;
15882   arg3 = (Dali::Property::Map *)jarg3;
15883   if (!arg3) {
15884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15885     return 0;
15886   }
15887   {
15888     try {
15889       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15890     } catch (std::out_of_range& e) {
15891       {
15892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15893       };
15894     } catch (std::exception& e) {
15895       {
15896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15897       };
15898     } catch (...) {
15899       {
15900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15901       };
15902     }
15903   }
15904   jresult = result;
15905
15906   //argout typemap for const std::string&
15907
15908   return jresult;
15909 }
15910
15911
15912 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15913   char * jresult ;
15914   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15915   std::string *result = 0 ;
15916
15917   arg1 = (Dali::BaseObject *)jarg1;
15918   {
15919     try {
15920       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15921     } catch (std::out_of_range& e) {
15922       {
15923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15924       };
15925     } catch (std::exception& e) {
15926       {
15927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15928       };
15929     } catch (...) {
15930       {
15931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15932       };
15933     }
15934   }
15935   jresult = SWIG_csharp_string_callback(result->c_str());
15936   return jresult;
15937 }
15938
15939
15940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15941   unsigned int jresult ;
15942   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15943   Dali::TypeInfo *arg2 = 0 ;
15944   bool result;
15945
15946   arg1 = (Dali::BaseObject *)jarg1;
15947   arg2 = (Dali::TypeInfo *)jarg2;
15948   if (!arg2) {
15949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15950     return 0;
15951   }
15952   {
15953     try {
15954       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
15955     } catch (std::out_of_range& e) {
15956       {
15957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15958       };
15959     } catch (std::exception& e) {
15960       {
15961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15962       };
15963     } catch (...) {
15964       {
15965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15966       };
15967     }
15968   }
15969   jresult = result;
15970   return jresult;
15971 }
15972
15973
15974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
15975   unsigned int jresult ;
15976   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15977   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
15978   std::string *arg3 = 0 ;
15979   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
15980   bool result;
15981
15982   arg1 = (Dali::BaseObject *)jarg1;
15983   arg2 = (ConnectionTrackerInterface *)jarg2;
15984   if (!jarg3) {
15985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15986     return 0;
15987   }
15988   std::string arg3_str(jarg3);
15989   arg3 = &arg3_str;
15990   arg4 = (FunctorDelegate *)jarg4;
15991   {
15992     try {
15993       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
15994     } catch (std::out_of_range& e) {
15995       {
15996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15997       };
15998     } catch (std::exception& e) {
15999       {
16000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16001       };
16002     } catch (...) {
16003       {
16004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16005       };
16006     }
16007   }
16008   jresult = result;
16009
16010   //argout typemap for const std::string&
16011
16012   return jresult;
16013 }
16014
16015
16016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16017   void * jresult ;
16018   Dali::BaseHandle *arg1 = 0 ;
16019   Dali::BaseObject *result = 0 ;
16020
16021   arg1 = (Dali::BaseHandle *)jarg1;
16022   if (!arg1) {
16023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16024     return 0;
16025   }
16026   {
16027     try {
16028       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16029     } catch (std::out_of_range& e) {
16030       {
16031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16032       };
16033     } catch (std::exception& e) {
16034       {
16035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16036       };
16037     } catch (...) {
16038       {
16039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16040       };
16041     }
16042   }
16043   jresult = (void *)result;
16044   return jresult;
16045 }
16046
16047
16048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16049   void * jresult ;
16050   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16051   Dali::BaseHandle *result = 0 ;
16052
16053   arg1 = (Dali::BaseObject *)jarg1;
16054   {
16055     try {
16056       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16057     } catch (std::out_of_range& e) {
16058       {
16059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16060       };
16061     } catch (std::exception& e) {
16062       {
16063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16064       };
16065     } catch (...) {
16066       {
16067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16068       };
16069     }
16070   }
16071   jresult = (void *)result;
16072   return jresult;
16073 }
16074
16075
16076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16077   void * jresult ;
16078   Dali::BaseHandle *result = 0 ;
16079
16080   {
16081     try {
16082       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16083     } catch (std::out_of_range& e) {
16084       {
16085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16086       };
16087     } catch (std::exception& e) {
16088       {
16089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16090       };
16091     } catch (...) {
16092       {
16093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16094       };
16095     }
16096   }
16097   jresult = (void *)result;
16098   return jresult;
16099 }
16100
16101
16102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16103   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16104
16105   arg1 = (Dali::BaseHandle *)jarg1;
16106   {
16107     try {
16108       delete arg1;
16109     } catch (std::out_of_range& e) {
16110       {
16111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16112       };
16113     } catch (std::exception& e) {
16114       {
16115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16116       };
16117     } catch (...) {
16118       {
16119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16120       };
16121     }
16122   }
16123 }
16124
16125
16126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16127   void * jresult ;
16128   Dali::BaseHandle *arg1 = 0 ;
16129   Dali::BaseHandle *result = 0 ;
16130
16131   arg1 = (Dali::BaseHandle *)jarg1;
16132   if (!arg1) {
16133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16134     return 0;
16135   }
16136   {
16137     try {
16138       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16139     } catch (std::out_of_range& e) {
16140       {
16141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16142       };
16143     } catch (std::exception& e) {
16144       {
16145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16146       };
16147     } catch (...) {
16148       {
16149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16150       };
16151     }
16152   }
16153   jresult = (void *)result;
16154   return jresult;
16155 }
16156
16157
16158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16159   void * jresult ;
16160   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16161   Dali::BaseHandle *arg2 = 0 ;
16162   Dali::BaseHandle *result = 0 ;
16163
16164   arg1 = (Dali::BaseHandle *)jarg1;
16165   arg2 = (Dali::BaseHandle *)jarg2;
16166   if (!arg2) {
16167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16168     return 0;
16169   }
16170   {
16171     try {
16172       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16173     } catch (std::out_of_range& e) {
16174       {
16175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16176       };
16177     } catch (std::exception& e) {
16178       {
16179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16180       };
16181     } catch (...) {
16182       {
16183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16184       };
16185     }
16186   }
16187   jresult = (void *)result;
16188   return jresult;
16189 }
16190
16191
16192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16193   unsigned int jresult ;
16194   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16195   std::string *arg2 = 0 ;
16196   Dali::Property::Map *arg3 = 0 ;
16197   bool result;
16198
16199   arg1 = (Dali::BaseHandle *)jarg1;
16200   if (!jarg2) {
16201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16202     return 0;
16203   }
16204   std::string arg2_str(jarg2);
16205   arg2 = &arg2_str;
16206   arg3 = (Dali::Property::Map *)jarg3;
16207   if (!arg3) {
16208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16209     return 0;
16210   }
16211   {
16212     try {
16213       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16214     } catch (std::out_of_range& e) {
16215       {
16216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16217       };
16218     } catch (std::exception& e) {
16219       {
16220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16221       };
16222     } catch (...) {
16223       {
16224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16225       };
16226     }
16227   }
16228   jresult = result;
16229
16230   //argout typemap for const std::string&
16231
16232   return jresult;
16233 }
16234
16235
16236 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16237   char * jresult ;
16238   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16239   std::string *result = 0 ;
16240
16241   arg1 = (Dali::BaseHandle *)jarg1;
16242   {
16243     try {
16244       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16245     } catch (std::out_of_range& e) {
16246       {
16247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16248       };
16249     } catch (std::exception& e) {
16250       {
16251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16252       };
16253     } catch (...) {
16254       {
16255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16256       };
16257     }
16258   }
16259   jresult = SWIG_csharp_string_callback(result->c_str());
16260   return jresult;
16261 }
16262
16263
16264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16265   unsigned int jresult ;
16266   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16267   Dali::TypeInfo *arg2 = 0 ;
16268   bool result;
16269
16270   arg1 = (Dali::BaseHandle *)jarg1;
16271   arg2 = (Dali::TypeInfo *)jarg2;
16272   if (!arg2) {
16273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16274     return 0;
16275   }
16276   {
16277     try {
16278       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16279     } catch (std::out_of_range& e) {
16280       {
16281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16282       };
16283     } catch (std::exception& e) {
16284       {
16285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16286       };
16287     } catch (...) {
16288       {
16289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16290       };
16291     }
16292   }
16293   jresult = result;
16294   return jresult;
16295 }
16296
16297
16298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16299   void * jresult ;
16300   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16301   Dali::BaseObject *result = 0 ;
16302
16303   arg1 = (Dali::BaseHandle *)jarg1;
16304   {
16305     try {
16306       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16307     } catch (std::out_of_range& e) {
16308       {
16309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16310       };
16311     } catch (std::exception& e) {
16312       {
16313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16314       };
16315     } catch (...) {
16316       {
16317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16318       };
16319     }
16320   }
16321   jresult = (void *)result;
16322   return jresult;
16323 }
16324
16325
16326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16327   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16328
16329   arg1 = (Dali::BaseHandle *)jarg1;
16330   {
16331     try {
16332       (arg1)->Reset();
16333     } catch (std::out_of_range& e) {
16334       {
16335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16336       };
16337     } catch (std::exception& e) {
16338       {
16339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16340       };
16341     } catch (...) {
16342       {
16343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16344       };
16345     }
16346   }
16347 }
16348
16349
16350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16351   unsigned int jresult ;
16352   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16353   Dali::BaseHandle *arg2 = 0 ;
16354   bool result;
16355
16356   arg1 = (Dali::BaseHandle *)jarg1;
16357   arg2 = (Dali::BaseHandle *)jarg2;
16358   if (!arg2) {
16359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16360     return 0;
16361   }
16362   {
16363     try {
16364       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16365     } catch (std::out_of_range& e) {
16366       {
16367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16368       };
16369     } catch (std::exception& e) {
16370       {
16371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16372       };
16373     } catch (...) {
16374       {
16375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16376       };
16377     }
16378   }
16379   jresult = result;
16380   return jresult;
16381 }
16382
16383
16384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16385   unsigned int jresult ;
16386   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16387   Dali::BaseHandle *arg2 = 0 ;
16388   bool result;
16389
16390   arg1 = (Dali::BaseHandle *)jarg1;
16391   arg2 = (Dali::BaseHandle *)jarg2;
16392   if (!arg2) {
16393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16394     return 0;
16395   }
16396   {
16397     try {
16398       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16399     } catch (std::out_of_range& e) {
16400       {
16401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16402       };
16403     } catch (std::exception& e) {
16404       {
16405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16406       };
16407     } catch (...) {
16408       {
16409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16410       };
16411     }
16412   }
16413   jresult = result;
16414   return jresult;
16415 }
16416
16417
16418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16419   void * jresult ;
16420   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16421   Dali::RefObject *result = 0 ;
16422
16423   arg1 = (Dali::BaseHandle *)jarg1;
16424   {
16425     try {
16426       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16427     } catch (std::out_of_range& e) {
16428       {
16429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16430       };
16431     } catch (std::exception& e) {
16432       {
16433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16434       };
16435     } catch (...) {
16436       {
16437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16438       };
16439     }
16440   }
16441   jresult = (void *)result;
16442   return jresult;
16443 }
16444
16445
16446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16447   unsigned int jresult ;
16448   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16449   bool result;
16450
16451   arg1 = (Dali::BaseHandle *)jarg1;
16452   {
16453     try {
16454       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16455     } catch (std::out_of_range& e) {
16456       {
16457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16458       };
16459     } catch (std::exception& e) {
16460       {
16461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16462       };
16463     } catch (...) {
16464       {
16465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16466       };
16467     }
16468   }
16469   jresult = result;
16470   return jresult;
16471 }
16472
16473
16474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16475   unsigned int jresult ;
16476   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16477   Dali::BaseHandle *arg2 = 0 ;
16478   bool result;
16479
16480   arg1 = (Dali::BaseHandle *)jarg1;
16481   arg2 = (Dali::BaseHandle *)jarg2;
16482   if (!arg2) {
16483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16484     return 0;
16485   }
16486   {
16487     try {
16488       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16489     } catch (std::out_of_range& e) {
16490       {
16491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16492       };
16493     } catch (std::exception& e) {
16494       {
16495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16496       };
16497     } catch (...) {
16498       {
16499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16500       };
16501     }
16502   }
16503   jresult = result;
16504   return jresult;
16505 }
16506
16507
16508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16509   unsigned int jresult ;
16510   Dali::BaseHandle *arg1 = 0 ;
16511   Dali::BaseHandle *arg2 = 0 ;
16512   bool result;
16513
16514   arg1 = (Dali::BaseHandle *)jarg1;
16515   if (!arg1) {
16516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16517     return 0;
16518   }
16519   arg2 = (Dali::BaseHandle *)jarg2;
16520   if (!arg2) {
16521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16522     return 0;
16523   }
16524   {
16525     try {
16526       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16527     } catch (std::out_of_range& e) {
16528       {
16529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16530       };
16531     } catch (std::exception& e) {
16532       {
16533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16534       };
16535     } catch (...) {
16536       {
16537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16538       };
16539     }
16540   }
16541   jresult = result;
16542   return jresult;
16543 }
16544
16545
16546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16547   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16548
16549   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16550   {
16551     try {
16552       delete arg1;
16553     } catch (std::out_of_range& e) {
16554       {
16555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16556       };
16557     } catch (std::exception& e) {
16558       {
16559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16560       };
16561     } catch (...) {
16562       {
16563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16564       };
16565     }
16566   }
16567 }
16568
16569
16570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16571   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16572   SlotObserver *arg2 = (SlotObserver *) 0 ;
16573   CallbackBase *arg3 = (CallbackBase *) 0 ;
16574
16575   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16576   arg2 = (SlotObserver *)jarg2;
16577   arg3 = (CallbackBase *)jarg3;
16578   {
16579     try {
16580       (arg1)->SignalConnected(arg2,arg3);
16581     } catch (std::out_of_range& e) {
16582       {
16583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16584       };
16585     } catch (std::exception& e) {
16586       {
16587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16588       };
16589     } catch (...) {
16590       {
16591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16592       };
16593     }
16594   }
16595 }
16596
16597
16598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16599   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16600
16601   arg1 = (Dali::SignalObserver *)jarg1;
16602   {
16603     try {
16604       delete arg1;
16605     } catch (std::out_of_range& e) {
16606       {
16607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16608       };
16609     } catch (std::exception& e) {
16610       {
16611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16612       };
16613     } catch (...) {
16614       {
16615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16616       };
16617     }
16618   }
16619 }
16620
16621
16622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16623   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16624   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16625   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16626
16627   arg1 = (Dali::SignalObserver *)jarg1;
16628   arg2 = (Dali::SlotObserver *)jarg2;
16629   arg3 = (Dali::CallbackBase *)jarg3;
16630   {
16631     try {
16632       (arg1)->SignalDisconnected(arg2,arg3);
16633     } catch (std::out_of_range& e) {
16634       {
16635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16636       };
16637     } catch (std::exception& e) {
16638       {
16639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16640       };
16641     } catch (...) {
16642       {
16643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16644       };
16645     }
16646   }
16647 }
16648
16649
16650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16651   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16652
16653   arg1 = (Dali::SlotObserver *)jarg1;
16654   {
16655     try {
16656       delete arg1;
16657     } catch (std::out_of_range& e) {
16658       {
16659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16660       };
16661     } catch (std::exception& e) {
16662       {
16663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16664       };
16665     } catch (...) {
16666       {
16667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16668       };
16669     }
16670   }
16671 }
16672
16673
16674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16675   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16676   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16677
16678   arg1 = (Dali::SlotObserver *)jarg1;
16679   arg2 = (Dali::CallbackBase *)jarg2;
16680   {
16681     try {
16682       (arg1)->SlotDisconnected(arg2);
16683     } catch (std::out_of_range& e) {
16684       {
16685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16686       };
16687     } catch (std::exception& e) {
16688       {
16689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16690       };
16691     } catch (...) {
16692       {
16693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16694       };
16695     }
16696   }
16697 }
16698
16699
16700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16701   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16702
16703   arg1 = (Dali::ConnectionTracker *)jarg1;
16704   {
16705     try {
16706       delete arg1;
16707     } catch (std::out_of_range& e) {
16708       {
16709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16710       };
16711     } catch (std::exception& e) {
16712       {
16713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16714       };
16715     } catch (...) {
16716       {
16717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16718       };
16719     }
16720   }
16721 }
16722
16723
16724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16725   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16726
16727   arg1 = (Dali::ConnectionTracker *)jarg1;
16728   {
16729     try {
16730       (arg1)->DisconnectAll();
16731     } catch (std::out_of_range& e) {
16732       {
16733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16734       };
16735     } catch (std::exception& e) {
16736       {
16737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16738       };
16739     } catch (...) {
16740       {
16741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16742       };
16743     }
16744   }
16745 }
16746
16747
16748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16749   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16750   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16751   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16752
16753   arg1 = (Dali::ConnectionTracker *)jarg1;
16754   arg2 = (Dali::SlotObserver *)jarg2;
16755   arg3 = (Dali::CallbackBase *)jarg3;
16756   {
16757     try {
16758       (arg1)->SignalConnected(arg2,arg3);
16759     } catch (std::out_of_range& e) {
16760       {
16761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16762       };
16763     } catch (std::exception& e) {
16764       {
16765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16766       };
16767     } catch (...) {
16768       {
16769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16770       };
16771     }
16772   }
16773 }
16774
16775
16776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16777   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16778   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16779   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16780
16781   arg1 = (Dali::ConnectionTracker *)jarg1;
16782   arg2 = (Dali::SlotObserver *)jarg2;
16783   arg3 = (Dali::CallbackBase *)jarg3;
16784   {
16785     try {
16786       (arg1)->SignalDisconnected(arg2,arg3);
16787     } catch (std::out_of_range& e) {
16788       {
16789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16790       };
16791     } catch (std::exception& e) {
16792       {
16793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16794       };
16795     } catch (...) {
16796       {
16797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16798       };
16799     }
16800   }
16801 }
16802
16803
16804 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16805   unsigned long jresult ;
16806   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16807   std::size_t result;
16808
16809   arg1 = (Dali::ConnectionTracker *)jarg1;
16810   {
16811     try {
16812       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16813     } catch (std::out_of_range& e) {
16814       {
16815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16816       };
16817     } catch (std::exception& e) {
16818       {
16819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16820       };
16821     } catch (...) {
16822       {
16823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16824       };
16825     }
16826   }
16827   jresult = (unsigned long)result;
16828   return jresult;
16829 }
16830
16831
16832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16833   void * jresult ;
16834   Dali::ObjectRegistry *result = 0 ;
16835
16836   {
16837     try {
16838       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16839     } catch (std::out_of_range& e) {
16840       {
16841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16842       };
16843     } catch (std::exception& e) {
16844       {
16845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16846       };
16847     } catch (...) {
16848       {
16849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16850       };
16851     }
16852   }
16853   jresult = (void *)result;
16854   return jresult;
16855 }
16856
16857
16858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16859   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16860
16861   arg1 = (Dali::ObjectRegistry *)jarg1;
16862   {
16863     try {
16864       delete arg1;
16865     } catch (std::out_of_range& e) {
16866       {
16867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16868       };
16869     } catch (std::exception& e) {
16870       {
16871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16872       };
16873     } catch (...) {
16874       {
16875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16876       };
16877     }
16878   }
16879 }
16880
16881
16882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16883   void * jresult ;
16884   Dali::ObjectRegistry *arg1 = 0 ;
16885   Dali::ObjectRegistry *result = 0 ;
16886
16887   arg1 = (Dali::ObjectRegistry *)jarg1;
16888   if (!arg1) {
16889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16890     return 0;
16891   }
16892   {
16893     try {
16894       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16895     } catch (std::out_of_range& e) {
16896       {
16897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16898       };
16899     } catch (std::exception& e) {
16900       {
16901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16902       };
16903     } catch (...) {
16904       {
16905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16906       };
16907     }
16908   }
16909   jresult = (void *)result;
16910   return jresult;
16911 }
16912
16913
16914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16915   void * jresult ;
16916   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16917   Dali::ObjectRegistry *arg2 = 0 ;
16918   Dali::ObjectRegistry *result = 0 ;
16919
16920   arg1 = (Dali::ObjectRegistry *)jarg1;
16921   arg2 = (Dali::ObjectRegistry *)jarg2;
16922   if (!arg2) {
16923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16924     return 0;
16925   }
16926   {
16927     try {
16928       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16929     } catch (std::out_of_range& e) {
16930       {
16931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16932       };
16933     } catch (std::exception& e) {
16934       {
16935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16936       };
16937     } catch (...) {
16938       {
16939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16940       };
16941     }
16942   }
16943   jresult = (void *)result;
16944   return jresult;
16945 }
16946
16947
16948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
16949   void * jresult ;
16950   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16951   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
16952
16953   arg1 = (Dali::ObjectRegistry *)jarg1;
16954   {
16955     try {
16956       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
16957     } catch (std::out_of_range& e) {
16958       {
16959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16960       };
16961     } catch (std::exception& e) {
16962       {
16963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16964       };
16965     } catch (...) {
16966       {
16967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16968       };
16969     }
16970   }
16971   jresult = (void *)result;
16972   return jresult;
16973 }
16974
16975
16976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
16977   void * jresult ;
16978   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16979   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
16980
16981   arg1 = (Dali::ObjectRegistry *)jarg1;
16982   {
16983     try {
16984       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
16985     } catch (std::out_of_range& e) {
16986       {
16987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16988       };
16989     } catch (std::exception& e) {
16990       {
16991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16992       };
16993     } catch (...) {
16994       {
16995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16996       };
16997     }
16998   }
16999   jresult = (void *)result;
17000   return jresult;
17001 }
17002
17003
17004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17005   void * jresult ;
17006   Dali::PropertyCondition *result = 0 ;
17007
17008   {
17009     try {
17010       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17011     } catch (std::out_of_range& e) {
17012       {
17013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17014       };
17015     } catch (std::exception& e) {
17016       {
17017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17018       };
17019     } catch (...) {
17020       {
17021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17022       };
17023     }
17024   }
17025   jresult = (void *)result;
17026   return jresult;
17027 }
17028
17029
17030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17031   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17032
17033   arg1 = (Dali::PropertyCondition *)jarg1;
17034   {
17035     try {
17036       delete arg1;
17037     } catch (std::out_of_range& e) {
17038       {
17039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17040       };
17041     } catch (std::exception& e) {
17042       {
17043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17044       };
17045     } catch (...) {
17046       {
17047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17048       };
17049     }
17050   }
17051 }
17052
17053
17054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17055   void * jresult ;
17056   Dali::PropertyCondition *arg1 = 0 ;
17057   Dali::PropertyCondition *result = 0 ;
17058
17059   arg1 = (Dali::PropertyCondition *)jarg1;
17060   if (!arg1) {
17061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17062     return 0;
17063   }
17064   {
17065     try {
17066       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17067     } catch (std::out_of_range& e) {
17068       {
17069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17070       };
17071     } catch (std::exception& e) {
17072       {
17073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17074       };
17075     } catch (...) {
17076       {
17077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17078       };
17079     }
17080   }
17081   jresult = (void *)result;
17082   return jresult;
17083 }
17084
17085
17086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17087   void * jresult ;
17088   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17089   Dali::PropertyCondition *arg2 = 0 ;
17090   Dali::PropertyCondition *result = 0 ;
17091
17092   arg1 = (Dali::PropertyCondition *)jarg1;
17093   arg2 = (Dali::PropertyCondition *)jarg2;
17094   if (!arg2) {
17095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17096     return 0;
17097   }
17098   {
17099     try {
17100       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17101     } catch (std::out_of_range& e) {
17102       {
17103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17104       };
17105     } catch (std::exception& e) {
17106       {
17107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17108       };
17109     } catch (...) {
17110       {
17111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17112       };
17113     }
17114   }
17115   jresult = (void *)result;
17116   return jresult;
17117 }
17118
17119
17120 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17121   unsigned long jresult ;
17122   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17123   std::size_t result;
17124
17125   arg1 = (Dali::PropertyCondition *)jarg1;
17126   {
17127     try {
17128       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17129     } catch (std::out_of_range& e) {
17130       {
17131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17132       };
17133     } catch (std::exception& e) {
17134       {
17135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17136       };
17137     } catch (...) {
17138       {
17139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17140       };
17141     }
17142   }
17143   jresult = (unsigned long)result;
17144   return jresult;
17145 }
17146
17147
17148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17149   float jresult ;
17150   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17151   std::size_t arg2 ;
17152   float result;
17153
17154   arg1 = (Dali::PropertyCondition *)jarg1;
17155   arg2 = (std::size_t)jarg2;
17156   {
17157     try {
17158       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17159     } catch (std::out_of_range& e) {
17160       {
17161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17162       };
17163     } catch (std::exception& e) {
17164       {
17165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17166       };
17167     } catch (...) {
17168       {
17169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17170       };
17171     }
17172   }
17173   jresult = result;
17174   return jresult;
17175 }
17176
17177
17178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17179   void * jresult ;
17180   float arg1 ;
17181   Dali::PropertyCondition result;
17182
17183   arg1 = (float)jarg1;
17184   {
17185     try {
17186       result = Dali::LessThanCondition(arg1);
17187     } catch (std::out_of_range& e) {
17188       {
17189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17190       };
17191     } catch (std::exception& e) {
17192       {
17193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17194       };
17195     } catch (...) {
17196       {
17197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17198       };
17199     }
17200   }
17201   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17202   return jresult;
17203 }
17204
17205
17206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17207   void * jresult ;
17208   float arg1 ;
17209   Dali::PropertyCondition result;
17210
17211   arg1 = (float)jarg1;
17212   {
17213     try {
17214       result = Dali::GreaterThanCondition(arg1);
17215     } catch (std::out_of_range& e) {
17216       {
17217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17218       };
17219     } catch (std::exception& e) {
17220       {
17221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17222       };
17223     } catch (...) {
17224       {
17225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17226       };
17227     }
17228   }
17229   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17230   return jresult;
17231 }
17232
17233
17234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17235   void * jresult ;
17236   float arg1 ;
17237   float arg2 ;
17238   Dali::PropertyCondition result;
17239
17240   arg1 = (float)jarg1;
17241   arg2 = (float)jarg2;
17242   {
17243     try {
17244       result = Dali::InsideCondition(arg1,arg2);
17245     } catch (std::out_of_range& e) {
17246       {
17247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17248       };
17249     } catch (std::exception& e) {
17250       {
17251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17252       };
17253     } catch (...) {
17254       {
17255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17256       };
17257     }
17258   }
17259   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17260   return jresult;
17261 }
17262
17263
17264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17265   void * jresult ;
17266   float arg1 ;
17267   float arg2 ;
17268   Dali::PropertyCondition result;
17269
17270   arg1 = (float)jarg1;
17271   arg2 = (float)jarg2;
17272   {
17273     try {
17274       result = Dali::OutsideCondition(arg1,arg2);
17275     } catch (std::out_of_range& e) {
17276       {
17277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17278       };
17279     } catch (std::exception& e) {
17280       {
17281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17282       };
17283     } catch (...) {
17284       {
17285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17286       };
17287     }
17288   }
17289   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17290   return jresult;
17291 }
17292
17293
17294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17295   void * jresult ;
17296   float arg1 ;
17297   float arg2 ;
17298   Dali::PropertyCondition result;
17299
17300   arg1 = (float)jarg1;
17301   arg2 = (float)jarg2;
17302   {
17303     try {
17304       result = Dali::StepCondition(arg1,arg2);
17305     } catch (std::out_of_range& e) {
17306       {
17307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17308       };
17309     } catch (std::exception& e) {
17310       {
17311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17312       };
17313     } catch (...) {
17314       {
17315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17316       };
17317     }
17318   }
17319   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17320   return jresult;
17321 }
17322
17323
17324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17325   void * jresult ;
17326   float arg1 ;
17327   Dali::PropertyCondition result;
17328
17329   arg1 = (float)jarg1;
17330   {
17331     try {
17332       result = Dali::StepCondition(arg1);
17333     } catch (std::out_of_range& e) {
17334       {
17335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17336       };
17337     } catch (std::exception& e) {
17338       {
17339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17340       };
17341     } catch (...) {
17342       {
17343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17344       };
17345     }
17346   }
17347   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17348   return jresult;
17349 }
17350
17351
17352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17353   void * jresult ;
17354   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17355   Dali::PropertyCondition result;
17356
17357   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17358   if (!arg1) {
17359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17360     return 0;
17361   }
17362   {
17363     try {
17364       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17365     } catch (std::out_of_range& e) {
17366       {
17367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17368       };
17369     } catch (std::exception& e) {
17370       {
17371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17372       };
17373     } catch (...) {
17374       {
17375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17376       };
17377     }
17378   }
17379   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17380   return jresult;
17381 }
17382
17383
17384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17385   void * jresult ;
17386   Dali::PropertyNotification *result = 0 ;
17387
17388   {
17389     try {
17390       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17391     } catch (std::out_of_range& e) {
17392       {
17393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17394       };
17395     } catch (std::exception& e) {
17396       {
17397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17398       };
17399     } catch (...) {
17400       {
17401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17402       };
17403     }
17404   }
17405   jresult = (void *)result;
17406   return jresult;
17407 }
17408
17409
17410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17411   void * jresult ;
17412   Dali::BaseHandle arg1 ;
17413   Dali::BaseHandle *argp1 ;
17414   Dali::PropertyNotification result;
17415
17416   argp1 = (Dali::BaseHandle *)jarg1;
17417   if (!argp1) {
17418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17419     return 0;
17420   }
17421   arg1 = *argp1;
17422   {
17423     try {
17424       result = Dali::PropertyNotification::DownCast(arg1);
17425     } catch (std::out_of_range& e) {
17426       {
17427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17428       };
17429     } catch (std::exception& e) {
17430       {
17431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17432       };
17433     } catch (...) {
17434       {
17435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17436       };
17437     }
17438   }
17439   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17440   return jresult;
17441 }
17442
17443
17444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17445   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17446
17447   arg1 = (Dali::PropertyNotification *)jarg1;
17448   {
17449     try {
17450       delete arg1;
17451     } catch (std::out_of_range& e) {
17452       {
17453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17454       };
17455     } catch (std::exception& e) {
17456       {
17457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17458       };
17459     } catch (...) {
17460       {
17461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17462       };
17463     }
17464   }
17465 }
17466
17467
17468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17469   void * jresult ;
17470   Dali::PropertyNotification *arg1 = 0 ;
17471   Dali::PropertyNotification *result = 0 ;
17472
17473   arg1 = (Dali::PropertyNotification *)jarg1;
17474   if (!arg1) {
17475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17476     return 0;
17477   }
17478   {
17479     try {
17480       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17481     } catch (std::out_of_range& e) {
17482       {
17483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17484       };
17485     } catch (std::exception& e) {
17486       {
17487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17488       };
17489     } catch (...) {
17490       {
17491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17492       };
17493     }
17494   }
17495   jresult = (void *)result;
17496   return jresult;
17497 }
17498
17499
17500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17501   void * jresult ;
17502   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17503   Dali::PropertyNotification *arg2 = 0 ;
17504   Dali::PropertyNotification *result = 0 ;
17505
17506   arg1 = (Dali::PropertyNotification *)jarg1;
17507   arg2 = (Dali::PropertyNotification *)jarg2;
17508   if (!arg2) {
17509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17510     return 0;
17511   }
17512   {
17513     try {
17514       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17515     } catch (std::out_of_range& e) {
17516       {
17517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17518       };
17519     } catch (std::exception& e) {
17520       {
17521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17522       };
17523     } catch (...) {
17524       {
17525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17526       };
17527     }
17528   }
17529   jresult = (void *)result;
17530   return jresult;
17531 }
17532
17533
17534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17535   void * jresult ;
17536   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17537   Dali::PropertyCondition result;
17538
17539   arg1 = (Dali::PropertyNotification *)jarg1;
17540   {
17541     try {
17542       result = (arg1)->GetCondition();
17543     } catch (std::out_of_range& e) {
17544       {
17545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17546       };
17547     } catch (std::exception& e) {
17548       {
17549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17550       };
17551     } catch (...) {
17552       {
17553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17554       };
17555     }
17556   }
17557   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17558   return jresult;
17559 }
17560
17561
17562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17563   void * jresult ;
17564   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17565   Dali::Handle result;
17566
17567   arg1 = (Dali::PropertyNotification *)jarg1;
17568   {
17569     try {
17570       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17571     } catch (std::out_of_range& e) {
17572       {
17573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17574       };
17575     } catch (std::exception& e) {
17576       {
17577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17578       };
17579     } catch (...) {
17580       {
17581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17582       };
17583     }
17584   }
17585   jresult = new Dali::Handle((const Dali::Handle &)result);
17586   return jresult;
17587 }
17588
17589
17590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17591   int jresult ;
17592   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17593   Dali::Property::Index result;
17594
17595   arg1 = (Dali::PropertyNotification *)jarg1;
17596   {
17597     try {
17598       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17599     } catch (std::out_of_range& e) {
17600       {
17601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17602       };
17603     } catch (std::exception& e) {
17604       {
17605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17606       };
17607     } catch (...) {
17608       {
17609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17610       };
17611     }
17612   }
17613   jresult = result;
17614   return jresult;
17615 }
17616
17617
17618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17619   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17620   Dali::PropertyNotification::NotifyMode arg2 ;
17621
17622   arg1 = (Dali::PropertyNotification *)jarg1;
17623   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17624   {
17625     try {
17626       (arg1)->SetNotifyMode(arg2);
17627     } catch (std::out_of_range& e) {
17628       {
17629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17630       };
17631     } catch (std::exception& e) {
17632       {
17633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17634       };
17635     } catch (...) {
17636       {
17637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17638       };
17639     }
17640   }
17641 }
17642
17643
17644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17645   int jresult ;
17646   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17647   Dali::PropertyNotification::NotifyMode result;
17648
17649   arg1 = (Dali::PropertyNotification *)jarg1;
17650   {
17651     try {
17652       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17653     } catch (std::out_of_range& e) {
17654       {
17655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17656       };
17657     } catch (std::exception& e) {
17658       {
17659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17660       };
17661     } catch (...) {
17662       {
17663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17664       };
17665     }
17666   }
17667   jresult = (int)result;
17668   return jresult;
17669 }
17670
17671
17672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17673   unsigned int jresult ;
17674   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17675   bool result;
17676
17677   arg1 = (Dali::PropertyNotification *)jarg1;
17678   {
17679     try {
17680       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17681     } catch (std::out_of_range& e) {
17682       {
17683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17684       };
17685     } catch (std::exception& e) {
17686       {
17687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17688       };
17689     } catch (...) {
17690       {
17691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17692       };
17693     }
17694   }
17695   jresult = result;
17696   return jresult;
17697 }
17698
17699
17700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17701   void * jresult ;
17702   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17703   Dali::PropertyNotifySignalType *result = 0 ;
17704
17705   arg1 = (Dali::PropertyNotification *)jarg1;
17706   {
17707     try {
17708       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17709     } catch (std::out_of_range& e) {
17710       {
17711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17712       };
17713     } catch (std::exception& e) {
17714       {
17715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17716       };
17717     } catch (...) {
17718       {
17719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17720       };
17721     }
17722   }
17723   jresult = (void *)result;
17724   return jresult;
17725 }
17726
17727
17728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17729   void * jresult ;
17730   Dali::Handle *result = 0 ;
17731
17732   {
17733     try {
17734       result = (Dali::Handle *)new Dali::Handle();
17735     } catch (std::out_of_range& e) {
17736       {
17737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17738       };
17739     } catch (std::exception& e) {
17740       {
17741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17742       };
17743     } catch (...) {
17744       {
17745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17746       };
17747     }
17748   }
17749   jresult = (void *)result;
17750   return jresult;
17751 }
17752
17753
17754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17755   void * jresult ;
17756   Dali::Handle result;
17757
17758   {
17759     try {
17760       result = Dali::Handle::New();
17761     } catch (std::out_of_range& e) {
17762       {
17763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17764       };
17765     } catch (std::exception& e) {
17766       {
17767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17768       };
17769     } catch (...) {
17770       {
17771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17772       };
17773     }
17774   }
17775   jresult = new Dali::Handle((const Dali::Handle &)result);
17776   return jresult;
17777 }
17778
17779
17780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17781   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17782
17783   arg1 = (Dali::Handle *)jarg1;
17784   {
17785     try {
17786       delete arg1;
17787     } catch (std::out_of_range& e) {
17788       {
17789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17790       };
17791     } catch (std::exception& e) {
17792       {
17793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17794       };
17795     } catch (...) {
17796       {
17797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17798       };
17799     }
17800   }
17801 }
17802
17803
17804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17805   void * jresult ;
17806   Dali::Handle *arg1 = 0 ;
17807   Dali::Handle *result = 0 ;
17808
17809   arg1 = (Dali::Handle *)jarg1;
17810   if (!arg1) {
17811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17812     return 0;
17813   }
17814   {
17815     try {
17816       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17817     } catch (std::out_of_range& e) {
17818       {
17819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17820       };
17821     } catch (std::exception& e) {
17822       {
17823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17824       };
17825     } catch (...) {
17826       {
17827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17828       };
17829     }
17830   }
17831   jresult = (void *)result;
17832   return jresult;
17833 }
17834
17835
17836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17837   void * jresult ;
17838   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17839   Dali::Handle *arg2 = 0 ;
17840   Dali::Handle *result = 0 ;
17841
17842   arg1 = (Dali::Handle *)jarg1;
17843   arg2 = (Dali::Handle *)jarg2;
17844   if (!arg2) {
17845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17846     return 0;
17847   }
17848   {
17849     try {
17850       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17851     } catch (std::out_of_range& e) {
17852       {
17853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17854       };
17855     } catch (std::exception& e) {
17856       {
17857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17858       };
17859     } catch (...) {
17860       {
17861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17862       };
17863     }
17864   }
17865   jresult = (void *)result;
17866   return jresult;
17867 }
17868
17869
17870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17871   void * jresult ;
17872   Dali::BaseHandle arg1 ;
17873   Dali::BaseHandle *argp1 ;
17874   Dali::Handle result;
17875
17876   argp1 = (Dali::BaseHandle *)jarg1;
17877   if (!argp1) {
17878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17879     return 0;
17880   }
17881   arg1 = *argp1;
17882   {
17883     try {
17884       result = Dali::Handle::DownCast(arg1);
17885     } catch (std::out_of_range& e) {
17886       {
17887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17888       };
17889     } catch (std::exception& e) {
17890       {
17891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17892       };
17893     } catch (...) {
17894       {
17895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17896       };
17897     }
17898   }
17899   jresult = new Dali::Handle((const Dali::Handle &)result);
17900   return jresult;
17901 }
17902
17903
17904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17905   unsigned int jresult ;
17906   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17907   Dali::Handle::Capability arg2 ;
17908   bool result;
17909
17910   arg1 = (Dali::Handle *)jarg1;
17911   arg2 = (Dali::Handle::Capability)jarg2;
17912   {
17913     try {
17914       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17915     } catch (std::out_of_range& e) {
17916       {
17917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17918       };
17919     } catch (std::exception& e) {
17920       {
17921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17922       };
17923     } catch (...) {
17924       {
17925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17926       };
17927     }
17928   }
17929   jresult = result;
17930   return jresult;
17931 }
17932
17933
17934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17935   unsigned int jresult ;
17936   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17937   unsigned int result;
17938
17939   arg1 = (Dali::Handle *)jarg1;
17940   {
17941     try {
17942       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17943     } catch (std::out_of_range& e) {
17944       {
17945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17946       };
17947     } catch (std::exception& e) {
17948       {
17949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17950       };
17951     } catch (...) {
17952       {
17953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17954       };
17955     }
17956   }
17957   jresult = result;
17958   return jresult;
17959 }
17960
17961
17962 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
17963   char * jresult ;
17964   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17965   Dali::Property::Index arg2 ;
17966   std::string result;
17967
17968   arg1 = (Dali::Handle *)jarg1;
17969   arg2 = (Dali::Property::Index)jarg2;
17970   {
17971     try {
17972       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
17973     } catch (std::out_of_range& e) {
17974       {
17975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17976       };
17977     } catch (std::exception& e) {
17978       {
17979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17980       };
17981     } catch (...) {
17982       {
17983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17984       };
17985     }
17986   }
17987   jresult = SWIG_csharp_string_callback((&result)->c_str());
17988   return jresult;
17989 }
17990
17991
17992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
17993   int jresult ;
17994   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17995   std::string *arg2 = 0 ;
17996   Dali::Property::Index result;
17997
17998   arg1 = (Dali::Handle *)jarg1;
17999   if (!jarg2) {
18000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18001     return 0;
18002   }
18003   std::string arg2_str(jarg2);
18004   arg2 = &arg2_str;
18005   {
18006     try {
18007       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*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
18024   //argout typemap for const std::string&
18025
18026   return jresult;
18027 }
18028
18029
18030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18031   unsigned int jresult ;
18032   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18033   Dali::Property::Index arg2 ;
18034   bool result;
18035
18036   arg1 = (Dali::Handle *)jarg1;
18037   arg2 = (Dali::Property::Index)jarg2;
18038   {
18039     try {
18040       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18041     } catch (std::out_of_range& e) {
18042       {
18043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18044       };
18045     } catch (std::exception& e) {
18046       {
18047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18048       };
18049     } catch (...) {
18050       {
18051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18052       };
18053     }
18054   }
18055   jresult = result;
18056   return jresult;
18057 }
18058
18059
18060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18061   unsigned int jresult ;
18062   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18063   Dali::Property::Index arg2 ;
18064   bool result;
18065
18066   arg1 = (Dali::Handle *)jarg1;
18067   arg2 = (Dali::Property::Index)jarg2;
18068   {
18069     try {
18070       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18071     } catch (std::out_of_range& e) {
18072       {
18073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18074       };
18075     } catch (std::exception& e) {
18076       {
18077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18078       };
18079     } catch (...) {
18080       {
18081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18082       };
18083     }
18084   }
18085   jresult = result;
18086   return jresult;
18087 }
18088
18089
18090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18091   unsigned int jresult ;
18092   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18093   Dali::Property::Index arg2 ;
18094   bool result;
18095
18096   arg1 = (Dali::Handle *)jarg1;
18097   arg2 = (Dali::Property::Index)jarg2;
18098   {
18099     try {
18100       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18101     } catch (std::out_of_range& e) {
18102       {
18103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18104       };
18105     } catch (std::exception& e) {
18106       {
18107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18108       };
18109     } catch (...) {
18110       {
18111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18112       };
18113     }
18114   }
18115   jresult = result;
18116   return jresult;
18117 }
18118
18119
18120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18121   int jresult ;
18122   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18123   Dali::Property::Index arg2 ;
18124   Dali::Property::Type result;
18125
18126   arg1 = (Dali::Handle *)jarg1;
18127   arg2 = (Dali::Property::Index)jarg2;
18128   {
18129     try {
18130       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18131     } catch (std::out_of_range& e) {
18132       {
18133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18134       };
18135     } catch (std::exception& e) {
18136       {
18137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18138       };
18139     } catch (...) {
18140       {
18141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18142       };
18143     }
18144   }
18145   jresult = (int)result;
18146   return jresult;
18147 }
18148
18149
18150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18151   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18152   Dali::Property::Index arg2 ;
18153   Dali::Property::Value *arg3 = 0 ;
18154
18155   arg1 = (Dali::Handle *)jarg1;
18156   arg2 = (Dali::Property::Index)jarg2;
18157   arg3 = (Dali::Property::Value *)jarg3;
18158   if (!arg3) {
18159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18160     return ;
18161   }
18162   {
18163     try {
18164       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18165     } catch (std::out_of_range& e) {
18166       {
18167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18168       };
18169     } catch (std::exception& e) {
18170       {
18171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18172       };
18173     } catch (...) {
18174       {
18175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18176       };
18177     }
18178   }
18179 }
18180
18181
18182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18183   int jresult ;
18184   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18185   std::string *arg2 = 0 ;
18186   Dali::Property::Value *arg3 = 0 ;
18187   Dali::Property::Index result;
18188
18189   arg1 = (Dali::Handle *)jarg1;
18190   if (!jarg2) {
18191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18192     return 0;
18193   }
18194   std::string arg2_str(jarg2);
18195   arg2 = &arg2_str;
18196   arg3 = (Dali::Property::Value *)jarg3;
18197   if (!arg3) {
18198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18199     return 0;
18200   }
18201   {
18202     try {
18203       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18204     } catch (std::out_of_range& e) {
18205       {
18206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18207       };
18208     } catch (std::exception& e) {
18209       {
18210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18211       };
18212     } catch (...) {
18213       {
18214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18215       };
18216     }
18217   }
18218   jresult = result;
18219
18220   //argout typemap for const std::string&
18221
18222   return jresult;
18223 }
18224
18225
18226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18227   int jresult ;
18228   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18229   std::string *arg2 = 0 ;
18230   Dali::Property::Value *arg3 = 0 ;
18231   Dali::Property::AccessMode arg4 ;
18232   Dali::Property::Index result;
18233
18234   arg1 = (Dali::Handle *)jarg1;
18235   if (!jarg2) {
18236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18237     return 0;
18238   }
18239   std::string arg2_str(jarg2);
18240   arg2 = &arg2_str;
18241   arg3 = (Dali::Property::Value *)jarg3;
18242   if (!arg3) {
18243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18244     return 0;
18245   }
18246   arg4 = (Dali::Property::AccessMode)jarg4;
18247   {
18248     try {
18249       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
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 = result;
18265
18266   //argout typemap for const std::string&
18267
18268   return jresult;
18269 }
18270
18271
18272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18273   void * jresult ;
18274   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18275   Dali::Property::Index arg2 ;
18276   Dali::Property::Value result;
18277
18278   arg1 = (Dali::Handle *)jarg1;
18279   arg2 = (Dali::Property::Index)jarg2;
18280   {
18281     try {
18282       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18283     } catch (std::out_of_range& e) {
18284       {
18285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18286       };
18287     } catch (std::exception& e) {
18288       {
18289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18290       };
18291     } catch (...) {
18292       {
18293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18294       };
18295     }
18296   }
18297   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18298   return jresult;
18299 }
18300
18301
18302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18303   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18304   Dali::Property::IndexContainer *arg2 = 0 ;
18305
18306   arg1 = (Dali::Handle *)jarg1;
18307   arg2 = (Dali::Property::IndexContainer *)jarg2;
18308   if (!arg2) {
18309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18310     return ;
18311   }
18312   {
18313     try {
18314       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18315     } catch (std::out_of_range& e) {
18316       {
18317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18318       };
18319     } catch (std::exception& e) {
18320       {
18321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18322       };
18323     } catch (...) {
18324       {
18325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18326       };
18327     }
18328   }
18329 }
18330
18331
18332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18333   void * jresult ;
18334   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18335   Dali::Property::Index arg2 ;
18336   Dali::PropertyCondition *arg3 = 0 ;
18337   Dali::PropertyNotification result;
18338
18339   arg1 = (Dali::Handle *)jarg1;
18340   arg2 = (Dali::Property::Index)jarg2;
18341   arg3 = (Dali::PropertyCondition *)jarg3;
18342   if (!arg3) {
18343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18344     return 0;
18345   }
18346   {
18347     try {
18348       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18349     } catch (std::out_of_range& e) {
18350       {
18351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18352       };
18353     } catch (std::exception& e) {
18354       {
18355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18356       };
18357     } catch (...) {
18358       {
18359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18360       };
18361     }
18362   }
18363   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18364   return jresult;
18365 }
18366
18367
18368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18369   void * jresult ;
18370   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18371   Dali::Property::Index arg2 ;
18372   int arg3 ;
18373   Dali::PropertyCondition *arg4 = 0 ;
18374   Dali::PropertyNotification result;
18375
18376   arg1 = (Dali::Handle *)jarg1;
18377   arg2 = (Dali::Property::Index)jarg2;
18378   arg3 = (int)jarg3;
18379   arg4 = (Dali::PropertyCondition *)jarg4;
18380   if (!arg4) {
18381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18382     return 0;
18383   }
18384   {
18385     try {
18386       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18387     } catch (std::out_of_range& e) {
18388       {
18389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18390       };
18391     } catch (std::exception& e) {
18392       {
18393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18394       };
18395     } catch (...) {
18396       {
18397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18398       };
18399     }
18400   }
18401   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18402   return jresult;
18403 }
18404
18405
18406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18407   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18408   Dali::PropertyNotification arg2 ;
18409   Dali::PropertyNotification *argp2 ;
18410
18411   arg1 = (Dali::Handle *)jarg1;
18412   argp2 = (Dali::PropertyNotification *)jarg2;
18413   if (!argp2) {
18414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18415     return ;
18416   }
18417   arg2 = *argp2;
18418   {
18419     try {
18420       (arg1)->RemovePropertyNotification(arg2);
18421     } catch (std::out_of_range& e) {
18422       {
18423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18424       };
18425     } catch (std::exception& e) {
18426       {
18427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18428       };
18429     } catch (...) {
18430       {
18431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18432       };
18433     }
18434   }
18435 }
18436
18437
18438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18439   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18440
18441   arg1 = (Dali::Handle *)jarg1;
18442   {
18443     try {
18444       (arg1)->RemovePropertyNotifications();
18445     } catch (std::out_of_range& e) {
18446       {
18447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18448       };
18449     } catch (std::exception& e) {
18450       {
18451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18452       };
18453     } catch (...) {
18454       {
18455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18456       };
18457     }
18458   }
18459 }
18460
18461
18462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18463   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18464
18465   arg1 = (Dali::Handle *)jarg1;
18466   {
18467     try {
18468       (arg1)->RemoveConstraints();
18469     } catch (std::out_of_range& e) {
18470       {
18471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18472       };
18473     } catch (std::exception& e) {
18474       {
18475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18476       };
18477     } catch (...) {
18478       {
18479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18480       };
18481     }
18482   }
18483 }
18484
18485
18486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18487   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18488   unsigned int arg2 ;
18489
18490   arg1 = (Dali::Handle *)jarg1;
18491   arg2 = (unsigned int)jarg2;
18492   {
18493     try {
18494       (arg1)->RemoveConstraints(arg2);
18495     } catch (std::out_of_range& e) {
18496       {
18497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18498       };
18499     } catch (std::exception& e) {
18500       {
18501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18502       };
18503     } catch (...) {
18504       {
18505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18506       };
18507     }
18508   }
18509 }
18510
18511
18512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18513   int jresult ;
18514   Dali::Property::Index result;
18515
18516   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18517   jresult = result;
18518   return jresult;
18519 }
18520
18521
18522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18523   void * jresult ;
18524   Dali::Handle result;
18525
18526   {
18527     try {
18528       result = Dali::WeightObject::New();
18529     } catch (std::out_of_range& e) {
18530       {
18531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18532       };
18533     } catch (std::exception& e) {
18534       {
18535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18536       };
18537     } catch (...) {
18538       {
18539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18540       };
18541     }
18542   }
18543   jresult = new Dali::Handle((const Dali::Handle &)result);
18544   return jresult;
18545 }
18546
18547
18548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18549   void * jresult ;
18550   Dali::TypeInfo *result = 0 ;
18551
18552   {
18553     try {
18554       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18555     } catch (std::out_of_range& e) {
18556       {
18557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18558       };
18559     } catch (std::exception& e) {
18560       {
18561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18562       };
18563     } catch (...) {
18564       {
18565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18566       };
18567     }
18568   }
18569   jresult = (void *)result;
18570   return jresult;
18571 }
18572
18573
18574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18575   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18576
18577   arg1 = (Dali::TypeInfo *)jarg1;
18578   {
18579     try {
18580       delete arg1;
18581     } catch (std::out_of_range& e) {
18582       {
18583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18584       };
18585     } catch (std::exception& e) {
18586       {
18587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18588       };
18589     } catch (...) {
18590       {
18591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18592       };
18593     }
18594   }
18595 }
18596
18597
18598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18599   void * jresult ;
18600   Dali::TypeInfo *arg1 = 0 ;
18601   Dali::TypeInfo *result = 0 ;
18602
18603   arg1 = (Dali::TypeInfo *)jarg1;
18604   if (!arg1) {
18605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18606     return 0;
18607   }
18608   {
18609     try {
18610       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18611     } catch (std::out_of_range& e) {
18612       {
18613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18614       };
18615     } catch (std::exception& e) {
18616       {
18617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18618       };
18619     } catch (...) {
18620       {
18621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18622       };
18623     }
18624   }
18625   jresult = (void *)result;
18626   return jresult;
18627 }
18628
18629
18630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18631   void * jresult ;
18632   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18633   Dali::TypeInfo *arg2 = 0 ;
18634   Dali::TypeInfo *result = 0 ;
18635
18636   arg1 = (Dali::TypeInfo *)jarg1;
18637   arg2 = (Dali::TypeInfo *)jarg2;
18638   if (!arg2) {
18639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18640     return 0;
18641   }
18642   {
18643     try {
18644       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18645     } catch (std::out_of_range& e) {
18646       {
18647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18648       };
18649     } catch (std::exception& e) {
18650       {
18651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18652       };
18653     } catch (...) {
18654       {
18655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18656       };
18657     }
18658   }
18659   jresult = (void *)result;
18660   return jresult;
18661 }
18662
18663
18664 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18665   char * jresult ;
18666   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18667   std::string *result = 0 ;
18668
18669   arg1 = (Dali::TypeInfo *)jarg1;
18670   {
18671     try {
18672       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18673     } catch (std::out_of_range& e) {
18674       {
18675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18676       };
18677     } catch (std::exception& e) {
18678       {
18679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18680       };
18681     } catch (...) {
18682       {
18683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18684       };
18685     }
18686   }
18687   jresult = SWIG_csharp_string_callback(result->c_str());
18688   return jresult;
18689 }
18690
18691
18692 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18693   char * jresult ;
18694   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18695   std::string *result = 0 ;
18696
18697   arg1 = (Dali::TypeInfo *)jarg1;
18698   {
18699     try {
18700       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18701     } catch (std::out_of_range& e) {
18702       {
18703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18704       };
18705     } catch (std::exception& e) {
18706       {
18707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18708       };
18709     } catch (...) {
18710       {
18711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18712       };
18713     }
18714   }
18715   jresult = SWIG_csharp_string_callback(result->c_str());
18716   return jresult;
18717 }
18718
18719
18720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18721   void * jresult ;
18722   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18723   Dali::BaseHandle result;
18724
18725   arg1 = (Dali::TypeInfo *)jarg1;
18726   {
18727     try {
18728       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18729     } catch (std::out_of_range& e) {
18730       {
18731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18732       };
18733     } catch (std::exception& e) {
18734       {
18735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18736       };
18737     } catch (...) {
18738       {
18739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18740       };
18741     }
18742   }
18743   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18744   return jresult;
18745 }
18746
18747
18748 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18749   unsigned long jresult ;
18750   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18751   size_t result;
18752
18753   arg1 = (Dali::TypeInfo *)jarg1;
18754   {
18755     try {
18756       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18757     } catch (std::out_of_range& e) {
18758       {
18759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18760       };
18761     } catch (std::exception& e) {
18762       {
18763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18764       };
18765     } catch (...) {
18766       {
18767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18768       };
18769     }
18770   }
18771   jresult = (unsigned long)result;
18772   return jresult;
18773 }
18774
18775
18776 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18777   char * jresult ;
18778   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18779   size_t arg2 ;
18780   std::string result;
18781
18782   arg1 = (Dali::TypeInfo *)jarg1;
18783   arg2 = (size_t)jarg2;
18784   {
18785     try {
18786       result = (arg1)->GetActionName(arg2);
18787     } catch (std::out_of_range& e) {
18788       {
18789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18790       };
18791     } catch (std::exception& e) {
18792       {
18793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18794       };
18795     } catch (...) {
18796       {
18797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18798       };
18799     }
18800   }
18801   jresult = SWIG_csharp_string_callback((&result)->c_str());
18802   return jresult;
18803 }
18804
18805
18806 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18807   unsigned long jresult ;
18808   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18809   size_t result;
18810
18811   arg1 = (Dali::TypeInfo *)jarg1;
18812   {
18813     try {
18814       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18815     } catch (std::out_of_range& e) {
18816       {
18817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18818       };
18819     } catch (std::exception& e) {
18820       {
18821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18822       };
18823     } catch (...) {
18824       {
18825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18826       };
18827     }
18828   }
18829   jresult = (unsigned long)result;
18830   return jresult;
18831 }
18832
18833
18834 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18835   char * jresult ;
18836   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18837   size_t arg2 ;
18838   std::string result;
18839
18840   arg1 = (Dali::TypeInfo *)jarg1;
18841   arg2 = (size_t)jarg2;
18842   {
18843     try {
18844       result = (arg1)->GetSignalName(arg2);
18845     } catch (std::out_of_range& e) {
18846       {
18847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18848       };
18849     } catch (std::exception& e) {
18850       {
18851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18852       };
18853     } catch (...) {
18854       {
18855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18856       };
18857     }
18858   }
18859   jresult = SWIG_csharp_string_callback((&result)->c_str());
18860   return jresult;
18861 }
18862
18863
18864 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18865   unsigned long jresult ;
18866   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18867   size_t result;
18868
18869   arg1 = (Dali::TypeInfo *)jarg1;
18870   {
18871     try {
18872       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18873     } catch (std::out_of_range& e) {
18874       {
18875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18876       };
18877     } catch (std::exception& e) {
18878       {
18879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18880       };
18881     } catch (...) {
18882       {
18883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18884       };
18885     }
18886   }
18887   jresult = (unsigned long)result;
18888   return jresult;
18889 }
18890
18891
18892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18893   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18894   Dali::Property::IndexContainer *arg2 = 0 ;
18895
18896   arg1 = (Dali::TypeInfo *)jarg1;
18897   arg2 = (Dali::Property::IndexContainer *)jarg2;
18898   if (!arg2) {
18899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18900     return ;
18901   }
18902   {
18903     try {
18904       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18905     } catch (std::out_of_range& e) {
18906       {
18907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18908       };
18909     } catch (std::exception& e) {
18910       {
18911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18912       };
18913     } catch (...) {
18914       {
18915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18916       };
18917     }
18918   }
18919 }
18920
18921
18922 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18923   char * jresult ;
18924   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18925   Dali::Property::Index arg2 ;
18926   std::string *result = 0 ;
18927
18928   arg1 = (Dali::TypeInfo *)jarg1;
18929   arg2 = (Dali::Property::Index)jarg2;
18930   {
18931     try {
18932       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18933     } catch (std::out_of_range& e) {
18934       {
18935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18936       };
18937     } catch (std::exception& e) {
18938       {
18939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18940       };
18941     } catch (...) {
18942       {
18943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18944       };
18945     }
18946   }
18947   jresult = SWIG_csharp_string_callback(result->c_str());
18948   return jresult;
18949 }
18950
18951
18952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
18953   void * jresult ;
18954   Dali::TypeRegistry result;
18955
18956   {
18957     try {
18958       result = Dali::TypeRegistry::Get();
18959     } catch (std::out_of_range& e) {
18960       {
18961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18962       };
18963     } catch (std::exception& e) {
18964       {
18965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18966       };
18967     } catch (...) {
18968       {
18969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18970       };
18971     }
18972   }
18973   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
18974   return jresult;
18975 }
18976
18977
18978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
18979   void * jresult ;
18980   Dali::TypeRegistry *result = 0 ;
18981
18982   {
18983     try {
18984       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
18985     } catch (std::out_of_range& e) {
18986       {
18987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18988       };
18989     } catch (std::exception& e) {
18990       {
18991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18992       };
18993     } catch (...) {
18994       {
18995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18996       };
18997     }
18998   }
18999   jresult = (void *)result;
19000   return jresult;
19001 }
19002
19003
19004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19005   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19006
19007   arg1 = (Dali::TypeRegistry *)jarg1;
19008   {
19009     try {
19010       delete arg1;
19011     } catch (std::out_of_range& e) {
19012       {
19013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19014       };
19015     } catch (std::exception& e) {
19016       {
19017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19018       };
19019     } catch (...) {
19020       {
19021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19022       };
19023     }
19024   }
19025 }
19026
19027
19028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19029   void * jresult ;
19030   Dali::TypeRegistry *arg1 = 0 ;
19031   Dali::TypeRegistry *result = 0 ;
19032
19033   arg1 = (Dali::TypeRegistry *)jarg1;
19034   if (!arg1) {
19035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19036     return 0;
19037   }
19038   {
19039     try {
19040       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19041     } catch (std::out_of_range& e) {
19042       {
19043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19044       };
19045     } catch (std::exception& e) {
19046       {
19047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19048       };
19049     } catch (...) {
19050       {
19051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19052       };
19053     }
19054   }
19055   jresult = (void *)result;
19056   return jresult;
19057 }
19058
19059
19060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19061   void * jresult ;
19062   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19063   Dali::TypeRegistry *arg2 = 0 ;
19064   Dali::TypeRegistry *result = 0 ;
19065
19066   arg1 = (Dali::TypeRegistry *)jarg1;
19067   arg2 = (Dali::TypeRegistry *)jarg2;
19068   if (!arg2) {
19069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19070     return 0;
19071   }
19072   {
19073     try {
19074       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19075     } catch (std::out_of_range& e) {
19076       {
19077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19078       };
19079     } catch (std::exception& e) {
19080       {
19081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19082       };
19083     } catch (...) {
19084       {
19085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19086       };
19087     }
19088   }
19089   jresult = (void *)result;
19090   return jresult;
19091 }
19092
19093
19094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19095   void * jresult ;
19096   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19097   std::string *arg2 = 0 ;
19098   Dali::TypeInfo result;
19099
19100   arg1 = (Dali::TypeRegistry *)jarg1;
19101   if (!jarg2) {
19102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19103     return 0;
19104   }
19105   std::string arg2_str(jarg2);
19106   arg2 = &arg2_str;
19107   {
19108     try {
19109       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19110     } catch (std::out_of_range& e) {
19111       {
19112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19113       };
19114     } catch (std::exception& e) {
19115       {
19116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19117       };
19118     } catch (...) {
19119       {
19120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19121       };
19122     }
19123   }
19124   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19125
19126   //argout typemap for const std::string&
19127
19128   return jresult;
19129 }
19130
19131
19132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19133   void * jresult ;
19134   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19135   std::type_info *arg2 = 0 ;
19136   Dali::TypeInfo result;
19137
19138   arg1 = (Dali::TypeRegistry *)jarg1;
19139   arg2 = (std::type_info *)jarg2;
19140   if (!arg2) {
19141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19142     return 0;
19143   }
19144   {
19145     try {
19146       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19147     } catch (std::out_of_range& e) {
19148       {
19149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19150       };
19151     } catch (std::exception& e) {
19152       {
19153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19154       };
19155     } catch (...) {
19156       {
19157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19158       };
19159     }
19160   }
19161   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19162   return jresult;
19163 }
19164
19165
19166 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19167   unsigned long jresult ;
19168   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19169   size_t result;
19170
19171   arg1 = (Dali::TypeRegistry *)jarg1;
19172   {
19173     try {
19174       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19175     } catch (std::out_of_range& e) {
19176       {
19177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19178       };
19179     } catch (std::exception& e) {
19180       {
19181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19182       };
19183     } catch (...) {
19184       {
19185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19186       };
19187     }
19188   }
19189   jresult = (unsigned long)result;
19190   return jresult;
19191 }
19192
19193
19194 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19195   char * jresult ;
19196   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19197   size_t arg2 ;
19198   std::string result;
19199
19200   arg1 = (Dali::TypeRegistry *)jarg1;
19201   arg2 = (size_t)jarg2;
19202   {
19203     try {
19204       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19205     } catch (std::out_of_range& e) {
19206       {
19207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19208       };
19209     } catch (std::exception& e) {
19210       {
19211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19212       };
19213     } catch (...) {
19214       {
19215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19216       };
19217     }
19218   }
19219   jresult = SWIG_csharp_string_callback((&result)->c_str());
19220   return jresult;
19221 }
19222
19223
19224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19225   void * jresult ;
19226   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19227   Dali::TypeRegistry *result = 0 ;
19228
19229   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19230   {
19231     try {
19232       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19233     } catch (std::out_of_range& e) {
19234       {
19235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19236       };
19237     } catch (std::exception& e) {
19238       {
19239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19240       };
19241     } catch (...) {
19242       {
19243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19244       };
19245     }
19246   }
19247   jresult = (void *)result;
19248   return jresult;
19249 }
19250
19251
19252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19253   void * jresult ;
19254   std::type_info *arg1 = 0 ;
19255   std::type_info *arg2 = 0 ;
19256   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19257   Dali::TypeRegistration *result = 0 ;
19258
19259   arg1 = (std::type_info *)jarg1;
19260   if (!arg1) {
19261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19262     return 0;
19263   }
19264   arg2 = (std::type_info *)jarg2;
19265   if (!arg2) {
19266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19267     return 0;
19268   }
19269   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19270   {
19271     try {
19272       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19273     } catch (std::out_of_range& e) {
19274       {
19275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19276       };
19277     } catch (std::exception& e) {
19278       {
19279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19280       };
19281     } catch (...) {
19282       {
19283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19284       };
19285     }
19286   }
19287   jresult = (void *)result;
19288   return jresult;
19289 }
19290
19291
19292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19293   void * jresult ;
19294   std::type_info *arg1 = 0 ;
19295   std::type_info *arg2 = 0 ;
19296   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19297   bool arg4 ;
19298   Dali::TypeRegistration *result = 0 ;
19299
19300   arg1 = (std::type_info *)jarg1;
19301   if (!arg1) {
19302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19303     return 0;
19304   }
19305   arg2 = (std::type_info *)jarg2;
19306   if (!arg2) {
19307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19308     return 0;
19309   }
19310   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19311   arg4 = jarg4 ? true : false;
19312   {
19313     try {
19314       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19315     } catch (std::out_of_range& e) {
19316       {
19317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19318       };
19319     } catch (std::exception& e) {
19320       {
19321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19322       };
19323     } catch (...) {
19324       {
19325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19326       };
19327     }
19328   }
19329   jresult = (void *)result;
19330   return jresult;
19331 }
19332
19333
19334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19335   void * jresult ;
19336   std::string *arg1 = 0 ;
19337   std::type_info *arg2 = 0 ;
19338   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19339   Dali::TypeRegistration *result = 0 ;
19340
19341   if (!jarg1) {
19342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19343     return 0;
19344   }
19345   std::string arg1_str(jarg1);
19346   arg1 = &arg1_str;
19347   arg2 = (std::type_info *)jarg2;
19348   if (!arg2) {
19349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19350     return 0;
19351   }
19352   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19353   {
19354     try {
19355       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19356     } catch (std::out_of_range& e) {
19357       {
19358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19359       };
19360     } catch (std::exception& e) {
19361       {
19362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19363       };
19364     } catch (...) {
19365       {
19366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19367       };
19368     }
19369   }
19370   jresult = (void *)result;
19371
19372   //argout typemap for const std::string&
19373
19374   return jresult;
19375 }
19376
19377
19378 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19379   char * jresult ;
19380   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19381   std::string result;
19382
19383   arg1 = (Dali::TypeRegistration *)jarg1;
19384   {
19385     try {
19386       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19387     } catch (std::out_of_range& e) {
19388       {
19389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19390       };
19391     } catch (std::exception& e) {
19392       {
19393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19394       };
19395     } catch (...) {
19396       {
19397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19398       };
19399     }
19400   }
19401   jresult = SWIG_csharp_string_callback((&result)->c_str());
19402   return jresult;
19403 }
19404
19405
19406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19407   std::string *arg1 = 0 ;
19408   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19409
19410   if (!jarg1) {
19411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19412     return ;
19413   }
19414   std::string arg1_str(jarg1);
19415   arg1 = &arg1_str;
19416   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19417   {
19418     try {
19419       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19420     } catch (std::out_of_range& e) {
19421       {
19422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19423       };
19424     } catch (std::exception& e) {
19425       {
19426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19427       };
19428     } catch (...) {
19429       {
19430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19431       };
19432     }
19433   }
19434
19435   //argout typemap for const std::string&
19436
19437 }
19438
19439
19440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19441   std::string *arg1 = 0 ;
19442   std::string *arg2 = 0 ;
19443   int arg3 ;
19444   Dali::Property::Type arg4 ;
19445   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19446   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19447
19448   if (!jarg1) {
19449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19450     return ;
19451   }
19452   std::string arg1_str(jarg1);
19453   arg1 = &arg1_str;
19454   if (!jarg2) {
19455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19456     return ;
19457   }
19458   std::string arg2_str(jarg2);
19459   arg2 = &arg2_str;
19460   arg3 = (int)jarg3;
19461   arg4 = (Dali::Property::Type)jarg4;
19462   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19463   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19464   {
19465     try {
19466       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19467     } catch (std::out_of_range& e) {
19468       {
19469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19470       };
19471     } catch (std::exception& e) {
19472       {
19473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19474       };
19475     } catch (...) {
19476       {
19477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19478       };
19479     }
19480   }
19481
19482   //argout typemap for const std::string&
19483
19484
19485   //argout typemap for const std::string&
19486
19487 }
19488
19489
19490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19491   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19492
19493   arg1 = (Dali::TypeRegistration *)jarg1;
19494   {
19495     try {
19496       delete arg1;
19497     } catch (std::out_of_range& e) {
19498       {
19499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19500       };
19501     } catch (std::exception& e) {
19502       {
19503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19504       };
19505     } catch (...) {
19506       {
19507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19508       };
19509     }
19510   }
19511 }
19512
19513
19514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19515   void * jresult ;
19516   Dali::TypeRegistration *arg1 = 0 ;
19517   std::string *arg2 = 0 ;
19518   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19519   Dali::SignalConnectorType *result = 0 ;
19520
19521   arg1 = (Dali::TypeRegistration *)jarg1;
19522   if (!arg1) {
19523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19524     return 0;
19525   }
19526   if (!jarg2) {
19527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19528     return 0;
19529   }
19530   std::string arg2_str(jarg2);
19531   arg2 = &arg2_str;
19532   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19533   {
19534     try {
19535       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19536     } catch (std::out_of_range& e) {
19537       {
19538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19539       };
19540     } catch (std::exception& e) {
19541       {
19542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19543       };
19544     } catch (...) {
19545       {
19546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19547       };
19548     }
19549   }
19550   jresult = (void *)result;
19551
19552   //argout typemap for const std::string&
19553
19554   return jresult;
19555 }
19556
19557
19558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19559   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19560
19561   arg1 = (Dali::SignalConnectorType *)jarg1;
19562   {
19563     try {
19564       delete arg1;
19565     } catch (std::out_of_range& e) {
19566       {
19567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19568       };
19569     } catch (std::exception& e) {
19570       {
19571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19572       };
19573     } catch (...) {
19574       {
19575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19576       };
19577     }
19578   }
19579 }
19580
19581
19582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19583   void * jresult ;
19584   Dali::TypeRegistration *arg1 = 0 ;
19585   std::string *arg2 = 0 ;
19586   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19587   Dali::TypeAction *result = 0 ;
19588
19589   arg1 = (Dali::TypeRegistration *)jarg1;
19590   if (!arg1) {
19591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19592     return 0;
19593   }
19594   if (!jarg2) {
19595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19596     return 0;
19597   }
19598   std::string arg2_str(jarg2);
19599   arg2 = &arg2_str;
19600   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19601   {
19602     try {
19603       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19604     } catch (std::out_of_range& e) {
19605       {
19606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19607       };
19608     } catch (std::exception& e) {
19609       {
19610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19611       };
19612     } catch (...) {
19613       {
19614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19615       };
19616     }
19617   }
19618   jresult = (void *)result;
19619
19620   //argout typemap for const std::string&
19621
19622   return jresult;
19623 }
19624
19625
19626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19627   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19628
19629   arg1 = (Dali::TypeAction *)jarg1;
19630   {
19631     try {
19632       delete arg1;
19633     } catch (std::out_of_range& e) {
19634       {
19635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19636       };
19637     } catch (std::exception& e) {
19638       {
19639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19640       };
19641     } catch (...) {
19642       {
19643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19644       };
19645     }
19646   }
19647 }
19648
19649
19650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19651   void * jresult ;
19652   Dali::TypeRegistration *arg1 = 0 ;
19653   std::string *arg2 = 0 ;
19654   Dali::Property::Index arg3 ;
19655   Dali::Property::Type arg4 ;
19656   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19657   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19658   Dali::PropertyRegistration *result = 0 ;
19659
19660   arg1 = (Dali::TypeRegistration *)jarg1;
19661   if (!arg1) {
19662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19663     return 0;
19664   }
19665   if (!jarg2) {
19666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19667     return 0;
19668   }
19669   std::string arg2_str(jarg2);
19670   arg2 = &arg2_str;
19671   arg3 = (Dali::Property::Index)jarg3;
19672   arg4 = (Dali::Property::Type)jarg4;
19673   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19674   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19675   {
19676     try {
19677       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19678     } catch (std::out_of_range& e) {
19679       {
19680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19681       };
19682     } catch (std::exception& e) {
19683       {
19684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19685       };
19686     } catch (...) {
19687       {
19688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19689       };
19690     }
19691   }
19692   jresult = (void *)result;
19693
19694   //argout typemap for const std::string&
19695
19696   return jresult;
19697 }
19698
19699
19700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19701   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19702
19703   arg1 = (Dali::PropertyRegistration *)jarg1;
19704   {
19705     try {
19706       delete arg1;
19707     } catch (std::out_of_range& e) {
19708       {
19709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19710       };
19711     } catch (std::exception& e) {
19712       {
19713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19714       };
19715     } catch (...) {
19716       {
19717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19718       };
19719     }
19720   }
19721 }
19722
19723
19724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19725   void * jresult ;
19726   Dali::TypeRegistration *arg1 = 0 ;
19727   std::string *arg2 = 0 ;
19728   Dali::Property::Index arg3 ;
19729   Dali::Property::Type arg4 ;
19730   Dali::AnimatablePropertyRegistration *result = 0 ;
19731
19732   arg1 = (Dali::TypeRegistration *)jarg1;
19733   if (!arg1) {
19734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19735     return 0;
19736   }
19737   if (!jarg2) {
19738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19739     return 0;
19740   }
19741   std::string arg2_str(jarg2);
19742   arg2 = &arg2_str;
19743   arg3 = (Dali::Property::Index)jarg3;
19744   arg4 = (Dali::Property::Type)jarg4;
19745   {
19746     try {
19747       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19748     } catch (std::out_of_range& e) {
19749       {
19750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19751       };
19752     } catch (std::exception& e) {
19753       {
19754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19755       };
19756     } catch (...) {
19757       {
19758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19759       };
19760     }
19761   }
19762   jresult = (void *)result;
19763
19764   //argout typemap for const std::string&
19765
19766   return jresult;
19767 }
19768
19769
19770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19771   void * jresult ;
19772   Dali::TypeRegistration *arg1 = 0 ;
19773   std::string *arg2 = 0 ;
19774   Dali::Property::Index arg3 ;
19775   Dali::Property::Value *arg4 = 0 ;
19776   Dali::AnimatablePropertyRegistration *result = 0 ;
19777
19778   arg1 = (Dali::TypeRegistration *)jarg1;
19779   if (!arg1) {
19780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19781     return 0;
19782   }
19783   if (!jarg2) {
19784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19785     return 0;
19786   }
19787   std::string arg2_str(jarg2);
19788   arg2 = &arg2_str;
19789   arg3 = (Dali::Property::Index)jarg3;
19790   arg4 = (Dali::Property::Value *)jarg4;
19791   if (!arg4) {
19792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19793     return 0;
19794   }
19795   {
19796     try {
19797       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19798     } catch (std::out_of_range& e) {
19799       {
19800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19801       };
19802     } catch (std::exception& e) {
19803       {
19804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19805       };
19806     } catch (...) {
19807       {
19808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19809       };
19810     }
19811   }
19812   jresult = (void *)result;
19813
19814   //argout typemap for const std::string&
19815
19816   return jresult;
19817 }
19818
19819
19820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19821   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19822
19823   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19824   {
19825     try {
19826       delete arg1;
19827     } catch (std::out_of_range& e) {
19828       {
19829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19830       };
19831     } catch (std::exception& e) {
19832       {
19833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19834       };
19835     } catch (...) {
19836       {
19837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19838       };
19839     }
19840   }
19841 }
19842
19843
19844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19845   void * jresult ;
19846   Dali::TypeRegistration *arg1 = 0 ;
19847   std::string *arg2 = 0 ;
19848   Dali::Property::Index arg3 ;
19849   Dali::Property::Index arg4 ;
19850   unsigned int arg5 ;
19851   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19852
19853   arg1 = (Dali::TypeRegistration *)jarg1;
19854   if (!arg1) {
19855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19856     return 0;
19857   }
19858   if (!jarg2) {
19859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19860     return 0;
19861   }
19862   std::string arg2_str(jarg2);
19863   arg2 = &arg2_str;
19864   arg3 = (Dali::Property::Index)jarg3;
19865   arg4 = (Dali::Property::Index)jarg4;
19866   arg5 = (unsigned int)jarg5;
19867   {
19868     try {
19869       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19870     } catch (std::out_of_range& e) {
19871       {
19872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19873       };
19874     } catch (std::exception& e) {
19875       {
19876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19877       };
19878     } catch (...) {
19879       {
19880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19881       };
19882     }
19883   }
19884   jresult = (void *)result;
19885
19886   //argout typemap for const std::string&
19887
19888   return jresult;
19889 }
19890
19891
19892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19893   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19894
19895   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19896   {
19897     try {
19898       delete arg1;
19899     } catch (std::out_of_range& e) {
19900       {
19901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19902       };
19903     } catch (std::exception& e) {
19904       {
19905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19906       };
19907     } catch (...) {
19908       {
19909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19910       };
19911     }
19912   }
19913 }
19914
19915
19916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19917   void * jresult ;
19918   Dali::TypeRegistration *arg1 = 0 ;
19919   std::string *arg2 = 0 ;
19920   Dali::Property::Index arg3 ;
19921   Dali::Property::Type arg4 ;
19922   Dali::ChildPropertyRegistration *result = 0 ;
19923
19924   arg1 = (Dali::TypeRegistration *)jarg1;
19925   if (!arg1) {
19926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19927     return 0;
19928   }
19929   if (!jarg2) {
19930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19931     return 0;
19932   }
19933   std::string arg2_str(jarg2);
19934   arg2 = &arg2_str;
19935   arg3 = (Dali::Property::Index)jarg3;
19936   arg4 = (Dali::Property::Type)jarg4;
19937   {
19938     try {
19939       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19940     } catch (std::out_of_range& e) {
19941       {
19942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19943       };
19944     } catch (std::exception& e) {
19945       {
19946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19947       };
19948     } catch (...) {
19949       {
19950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19951       };
19952     }
19953   }
19954   jresult = (void *)result;
19955
19956   //argout typemap for const std::string&
19957
19958   return jresult;
19959 }
19960
19961
19962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
19963   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
19964
19965   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
19966   {
19967     try {
19968       delete arg1;
19969     } catch (std::out_of_range& e) {
19970       {
19971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19972       };
19973     } catch (std::exception& e) {
19974       {
19975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19976       };
19977     } catch (...) {
19978       {
19979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19980       };
19981     }
19982   }
19983 }
19984
19985
19986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
19987   unsigned int jresult ;
19988   std::string *arg1 = 0 ;
19989   std::type_info *arg2 = 0 ;
19990   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19991   bool result;
19992
19993   if (!jarg1) {
19994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19995     return 0;
19996   }
19997   std::string arg1_str(jarg1);
19998   arg1 = &arg1_str;
19999   arg2 = (std::type_info *)jarg2;
20000   if (!arg2) {
20001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20002     return 0;
20003   }
20004   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20005   {
20006     try {
20007       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20008     } catch (std::out_of_range& e) {
20009       {
20010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20011       };
20012     } catch (std::exception& e) {
20013       {
20014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20015       };
20016     } catch (...) {
20017       {
20018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20019       };
20020     }
20021   }
20022   jresult = result;
20023
20024   //argout typemap for const std::string&
20025
20026   return jresult;
20027 }
20028
20029
20030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20031   unsigned int jresult ;
20032   std::string *arg1 = 0 ;
20033   std::string *arg2 = 0 ;
20034   Dali::Property::Index arg3 ;
20035   Dali::Property::Type arg4 ;
20036   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20037   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20038   bool result;
20039
20040   if (!jarg1) {
20041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20042     return 0;
20043   }
20044   std::string arg1_str(jarg1);
20045   arg1 = &arg1_str;
20046   if (!jarg2) {
20047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20048     return 0;
20049   }
20050   std::string arg2_str(jarg2);
20051   arg2 = &arg2_str;
20052   arg3 = (Dali::Property::Index)jarg3;
20053   arg4 = (Dali::Property::Type)jarg4;
20054   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20055   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20056   {
20057     try {
20058       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20059     } catch (std::out_of_range& e) {
20060       {
20061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20062       };
20063     } catch (std::exception& e) {
20064       {
20065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20066       };
20067     } catch (...) {
20068       {
20069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20070       };
20071     }
20072   }
20073   jresult = result;
20074
20075   //argout typemap for const std::string&
20076
20077
20078   //argout typemap for const std::string&
20079
20080   return jresult;
20081 }
20082
20083
20084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20085   float jresult ;
20086   float result;
20087
20088   result = (float)(float)Dali::ParentOrigin::TOP;
20089   jresult = result;
20090   return jresult;
20091 }
20092
20093
20094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20095   float jresult ;
20096   float result;
20097
20098   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20099   jresult = result;
20100   return jresult;
20101 }
20102
20103
20104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20105   float jresult ;
20106   float result;
20107
20108   result = (float)(float)Dali::ParentOrigin::LEFT;
20109   jresult = result;
20110   return jresult;
20111 }
20112
20113
20114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20115   float jresult ;
20116   float result;
20117
20118   result = (float)(float)Dali::ParentOrigin::RIGHT;
20119   jresult = result;
20120   return jresult;
20121 }
20122
20123
20124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20125   float jresult ;
20126   float result;
20127
20128   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20129   jresult = result;
20130   return jresult;
20131 }
20132
20133
20134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20135   void * jresult ;
20136   Dali::Vector3 *result = 0 ;
20137
20138   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20139   jresult = (void *)result;
20140   return jresult;
20141 }
20142
20143
20144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20145   void * jresult ;
20146   Dali::Vector3 *result = 0 ;
20147
20148   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20149   jresult = (void *)result;
20150   return jresult;
20151 }
20152
20153
20154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20155   void * jresult ;
20156   Dali::Vector3 *result = 0 ;
20157
20158   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20159   jresult = (void *)result;
20160   return jresult;
20161 }
20162
20163
20164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20165   void * jresult ;
20166   Dali::Vector3 *result = 0 ;
20167
20168   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20169   jresult = (void *)result;
20170   return jresult;
20171 }
20172
20173
20174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20175   void * jresult ;
20176   Dali::Vector3 *result = 0 ;
20177
20178   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20179   jresult = (void *)result;
20180   return jresult;
20181 }
20182
20183
20184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20185   void * jresult ;
20186   Dali::Vector3 *result = 0 ;
20187
20188   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20189   jresult = (void *)result;
20190   return jresult;
20191 }
20192
20193
20194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20195   void * jresult ;
20196   Dali::Vector3 *result = 0 ;
20197
20198   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20199   jresult = (void *)result;
20200   return jresult;
20201 }
20202
20203
20204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20205   void * jresult ;
20206   Dali::Vector3 *result = 0 ;
20207
20208   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20209   jresult = (void *)result;
20210   return jresult;
20211 }
20212
20213
20214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20215   void * jresult ;
20216   Dali::Vector3 *result = 0 ;
20217
20218   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20219   jresult = (void *)result;
20220   return jresult;
20221 }
20222
20223
20224 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20225   float jresult ;
20226   float result;
20227
20228   result = (float)(float)Dali::AnchorPoint::TOP;
20229   jresult = result;
20230   return jresult;
20231 }
20232
20233
20234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20235   float jresult ;
20236   float result;
20237
20238   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20239   jresult = result;
20240   return jresult;
20241 }
20242
20243
20244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20245   float jresult ;
20246   float result;
20247
20248   result = (float)(float)Dali::AnchorPoint::LEFT;
20249   jresult = result;
20250   return jresult;
20251 }
20252
20253
20254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20255   float jresult ;
20256   float result;
20257
20258   result = (float)(float)Dali::AnchorPoint::RIGHT;
20259   jresult = result;
20260   return jresult;
20261 }
20262
20263
20264 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20265   float jresult ;
20266   float result;
20267
20268   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20269   jresult = result;
20270   return jresult;
20271 }
20272
20273
20274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20275   void * jresult ;
20276   Dali::Vector3 *result = 0 ;
20277
20278   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20279   jresult = (void *)result;
20280   return jresult;
20281 }
20282
20283
20284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20285   void * jresult ;
20286   Dali::Vector3 *result = 0 ;
20287
20288   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20289   jresult = (void *)result;
20290   return jresult;
20291 }
20292
20293
20294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20295   void * jresult ;
20296   Dali::Vector3 *result = 0 ;
20297
20298   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20299   jresult = (void *)result;
20300   return jresult;
20301 }
20302
20303
20304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20305   void * jresult ;
20306   Dali::Vector3 *result = 0 ;
20307
20308   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20309   jresult = (void *)result;
20310   return jresult;
20311 }
20312
20313
20314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20315   void * jresult ;
20316   Dali::Vector3 *result = 0 ;
20317
20318   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20319   jresult = (void *)result;
20320   return jresult;
20321 }
20322
20323
20324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20325   void * jresult ;
20326   Dali::Vector3 *result = 0 ;
20327
20328   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20329   jresult = (void *)result;
20330   return jresult;
20331 }
20332
20333
20334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20335   void * jresult ;
20336   Dali::Vector3 *result = 0 ;
20337
20338   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20339   jresult = (void *)result;
20340   return jresult;
20341 }
20342
20343
20344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20345   void * jresult ;
20346   Dali::Vector3 *result = 0 ;
20347
20348   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20349   jresult = (void *)result;
20350   return jresult;
20351 }
20352
20353
20354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20355   void * jresult ;
20356   Dali::Vector3 *result = 0 ;
20357
20358   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20359   jresult = (void *)result;
20360   return jresult;
20361 }
20362
20363
20364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20365   void * jresult ;
20366   Dali::Vector4 *result = 0 ;
20367
20368   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20369   jresult = (void *)result;
20370   return jresult;
20371 }
20372
20373
20374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20375   void * jresult ;
20376   Dali::Vector4 *result = 0 ;
20377
20378   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20379   jresult = (void *)result;
20380   return jresult;
20381 }
20382
20383
20384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20385   void * jresult ;
20386   Dali::Vector4 *result = 0 ;
20387
20388   result = (Dali::Vector4 *)&Dali::Color::RED;
20389   jresult = (void *)result;
20390   return jresult;
20391 }
20392
20393
20394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20395   void * jresult ;
20396   Dali::Vector4 *result = 0 ;
20397
20398   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20399   jresult = (void *)result;
20400   return jresult;
20401 }
20402
20403
20404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20405   void * jresult ;
20406   Dali::Vector4 *result = 0 ;
20407
20408   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20409   jresult = (void *)result;
20410   return jresult;
20411 }
20412
20413
20414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20415   void * jresult ;
20416   Dali::Vector4 *result = 0 ;
20417
20418   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20419   jresult = (void *)result;
20420   return jresult;
20421 }
20422
20423
20424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20425   void * jresult ;
20426   Dali::Vector4 *result = 0 ;
20427
20428   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20429   jresult = (void *)result;
20430   return jresult;
20431 }
20432
20433
20434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20435   void * jresult ;
20436   Dali::Vector4 *result = 0 ;
20437
20438   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20439   jresult = (void *)result;
20440   return jresult;
20441 }
20442
20443
20444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20445   void * jresult ;
20446   Dali::Vector4 *result = 0 ;
20447
20448   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20449   jresult = (void *)result;
20450   return jresult;
20451 }
20452
20453
20454 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20455   float jresult ;
20456   float result;
20457
20458   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20459   jresult = result;
20460   return jresult;
20461 }
20462
20463
20464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20465   float jresult ;
20466   float result;
20467
20468   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20469   jresult = result;
20470   return jresult;
20471 }
20472
20473
20474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20475   float jresult ;
20476   float result;
20477
20478   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20479   jresult = result;
20480   return jresult;
20481 }
20482
20483
20484 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20485   float jresult ;
20486   float result;
20487
20488   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20489   jresult = result;
20490   return jresult;
20491 }
20492
20493
20494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20495   float jresult ;
20496   float result;
20497
20498   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20499   jresult = result;
20500   return jresult;
20501 }
20502
20503
20504 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20505   float jresult ;
20506   float result;
20507
20508   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20509   jresult = result;
20510   return jresult;
20511 }
20512
20513
20514 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20515   float jresult ;
20516   float result;
20517
20518   result = (float)(float)Dali::Math::PI;
20519   jresult = result;
20520   return jresult;
20521 }
20522
20523
20524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20525   float jresult ;
20526   float result;
20527
20528   result = (float)(float)Dali::Math::PI_2;
20529   jresult = result;
20530   return jresult;
20531 }
20532
20533
20534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20535   float jresult ;
20536   float result;
20537
20538   result = (float)(float)Dali::Math::PI_4;
20539   jresult = result;
20540   return jresult;
20541 }
20542
20543
20544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20545   float jresult ;
20546   float result;
20547
20548   result = (float)(float)Dali::Math::PI_OVER_180;
20549   jresult = result;
20550   return jresult;
20551 }
20552
20553
20554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20555   float jresult ;
20556   float result;
20557
20558   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20559   jresult = result;
20560   return jresult;
20561 }
20562
20563
20564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20565   int jresult ;
20566   Dali::ResizePolicy::Type result;
20567
20568   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20569   jresult = (int)result;
20570   return jresult;
20571 }
20572
20573
20574 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20575   unsigned long jresult ;
20576   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20577   Dali::VectorBase::SizeType result;
20578
20579   arg1 = (Dali::VectorBase *)jarg1;
20580   {
20581     try {
20582       result = ((Dali::VectorBase const *)arg1)->Count();
20583     } catch (std::out_of_range& e) {
20584       {
20585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20586       };
20587     } catch (std::exception& e) {
20588       {
20589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20590       };
20591     } catch (...) {
20592       {
20593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20594       };
20595     }
20596   }
20597   jresult = (unsigned long)result;
20598   return jresult;
20599 }
20600
20601
20602 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20603   unsigned long jresult ;
20604   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20605   Dali::VectorBase::SizeType result;
20606
20607   arg1 = (Dali::VectorBase *)jarg1;
20608   {
20609     try {
20610       result = ((Dali::VectorBase const *)arg1)->Size();
20611     } catch (std::out_of_range& e) {
20612       {
20613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20614       };
20615     } catch (std::exception& e) {
20616       {
20617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20618       };
20619     } catch (...) {
20620       {
20621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20622       };
20623     }
20624   }
20625   jresult = (unsigned long)result;
20626   return jresult;
20627 }
20628
20629
20630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20631   unsigned int jresult ;
20632   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20633   bool result;
20634
20635   arg1 = (Dali::VectorBase *)jarg1;
20636   {
20637     try {
20638       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20639     } catch (std::out_of_range& e) {
20640       {
20641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20642       };
20643     } catch (std::exception& e) {
20644       {
20645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20646       };
20647     } catch (...) {
20648       {
20649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20650       };
20651     }
20652   }
20653   jresult = result;
20654   return jresult;
20655 }
20656
20657
20658 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20659   unsigned long jresult ;
20660   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20661   Dali::VectorBase::SizeType result;
20662
20663   arg1 = (Dali::VectorBase *)jarg1;
20664   {
20665     try {
20666       result = ((Dali::VectorBase const *)arg1)->Capacity();
20667     } catch (std::out_of_range& e) {
20668       {
20669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20670       };
20671     } catch (std::exception& e) {
20672       {
20673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20674       };
20675     } catch (...) {
20676       {
20677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20678       };
20679     }
20680   }
20681   jresult = (unsigned long)result;
20682   return jresult;
20683 }
20684
20685
20686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20687   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20688
20689   arg1 = (Dali::VectorBase *)jarg1;
20690   {
20691     try {
20692       (arg1)->Release();
20693     } catch (std::out_of_range& e) {
20694       {
20695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20696       };
20697     } catch (std::exception& e) {
20698       {
20699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20700       };
20701     } catch (...) {
20702       {
20703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20704       };
20705     }
20706   }
20707 }
20708
20709
20710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20711   void * jresult ;
20712   Dali::Image *result = 0 ;
20713
20714   {
20715     try {
20716       result = (Dali::Image *)new Dali::Image();
20717     } catch (std::out_of_range& e) {
20718       {
20719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20720       };
20721     } catch (std::exception& e) {
20722       {
20723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20724       };
20725     } catch (...) {
20726       {
20727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20728       };
20729     }
20730   }
20731   jresult = (void *)result;
20732   return jresult;
20733 }
20734
20735
20736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20737   Dali::Image *arg1 = (Dali::Image *) 0 ;
20738
20739   arg1 = (Dali::Image *)jarg1;
20740   {
20741     try {
20742       delete arg1;
20743     } catch (std::out_of_range& e) {
20744       {
20745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20746       };
20747     } catch (std::exception& e) {
20748       {
20749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20750       };
20751     } catch (...) {
20752       {
20753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20754       };
20755     }
20756   }
20757 }
20758
20759
20760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20761   void * jresult ;
20762   Dali::Image *arg1 = 0 ;
20763   Dali::Image *result = 0 ;
20764
20765   arg1 = (Dali::Image *)jarg1;
20766   if (!arg1) {
20767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20768     return 0;
20769   }
20770   {
20771     try {
20772       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20773     } catch (std::out_of_range& e) {
20774       {
20775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20776       };
20777     } catch (std::exception& e) {
20778       {
20779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20780       };
20781     } catch (...) {
20782       {
20783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20784       };
20785     }
20786   }
20787   jresult = (void *)result;
20788   return jresult;
20789 }
20790
20791
20792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20793   void * jresult ;
20794   Dali::Image *arg1 = (Dali::Image *) 0 ;
20795   Dali::Image *arg2 = 0 ;
20796   Dali::Image *result = 0 ;
20797
20798   arg1 = (Dali::Image *)jarg1;
20799   arg2 = (Dali::Image *)jarg2;
20800   if (!arg2) {
20801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20802     return 0;
20803   }
20804   {
20805     try {
20806       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20807     } catch (std::out_of_range& e) {
20808       {
20809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20810       };
20811     } catch (std::exception& e) {
20812       {
20813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20814       };
20815     } catch (...) {
20816       {
20817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20818       };
20819     }
20820   }
20821   jresult = (void *)result;
20822   return jresult;
20823 }
20824
20825
20826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20827   void * jresult ;
20828   Dali::BaseHandle arg1 ;
20829   Dali::BaseHandle *argp1 ;
20830   Dali::Image result;
20831
20832   argp1 = (Dali::BaseHandle *)jarg1;
20833   if (!argp1) {
20834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20835     return 0;
20836   }
20837   arg1 = *argp1;
20838   {
20839     try {
20840       result = Dali::Image::DownCast(arg1);
20841     } catch (std::out_of_range& e) {
20842       {
20843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20844       };
20845     } catch (std::exception& e) {
20846       {
20847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20848       };
20849     } catch (...) {
20850       {
20851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20852       };
20853     }
20854   }
20855   jresult = new Dali::Image((const Dali::Image &)result);
20856   return jresult;
20857 }
20858
20859
20860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20861   unsigned int jresult ;
20862   Dali::Image *arg1 = (Dali::Image *) 0 ;
20863   unsigned int result;
20864
20865   arg1 = (Dali::Image *)jarg1;
20866   {
20867     try {
20868       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20869     } catch (std::out_of_range& e) {
20870       {
20871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20872       };
20873     } catch (std::exception& e) {
20874       {
20875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20876       };
20877     } catch (...) {
20878       {
20879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20880       };
20881     }
20882   }
20883   jresult = result;
20884   return jresult;
20885 }
20886
20887
20888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20889   unsigned int jresult ;
20890   Dali::Image *arg1 = (Dali::Image *) 0 ;
20891   unsigned int result;
20892
20893   arg1 = (Dali::Image *)jarg1;
20894   {
20895     try {
20896       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20897     } catch (std::out_of_range& e) {
20898       {
20899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20900       };
20901     } catch (std::exception& e) {
20902       {
20903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20904       };
20905     } catch (...) {
20906       {
20907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20908       };
20909     }
20910   }
20911   jresult = result;
20912   return jresult;
20913 }
20914
20915
20916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20917   void * jresult ;
20918   Dali::Image *arg1 = (Dali::Image *) 0 ;
20919   Dali::Image::ImageSignalType *result = 0 ;
20920
20921   arg1 = (Dali::Image *)jarg1;
20922   {
20923     try {
20924       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20925     } catch (std::out_of_range& e) {
20926       {
20927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20928       };
20929     } catch (std::exception& e) {
20930       {
20931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20932       };
20933     } catch (...) {
20934       {
20935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20936       };
20937     }
20938   }
20939   jresult = (void *)result;
20940   return jresult;
20941 }
20942
20943
20944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
20945   int jresult ;
20946   Dali::Pixel::Format result;
20947
20948   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20949   jresult = (int)result;
20950   return jresult;
20951 }
20952
20953
20954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
20955   int jresult ;
20956   Dali::Pixel::Format result;
20957
20958   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
20959   jresult = (int)result;
20960   return jresult;
20961 }
20962
20963
20964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
20965   unsigned int jresult ;
20966   Dali::Pixel::Format arg1 ;
20967   bool result;
20968
20969   arg1 = (Dali::Pixel::Format)jarg1;
20970   {
20971     try {
20972       result = (bool)Dali::Pixel::HasAlpha(arg1);
20973     } catch (std::out_of_range& e) {
20974       {
20975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20976       };
20977     } catch (std::exception& e) {
20978       {
20979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20980       };
20981     } catch (...) {
20982       {
20983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20984       };
20985     }
20986   }
20987   jresult = result;
20988   return jresult;
20989 }
20990
20991
20992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
20993   unsigned int jresult ;
20994   Dali::Pixel::Format arg1 ;
20995   unsigned int result;
20996
20997   arg1 = (Dali::Pixel::Format)jarg1;
20998   {
20999     try {
21000       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21001     } catch (std::out_of_range& e) {
21002       {
21003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21004       };
21005     } catch (std::exception& e) {
21006       {
21007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21008       };
21009     } catch (...) {
21010       {
21011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21012       };
21013     }
21014   }
21015   jresult = result;
21016   return jresult;
21017 }
21018
21019
21020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21021   Dali::Pixel::Format arg1 ;
21022   int *arg2 = 0 ;
21023   int *arg3 = 0 ;
21024
21025   arg1 = (Dali::Pixel::Format)jarg1;
21026   arg2 = (int *)jarg2;
21027   if (!arg2) {
21028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21029     return ;
21030   }
21031   arg3 = (int *)jarg3;
21032   if (!arg3) {
21033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21034     return ;
21035   }
21036   {
21037     try {
21038       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21039     } catch (std::out_of_range& e) {
21040       {
21041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21042       };
21043     } catch (std::exception& e) {
21044       {
21045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21046       };
21047     } catch (...) {
21048       {
21049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21050       };
21051     }
21052   }
21053 }
21054
21055
21056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21057   void * jresult ;
21058   unsigned char *arg1 = (unsigned char *) 0 ;
21059   unsigned int arg2 ;
21060   unsigned int arg3 ;
21061   unsigned int arg4 ;
21062   Dali::Pixel::Format arg5 ;
21063   Dali::PixelData::ReleaseFunction arg6 ;
21064   Dali::PixelData result;
21065
21066   arg1 = jarg1;
21067   arg2 = (unsigned int)jarg2;
21068   arg3 = (unsigned int)jarg3;
21069   arg4 = (unsigned int)jarg4;
21070   arg5 = (Dali::Pixel::Format)jarg5;
21071   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21072   {
21073     try {
21074       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21075     } catch (std::out_of_range& e) {
21076       {
21077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21078       };
21079     } catch (std::exception& e) {
21080       {
21081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21082       };
21083     } catch (...) {
21084       {
21085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21086       };
21087     }
21088   }
21089   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21090
21091
21092   return jresult;
21093 }
21094
21095
21096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21097   void * jresult ;
21098   Dali::PixelData *result = 0 ;
21099
21100   {
21101     try {
21102       result = (Dali::PixelData *)new Dali::PixelData();
21103     } catch (std::out_of_range& e) {
21104       {
21105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21106       };
21107     } catch (std::exception& e) {
21108       {
21109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21110       };
21111     } catch (...) {
21112       {
21113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21114       };
21115     }
21116   }
21117   jresult = (void *)result;
21118   return jresult;
21119 }
21120
21121
21122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21123   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21124
21125   arg1 = (Dali::PixelData *)jarg1;
21126   {
21127     try {
21128       delete arg1;
21129     } catch (std::out_of_range& e) {
21130       {
21131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21132       };
21133     } catch (std::exception& e) {
21134       {
21135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21136       };
21137     } catch (...) {
21138       {
21139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21140       };
21141     }
21142   }
21143 }
21144
21145
21146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21147   void * jresult ;
21148   Dali::PixelData *arg1 = 0 ;
21149   Dali::PixelData *result = 0 ;
21150
21151   arg1 = (Dali::PixelData *)jarg1;
21152   if (!arg1) {
21153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21154     return 0;
21155   }
21156   {
21157     try {
21158       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21159     } catch (std::out_of_range& e) {
21160       {
21161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21162       };
21163     } catch (std::exception& e) {
21164       {
21165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21166       };
21167     } catch (...) {
21168       {
21169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21170       };
21171     }
21172   }
21173   jresult = (void *)result;
21174   return jresult;
21175 }
21176
21177
21178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21179   void * jresult ;
21180   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21181   Dali::PixelData *arg2 = 0 ;
21182   Dali::PixelData *result = 0 ;
21183
21184   arg1 = (Dali::PixelData *)jarg1;
21185   arg2 = (Dali::PixelData *)jarg2;
21186   if (!arg2) {
21187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21188     return 0;
21189   }
21190   {
21191     try {
21192       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21193     } catch (std::out_of_range& e) {
21194       {
21195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21196       };
21197     } catch (std::exception& e) {
21198       {
21199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21200       };
21201     } catch (...) {
21202       {
21203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21204       };
21205     }
21206   }
21207   jresult = (void *)result;
21208   return jresult;
21209 }
21210
21211
21212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21213   unsigned int jresult ;
21214   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21215   unsigned int result;
21216
21217   arg1 = (Dali::PixelData *)jarg1;
21218   {
21219     try {
21220       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21221     } catch (std::out_of_range& e) {
21222       {
21223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21224       };
21225     } catch (std::exception& e) {
21226       {
21227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21228       };
21229     } catch (...) {
21230       {
21231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21232       };
21233     }
21234   }
21235   jresult = result;
21236   return jresult;
21237 }
21238
21239
21240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21241   unsigned int jresult ;
21242   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21243   unsigned int result;
21244
21245   arg1 = (Dali::PixelData *)jarg1;
21246   {
21247     try {
21248       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21249     } catch (std::out_of_range& e) {
21250       {
21251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21252       };
21253     } catch (std::exception& e) {
21254       {
21255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21256       };
21257     } catch (...) {
21258       {
21259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21260       };
21261     }
21262   }
21263   jresult = result;
21264   return jresult;
21265 }
21266
21267
21268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21269   int jresult ;
21270   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21271   Dali::Pixel::Format result;
21272
21273   arg1 = (Dali::PixelData *)jarg1;
21274   {
21275     try {
21276       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21277     } catch (std::out_of_range& e) {
21278       {
21279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21280       };
21281     } catch (std::exception& e) {
21282       {
21283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21284       };
21285     } catch (...) {
21286       {
21287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21288       };
21289     }
21290   }
21291   jresult = (int)result;
21292   return jresult;
21293 }
21294
21295
21296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21297   unsigned int jresult ;
21298   unsigned int result;
21299
21300   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21301   jresult = result;
21302   return jresult;
21303 }
21304
21305
21306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21307   unsigned int jresult ;
21308   unsigned int result;
21309
21310   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21311   jresult = result;
21312   return jresult;
21313 }
21314
21315
21316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21317   unsigned int jresult ;
21318   unsigned int result;
21319
21320   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21321   jresult = result;
21322   return jresult;
21323 }
21324
21325
21326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21327   unsigned int jresult ;
21328   unsigned int result;
21329
21330   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21331   jresult = result;
21332   return jresult;
21333 }
21334
21335
21336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21337   unsigned int jresult ;
21338   unsigned int result;
21339
21340   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21341   jresult = result;
21342   return jresult;
21343 }
21344
21345
21346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21347   unsigned int jresult ;
21348   unsigned int result;
21349
21350   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21351   jresult = result;
21352   return jresult;
21353 }
21354
21355
21356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21357   void * jresult ;
21358   Dali::TextureType::Type arg1 ;
21359   Dali::Pixel::Format arg2 ;
21360   unsigned int arg3 ;
21361   unsigned int arg4 ;
21362   Dali::Texture result;
21363
21364   arg1 = (Dali::TextureType::Type)jarg1;
21365   arg2 = (Dali::Pixel::Format)jarg2;
21366   arg3 = (unsigned int)jarg3;
21367   arg4 = (unsigned int)jarg4;
21368   {
21369     try {
21370       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21371     } catch (std::out_of_range& e) {
21372       {
21373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21374       };
21375     } catch (std::exception& e) {
21376       {
21377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21378       };
21379     } catch (...) {
21380       {
21381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21382       };
21383     }
21384   }
21385   jresult = new Dali::Texture((const Dali::Texture &)result);
21386   return jresult;
21387 }
21388
21389
21390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21391   void * jresult ;
21392   NativeImageInterface *arg1 = 0 ;
21393   Dali::Texture result;
21394
21395   arg1 = (NativeImageInterface *)jarg1;
21396   if (!arg1) {
21397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21398     return 0;
21399   }
21400   {
21401     try {
21402       result = Dali::Texture::New(*arg1);
21403     } catch (std::out_of_range& e) {
21404       {
21405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21406       };
21407     } catch (std::exception& e) {
21408       {
21409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21410       };
21411     } catch (...) {
21412       {
21413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21414       };
21415     }
21416   }
21417   jresult = new Dali::Texture((const Dali::Texture &)result);
21418   return jresult;
21419 }
21420
21421
21422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21423   void * jresult ;
21424   Dali::Texture *result = 0 ;
21425
21426   {
21427     try {
21428       result = (Dali::Texture *)new Dali::Texture();
21429     } catch (std::out_of_range& e) {
21430       {
21431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21432       };
21433     } catch (std::exception& e) {
21434       {
21435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21436       };
21437     } catch (...) {
21438       {
21439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21440       };
21441     }
21442   }
21443   jresult = (void *)result;
21444   return jresult;
21445 }
21446
21447
21448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21449   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21450
21451   arg1 = (Dali::Texture *)jarg1;
21452   {
21453     try {
21454       delete arg1;
21455     } catch (std::out_of_range& e) {
21456       {
21457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21458       };
21459     } catch (std::exception& e) {
21460       {
21461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21462       };
21463     } catch (...) {
21464       {
21465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21466       };
21467     }
21468   }
21469 }
21470
21471
21472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21473   void * jresult ;
21474   Dali::Texture *arg1 = 0 ;
21475   Dali::Texture *result = 0 ;
21476
21477   arg1 = (Dali::Texture *)jarg1;
21478   if (!arg1) {
21479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21480     return 0;
21481   }
21482   {
21483     try {
21484       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21485     } catch (std::out_of_range& e) {
21486       {
21487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21488       };
21489     } catch (std::exception& e) {
21490       {
21491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21492       };
21493     } catch (...) {
21494       {
21495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21496       };
21497     }
21498   }
21499   jresult = (void *)result;
21500   return jresult;
21501 }
21502
21503
21504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21505   void * jresult ;
21506   Dali::BaseHandle arg1 ;
21507   Dali::BaseHandle *argp1 ;
21508   Dali::Texture result;
21509
21510   argp1 = (Dali::BaseHandle *)jarg1;
21511   if (!argp1) {
21512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21513     return 0;
21514   }
21515   arg1 = *argp1;
21516   {
21517     try {
21518       result = Dali::Texture::DownCast(arg1);
21519     } catch (std::out_of_range& e) {
21520       {
21521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21522       };
21523     } catch (std::exception& e) {
21524       {
21525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21526       };
21527     } catch (...) {
21528       {
21529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21530       };
21531     }
21532   }
21533   jresult = new Dali::Texture((const Dali::Texture &)result);
21534   return jresult;
21535 }
21536
21537
21538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21539   void * jresult ;
21540   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21541   Dali::Texture *arg2 = 0 ;
21542   Dali::Texture *result = 0 ;
21543
21544   arg1 = (Dali::Texture *)jarg1;
21545   arg2 = (Dali::Texture *)jarg2;
21546   if (!arg2) {
21547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21548     return 0;
21549   }
21550   {
21551     try {
21552       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21553     } catch (std::out_of_range& e) {
21554       {
21555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21556       };
21557     } catch (std::exception& e) {
21558       {
21559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21560       };
21561     } catch (...) {
21562       {
21563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21564       };
21565     }
21566   }
21567   jresult = (void *)result;
21568   return jresult;
21569 }
21570
21571
21572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21573   unsigned int jresult ;
21574   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21575   Dali::PixelData arg2 ;
21576   Dali::PixelData *argp2 ;
21577   bool result;
21578
21579   arg1 = (Dali::Texture *)jarg1;
21580   argp2 = (Dali::PixelData *)jarg2;
21581   if (!argp2) {
21582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21583     return 0;
21584   }
21585   arg2 = *argp2;
21586   {
21587     try {
21588       result = (bool)(arg1)->Upload(arg2);
21589     } catch (std::out_of_range& e) {
21590       {
21591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21592       };
21593     } catch (std::exception& e) {
21594       {
21595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21596       };
21597     } catch (...) {
21598       {
21599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21600       };
21601     }
21602   }
21603   jresult = result;
21604   return jresult;
21605 }
21606
21607
21608 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) {
21609   unsigned int jresult ;
21610   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21611   Dali::PixelData arg2 ;
21612   unsigned int arg3 ;
21613   unsigned int arg4 ;
21614   unsigned int arg5 ;
21615   unsigned int arg6 ;
21616   unsigned int arg7 ;
21617   unsigned int arg8 ;
21618   Dali::PixelData *argp2 ;
21619   bool result;
21620
21621   arg1 = (Dali::Texture *)jarg1;
21622   argp2 = (Dali::PixelData *)jarg2;
21623   if (!argp2) {
21624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21625     return 0;
21626   }
21627   arg2 = *argp2;
21628   arg3 = (unsigned int)jarg3;
21629   arg4 = (unsigned int)jarg4;
21630   arg5 = (unsigned int)jarg5;
21631   arg6 = (unsigned int)jarg6;
21632   arg7 = (unsigned int)jarg7;
21633   arg8 = (unsigned int)jarg8;
21634   {
21635     try {
21636       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21637     } catch (std::out_of_range& e) {
21638       {
21639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21640       };
21641     } catch (std::exception& e) {
21642       {
21643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21644       };
21645     } catch (...) {
21646       {
21647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21648       };
21649     }
21650   }
21651   jresult = result;
21652   return jresult;
21653 }
21654
21655
21656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21657   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21658
21659   arg1 = (Dali::Texture *)jarg1;
21660   {
21661     try {
21662       (arg1)->GenerateMipmaps();
21663     } catch (std::out_of_range& e) {
21664       {
21665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21666       };
21667     } catch (std::exception& e) {
21668       {
21669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21670       };
21671     } catch (...) {
21672       {
21673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21674       };
21675     }
21676   }
21677 }
21678
21679
21680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21681   unsigned int jresult ;
21682   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21683   unsigned int result;
21684
21685   arg1 = (Dali::Texture *)jarg1;
21686   {
21687     try {
21688       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21689     } catch (std::out_of_range& e) {
21690       {
21691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21692       };
21693     } catch (std::exception& e) {
21694       {
21695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21696       };
21697     } catch (...) {
21698       {
21699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21700       };
21701     }
21702   }
21703   jresult = result;
21704   return jresult;
21705 }
21706
21707
21708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21709   unsigned int jresult ;
21710   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21711   unsigned int result;
21712
21713   arg1 = (Dali::Texture *)jarg1;
21714   {
21715     try {
21716       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21717     } catch (std::out_of_range& e) {
21718       {
21719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21720       };
21721     } catch (std::exception& e) {
21722       {
21723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21724       };
21725     } catch (...) {
21726       {
21727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21728       };
21729     }
21730   }
21731   jresult = result;
21732   return jresult;
21733 }
21734
21735
21736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21737   void * jresult ;
21738   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21739   Dali::Texture *result = 0 ;
21740
21741   arg1 = (Dali::Internal::Texture *)jarg1;
21742   {
21743     try {
21744       result = (Dali::Texture *)new Dali::Texture(arg1);
21745     } catch (std::out_of_range& e) {
21746       {
21747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21748       };
21749     } catch (std::exception& e) {
21750       {
21751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21752       };
21753     } catch (...) {
21754       {
21755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21756       };
21757     }
21758   }
21759   jresult = (void *)result;
21760   return jresult;
21761 }
21762
21763
21764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21765   void * jresult ;
21766   Dali::Sampler result;
21767
21768   {
21769     try {
21770       result = Dali::Sampler::New();
21771     } catch (std::out_of_range& e) {
21772       {
21773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21774       };
21775     } catch (std::exception& e) {
21776       {
21777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21778       };
21779     } catch (...) {
21780       {
21781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21782       };
21783     }
21784   }
21785   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21786   return jresult;
21787 }
21788
21789
21790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21791   void * jresult ;
21792   Dali::Sampler *result = 0 ;
21793
21794   {
21795     try {
21796       result = (Dali::Sampler *)new Dali::Sampler();
21797     } catch (std::out_of_range& e) {
21798       {
21799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21800       };
21801     } catch (std::exception& e) {
21802       {
21803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21804       };
21805     } catch (...) {
21806       {
21807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21808       };
21809     }
21810   }
21811   jresult = (void *)result;
21812   return jresult;
21813 }
21814
21815
21816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21817   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21818
21819   arg1 = (Dali::Sampler *)jarg1;
21820   {
21821     try {
21822       delete arg1;
21823     } catch (std::out_of_range& e) {
21824       {
21825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21826       };
21827     } catch (std::exception& e) {
21828       {
21829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21830       };
21831     } catch (...) {
21832       {
21833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21834       };
21835     }
21836   }
21837 }
21838
21839
21840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21841   void * jresult ;
21842   Dali::Sampler *arg1 = 0 ;
21843   Dali::Sampler *result = 0 ;
21844
21845   arg1 = (Dali::Sampler *)jarg1;
21846   if (!arg1) {
21847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21848     return 0;
21849   }
21850   {
21851     try {
21852       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21853     } catch (std::out_of_range& e) {
21854       {
21855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21856       };
21857     } catch (std::exception& e) {
21858       {
21859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21860       };
21861     } catch (...) {
21862       {
21863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21864       };
21865     }
21866   }
21867   jresult = (void *)result;
21868   return jresult;
21869 }
21870
21871
21872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21873   void * jresult ;
21874   Dali::BaseHandle arg1 ;
21875   Dali::BaseHandle *argp1 ;
21876   Dali::Sampler result;
21877
21878   argp1 = (Dali::BaseHandle *)jarg1;
21879   if (!argp1) {
21880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21881     return 0;
21882   }
21883   arg1 = *argp1;
21884   {
21885     try {
21886       result = Dali::Sampler::DownCast(arg1);
21887     } catch (std::out_of_range& e) {
21888       {
21889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21890       };
21891     } catch (std::exception& e) {
21892       {
21893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21894       };
21895     } catch (...) {
21896       {
21897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21898       };
21899     }
21900   }
21901   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21902   return jresult;
21903 }
21904
21905
21906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21907   void * jresult ;
21908   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21909   Dali::Sampler *arg2 = 0 ;
21910   Dali::Sampler *result = 0 ;
21911
21912   arg1 = (Dali::Sampler *)jarg1;
21913   arg2 = (Dali::Sampler *)jarg2;
21914   if (!arg2) {
21915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21916     return 0;
21917   }
21918   {
21919     try {
21920       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21921     } catch (std::out_of_range& e) {
21922       {
21923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21924       };
21925     } catch (std::exception& e) {
21926       {
21927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21928       };
21929     } catch (...) {
21930       {
21931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21932       };
21933     }
21934   }
21935   jresult = (void *)result;
21936   return jresult;
21937 }
21938
21939
21940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21941   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21942   Dali::FilterMode::Type arg2 ;
21943   Dali::FilterMode::Type arg3 ;
21944
21945   arg1 = (Dali::Sampler *)jarg1;
21946   arg2 = (Dali::FilterMode::Type)jarg2;
21947   arg3 = (Dali::FilterMode::Type)jarg3;
21948   {
21949     try {
21950       (arg1)->SetFilterMode(arg2,arg3);
21951     } catch (std::out_of_range& e) {
21952       {
21953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21954       };
21955     } catch (std::exception& e) {
21956       {
21957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21958       };
21959     } catch (...) {
21960       {
21961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21962       };
21963     }
21964   }
21965 }
21966
21967
21968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
21969   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21970   Dali::WrapMode::Type arg2 ;
21971   Dali::WrapMode::Type arg3 ;
21972
21973   arg1 = (Dali::Sampler *)jarg1;
21974   arg2 = (Dali::WrapMode::Type)jarg2;
21975   arg3 = (Dali::WrapMode::Type)jarg3;
21976   {
21977     try {
21978       (arg1)->SetWrapMode(arg2,arg3);
21979     } catch (std::out_of_range& e) {
21980       {
21981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21982       };
21983     } catch (std::exception& e) {
21984       {
21985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21986       };
21987     } catch (...) {
21988       {
21989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21990       };
21991     }
21992   }
21993 }
21994
21995
21996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
21997   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21998   Dali::WrapMode::Type arg2 ;
21999   Dali::WrapMode::Type arg3 ;
22000   Dali::WrapMode::Type arg4 ;
22001
22002   arg1 = (Dali::Sampler *)jarg1;
22003   arg2 = (Dali::WrapMode::Type)jarg2;
22004   arg3 = (Dali::WrapMode::Type)jarg3;
22005   arg4 = (Dali::WrapMode::Type)jarg4;
22006   {
22007     try {
22008       (arg1)->SetWrapMode(arg2,arg3,arg4);
22009     } catch (std::out_of_range& e) {
22010       {
22011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22012       };
22013     } catch (std::exception& e) {
22014       {
22015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22016       };
22017     } catch (...) {
22018       {
22019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22020       };
22021     }
22022   }
22023 }
22024
22025
22026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22027   void * jresult ;
22028   Dali::TextureSet result;
22029
22030   {
22031     try {
22032       result = Dali::TextureSet::New();
22033     } catch (std::out_of_range& e) {
22034       {
22035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22036       };
22037     } catch (std::exception& e) {
22038       {
22039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22040       };
22041     } catch (...) {
22042       {
22043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22044       };
22045     }
22046   }
22047   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22048   return jresult;
22049 }
22050
22051
22052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22053   void * jresult ;
22054   Dali::TextureSet *result = 0 ;
22055
22056   {
22057     try {
22058       result = (Dali::TextureSet *)new Dali::TextureSet();
22059     } catch (std::out_of_range& e) {
22060       {
22061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22062       };
22063     } catch (std::exception& e) {
22064       {
22065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22066       };
22067     } catch (...) {
22068       {
22069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22070       };
22071     }
22072   }
22073   jresult = (void *)result;
22074   return jresult;
22075 }
22076
22077
22078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22079   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22080
22081   arg1 = (Dali::TextureSet *)jarg1;
22082   {
22083     try {
22084       delete arg1;
22085     } catch (std::out_of_range& e) {
22086       {
22087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22088       };
22089     } catch (std::exception& e) {
22090       {
22091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22092       };
22093     } catch (...) {
22094       {
22095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22096       };
22097     }
22098   }
22099 }
22100
22101
22102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22103   void * jresult ;
22104   Dali::TextureSet *arg1 = 0 ;
22105   Dali::TextureSet *result = 0 ;
22106
22107   arg1 = (Dali::TextureSet *)jarg1;
22108   if (!arg1) {
22109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22110     return 0;
22111   }
22112   {
22113     try {
22114       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22115     } catch (std::out_of_range& e) {
22116       {
22117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22118       };
22119     } catch (std::exception& e) {
22120       {
22121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22122       };
22123     } catch (...) {
22124       {
22125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22126       };
22127     }
22128   }
22129   jresult = (void *)result;
22130   return jresult;
22131 }
22132
22133
22134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22135   void * jresult ;
22136   Dali::BaseHandle arg1 ;
22137   Dali::BaseHandle *argp1 ;
22138   Dali::TextureSet result;
22139
22140   argp1 = (Dali::BaseHandle *)jarg1;
22141   if (!argp1) {
22142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22143     return 0;
22144   }
22145   arg1 = *argp1;
22146   {
22147     try {
22148       result = Dali::TextureSet::DownCast(arg1);
22149     } catch (std::out_of_range& e) {
22150       {
22151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22152       };
22153     } catch (std::exception& e) {
22154       {
22155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22156       };
22157     } catch (...) {
22158       {
22159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22160       };
22161     }
22162   }
22163   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22164   return jresult;
22165 }
22166
22167
22168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22169   void * jresult ;
22170   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22171   Dali::TextureSet *arg2 = 0 ;
22172   Dali::TextureSet *result = 0 ;
22173
22174   arg1 = (Dali::TextureSet *)jarg1;
22175   arg2 = (Dali::TextureSet *)jarg2;
22176   if (!arg2) {
22177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22178     return 0;
22179   }
22180   {
22181     try {
22182       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22183     } catch (std::out_of_range& e) {
22184       {
22185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22186       };
22187     } catch (std::exception& e) {
22188       {
22189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22190       };
22191     } catch (...) {
22192       {
22193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22194       };
22195     }
22196   }
22197   jresult = (void *)result;
22198   return jresult;
22199 }
22200
22201
22202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22203   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22204   size_t arg2 ;
22205   Dali::Texture arg3 ;
22206   Dali::Texture *argp3 ;
22207
22208   arg1 = (Dali::TextureSet *)jarg1;
22209   arg2 = (size_t)jarg2;
22210   argp3 = (Dali::Texture *)jarg3;
22211   if (!argp3) {
22212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22213     return ;
22214   }
22215   arg3 = *argp3;
22216   {
22217     try {
22218       (arg1)->SetTexture(arg2,arg3);
22219     } catch (std::out_of_range& e) {
22220       {
22221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22222       };
22223     } catch (std::exception& e) {
22224       {
22225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22226       };
22227     } catch (...) {
22228       {
22229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22230       };
22231     }
22232   }
22233 }
22234
22235
22236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22237   void * jresult ;
22238   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22239   size_t arg2 ;
22240   Dali::Texture result;
22241
22242   arg1 = (Dali::TextureSet *)jarg1;
22243   arg2 = (size_t)jarg2;
22244   {
22245     try {
22246       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22247     } catch (std::out_of_range& e) {
22248       {
22249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22250       };
22251     } catch (std::exception& e) {
22252       {
22253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22254       };
22255     } catch (...) {
22256       {
22257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22258       };
22259     }
22260   }
22261   jresult = new Dali::Texture((const Dali::Texture &)result);
22262   return jresult;
22263 }
22264
22265
22266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22267   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22268   size_t arg2 ;
22269   Dali::Sampler arg3 ;
22270   Dali::Sampler *argp3 ;
22271
22272   arg1 = (Dali::TextureSet *)jarg1;
22273   arg2 = (size_t)jarg2;
22274   argp3 = (Dali::Sampler *)jarg3;
22275   if (!argp3) {
22276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22277     return ;
22278   }
22279   arg3 = *argp3;
22280   {
22281     try {
22282       (arg1)->SetSampler(arg2,arg3);
22283     } catch (std::out_of_range& e) {
22284       {
22285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22286       };
22287     } catch (std::exception& e) {
22288       {
22289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22290       };
22291     } catch (...) {
22292       {
22293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22294       };
22295     }
22296   }
22297 }
22298
22299
22300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22301   void * jresult ;
22302   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22303   size_t arg2 ;
22304   Dali::Sampler result;
22305
22306   arg1 = (Dali::TextureSet *)jarg1;
22307   arg2 = (size_t)jarg2;
22308   {
22309     try {
22310       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22311     } catch (std::out_of_range& e) {
22312       {
22313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22314       };
22315     } catch (std::exception& e) {
22316       {
22317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22318       };
22319     } catch (...) {
22320       {
22321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22322       };
22323     }
22324   }
22325   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22326   return jresult;
22327 }
22328
22329
22330 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22331   unsigned long jresult ;
22332   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22333   size_t result;
22334
22335   arg1 = (Dali::TextureSet *)jarg1;
22336   {
22337     try {
22338       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22339     } catch (std::out_of_range& e) {
22340       {
22341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22342       };
22343     } catch (std::exception& e) {
22344       {
22345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22346       };
22347     } catch (...) {
22348       {
22349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22350       };
22351     }
22352   }
22353   jresult = (unsigned long)result;
22354   return jresult;
22355 }
22356
22357
22358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22359   void * jresult ;
22360   Dali::Property::Map *arg1 = 0 ;
22361   Dali::PropertyBuffer result;
22362
22363   arg1 = (Dali::Property::Map *)jarg1;
22364   if (!arg1) {
22365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22366     return 0;
22367   }
22368   {
22369     try {
22370       result = Dali::PropertyBuffer::New(*arg1);
22371     } catch (std::out_of_range& e) {
22372       {
22373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22374       };
22375     } catch (std::exception& e) {
22376       {
22377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22378       };
22379     } catch (...) {
22380       {
22381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22382       };
22383     }
22384   }
22385   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22386   return jresult;
22387 }
22388
22389
22390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22391   void * jresult ;
22392   Dali::PropertyBuffer *result = 0 ;
22393
22394   {
22395     try {
22396       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22397     } catch (std::out_of_range& e) {
22398       {
22399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22400       };
22401     } catch (std::exception& e) {
22402       {
22403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22404       };
22405     } catch (...) {
22406       {
22407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22408       };
22409     }
22410   }
22411   jresult = (void *)result;
22412   return jresult;
22413 }
22414
22415
22416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22417   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22418
22419   arg1 = (Dali::PropertyBuffer *)jarg1;
22420   {
22421     try {
22422       delete arg1;
22423     } catch (std::out_of_range& e) {
22424       {
22425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22426       };
22427     } catch (std::exception& e) {
22428       {
22429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22430       };
22431     } catch (...) {
22432       {
22433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22434       };
22435     }
22436   }
22437 }
22438
22439
22440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22441   void * jresult ;
22442   Dali::PropertyBuffer *arg1 = 0 ;
22443   Dali::PropertyBuffer *result = 0 ;
22444
22445   arg1 = (Dali::PropertyBuffer *)jarg1;
22446   if (!arg1) {
22447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22448     return 0;
22449   }
22450   {
22451     try {
22452       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22453     } catch (std::out_of_range& e) {
22454       {
22455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22456       };
22457     } catch (std::exception& e) {
22458       {
22459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22460       };
22461     } catch (...) {
22462       {
22463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22464       };
22465     }
22466   }
22467   jresult = (void *)result;
22468   return jresult;
22469 }
22470
22471
22472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22473   void * jresult ;
22474   Dali::BaseHandle arg1 ;
22475   Dali::BaseHandle *argp1 ;
22476   Dali::PropertyBuffer result;
22477
22478   argp1 = (Dali::BaseHandle *)jarg1;
22479   if (!argp1) {
22480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22481     return 0;
22482   }
22483   arg1 = *argp1;
22484   {
22485     try {
22486       result = Dali::PropertyBuffer::DownCast(arg1);
22487     } catch (std::out_of_range& e) {
22488       {
22489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22490       };
22491     } catch (std::exception& e) {
22492       {
22493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22494       };
22495     } catch (...) {
22496       {
22497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22498       };
22499     }
22500   }
22501   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22502   return jresult;
22503 }
22504
22505
22506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22507   void * jresult ;
22508   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22509   Dali::PropertyBuffer *arg2 = 0 ;
22510   Dali::PropertyBuffer *result = 0 ;
22511
22512   arg1 = (Dali::PropertyBuffer *)jarg1;
22513   arg2 = (Dali::PropertyBuffer *)jarg2;
22514   if (!arg2) {
22515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22516     return 0;
22517   }
22518   {
22519     try {
22520       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22521     } catch (std::out_of_range& e) {
22522       {
22523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22524       };
22525     } catch (std::exception& e) {
22526       {
22527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22528       };
22529     } catch (...) {
22530       {
22531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22532       };
22533     }
22534   }
22535   jresult = (void *)result;
22536   return jresult;
22537 }
22538
22539
22540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22541   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22542   void *arg2 = (void *) 0 ;
22543   std::size_t arg3 ;
22544
22545   arg1 = (Dali::PropertyBuffer *)jarg1;
22546   arg2 = jarg2;
22547   arg3 = (std::size_t)jarg3;
22548   {
22549     try {
22550       (arg1)->SetData((void const *)arg2,arg3);
22551     } catch (std::out_of_range& e) {
22552       {
22553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22554       };
22555     } catch (std::exception& e) {
22556       {
22557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22558       };
22559     } catch (...) {
22560       {
22561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22562       };
22563     }
22564   }
22565 }
22566
22567
22568 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22569   unsigned long jresult ;
22570   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22571   std::size_t result;
22572
22573   arg1 = (Dali::PropertyBuffer *)jarg1;
22574   {
22575     try {
22576       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22577     } catch (std::out_of_range& e) {
22578       {
22579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22580       };
22581     } catch (std::exception& e) {
22582       {
22583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22584       };
22585     } catch (...) {
22586       {
22587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22588       };
22589     }
22590   }
22591   jresult = (unsigned long)result;
22592   return jresult;
22593 }
22594
22595
22596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22597   void * jresult ;
22598   Dali::Geometry result;
22599
22600   {
22601     try {
22602       result = Dali::Geometry::New();
22603     } catch (std::out_of_range& e) {
22604       {
22605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22606       };
22607     } catch (std::exception& e) {
22608       {
22609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22610       };
22611     } catch (...) {
22612       {
22613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22614       };
22615     }
22616   }
22617   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22618   return jresult;
22619 }
22620
22621
22622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22623   void * jresult ;
22624   Dali::Geometry *result = 0 ;
22625
22626   {
22627     try {
22628       result = (Dali::Geometry *)new Dali::Geometry();
22629     } catch (std::out_of_range& e) {
22630       {
22631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22632       };
22633     } catch (std::exception& e) {
22634       {
22635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22636       };
22637     } catch (...) {
22638       {
22639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22640       };
22641     }
22642   }
22643   jresult = (void *)result;
22644   return jresult;
22645 }
22646
22647
22648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22649   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22650
22651   arg1 = (Dali::Geometry *)jarg1;
22652   {
22653     try {
22654       delete arg1;
22655     } catch (std::out_of_range& e) {
22656       {
22657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22658       };
22659     } catch (std::exception& e) {
22660       {
22661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22662       };
22663     } catch (...) {
22664       {
22665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22666       };
22667     }
22668   }
22669 }
22670
22671
22672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22673   void * jresult ;
22674   Dali::Geometry *arg1 = 0 ;
22675   Dali::Geometry *result = 0 ;
22676
22677   arg1 = (Dali::Geometry *)jarg1;
22678   if (!arg1) {
22679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22680     return 0;
22681   }
22682   {
22683     try {
22684       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22685     } catch (std::out_of_range& e) {
22686       {
22687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22688       };
22689     } catch (std::exception& e) {
22690       {
22691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22692       };
22693     } catch (...) {
22694       {
22695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22696       };
22697     }
22698   }
22699   jresult = (void *)result;
22700   return jresult;
22701 }
22702
22703
22704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22705   void * jresult ;
22706   Dali::BaseHandle arg1 ;
22707   Dali::BaseHandle *argp1 ;
22708   Dali::Geometry result;
22709
22710   argp1 = (Dali::BaseHandle *)jarg1;
22711   if (!argp1) {
22712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22713     return 0;
22714   }
22715   arg1 = *argp1;
22716   {
22717     try {
22718       result = Dali::Geometry::DownCast(arg1);
22719     } catch (std::out_of_range& e) {
22720       {
22721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22722       };
22723     } catch (std::exception& e) {
22724       {
22725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22726       };
22727     } catch (...) {
22728       {
22729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22730       };
22731     }
22732   }
22733   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22734   return jresult;
22735 }
22736
22737
22738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22739   void * jresult ;
22740   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22741   Dali::Geometry *arg2 = 0 ;
22742   Dali::Geometry *result = 0 ;
22743
22744   arg1 = (Dali::Geometry *)jarg1;
22745   arg2 = (Dali::Geometry *)jarg2;
22746   if (!arg2) {
22747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22748     return 0;
22749   }
22750   {
22751     try {
22752       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22753     } catch (std::out_of_range& e) {
22754       {
22755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22756       };
22757     } catch (std::exception& e) {
22758       {
22759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22760       };
22761     } catch (...) {
22762       {
22763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22764       };
22765     }
22766   }
22767   jresult = (void *)result;
22768   return jresult;
22769 }
22770
22771
22772 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22773   unsigned long jresult ;
22774   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22775   Dali::PropertyBuffer *arg2 = 0 ;
22776   std::size_t result;
22777
22778   arg1 = (Dali::Geometry *)jarg1;
22779   arg2 = (Dali::PropertyBuffer *)jarg2;
22780   if (!arg2) {
22781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22782     return 0;
22783   }
22784   {
22785     try {
22786       result = (arg1)->AddVertexBuffer(*arg2);
22787     } catch (std::out_of_range& e) {
22788       {
22789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22790       };
22791     } catch (std::exception& e) {
22792       {
22793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22794       };
22795     } catch (...) {
22796       {
22797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22798       };
22799     }
22800   }
22801   jresult = (unsigned long)result;
22802   return jresult;
22803 }
22804
22805
22806 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22807   unsigned long jresult ;
22808   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22809   std::size_t result;
22810
22811   arg1 = (Dali::Geometry *)jarg1;
22812   {
22813     try {
22814       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22815     } catch (std::out_of_range& e) {
22816       {
22817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22818       };
22819     } catch (std::exception& e) {
22820       {
22821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22822       };
22823     } catch (...) {
22824       {
22825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22826       };
22827     }
22828   }
22829   jresult = (unsigned long)result;
22830   return jresult;
22831 }
22832
22833
22834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22835   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22836   std::size_t arg2 ;
22837
22838   arg1 = (Dali::Geometry *)jarg1;
22839   arg2 = (std::size_t)jarg2;
22840   {
22841     try {
22842       (arg1)->RemoveVertexBuffer(arg2);
22843     } catch (std::out_of_range& e) {
22844       {
22845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22846       };
22847     } catch (std::exception& e) {
22848       {
22849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22850       };
22851     } catch (...) {
22852       {
22853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22854       };
22855     }
22856   }
22857 }
22858
22859
22860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22861   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22862   unsigned short *arg2 = (unsigned short *) 0 ;
22863   size_t arg3 ;
22864
22865   arg1 = (Dali::Geometry *)jarg1;
22866   arg2 = jarg2;
22867   arg3 = (size_t)jarg3;
22868   {
22869     try {
22870       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22871     } catch (std::out_of_range& e) {
22872       {
22873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22874       };
22875     } catch (std::exception& e) {
22876       {
22877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22878       };
22879     } catch (...) {
22880       {
22881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22882       };
22883     }
22884   }
22885
22886
22887 }
22888
22889
22890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22891   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22892   Dali::Geometry::Type arg2 ;
22893
22894   arg1 = (Dali::Geometry *)jarg1;
22895   arg2 = (Dali::Geometry::Type)jarg2;
22896   {
22897     try {
22898       (arg1)->SetType(arg2);
22899     } catch (std::out_of_range& e) {
22900       {
22901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22902       };
22903     } catch (std::exception& e) {
22904       {
22905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22906       };
22907     } catch (...) {
22908       {
22909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22910       };
22911     }
22912   }
22913 }
22914
22915
22916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22917   int jresult ;
22918   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22919   Dali::Geometry::Type result;
22920
22921   arg1 = (Dali::Geometry *)jarg1;
22922   {
22923     try {
22924       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22925     } catch (std::out_of_range& e) {
22926       {
22927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22928       };
22929     } catch (std::exception& e) {
22930       {
22931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22932       };
22933     } catch (...) {
22934       {
22935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22936       };
22937     }
22938   }
22939   jresult = (int)result;
22940   return jresult;
22941 }
22942
22943
22944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
22945   void * jresult ;
22946   Dali::Shader::Hint *result = 0 ;
22947
22948   {
22949     try {
22950       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22951     } catch (std::out_of_range& e) {
22952       {
22953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22954       };
22955     } catch (std::exception& e) {
22956       {
22957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22958       };
22959     } catch (...) {
22960       {
22961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22962       };
22963     }
22964   }
22965   jresult = (void *)result;
22966   return jresult;
22967 }
22968
22969
22970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
22971   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
22972
22973   arg1 = (Dali::Shader::Hint *)jarg1;
22974   {
22975     try {
22976       delete arg1;
22977     } catch (std::out_of_range& e) {
22978       {
22979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22980       };
22981     } catch (std::exception& e) {
22982       {
22983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22984       };
22985     } catch (...) {
22986       {
22987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22988       };
22989     }
22990   }
22991 }
22992
22993
22994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
22995   int jresult ;
22996   int result;
22997
22998   result = (int)Dali::Shader::Property::PROGRAM;
22999   jresult = (int)result;
23000   return jresult;
23001 }
23002
23003
23004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23005   void * jresult ;
23006   Dali::Shader::Property *result = 0 ;
23007
23008   {
23009     try {
23010       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23011     } catch (std::out_of_range& e) {
23012       {
23013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23014       };
23015     } catch (std::exception& e) {
23016       {
23017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23018       };
23019     } catch (...) {
23020       {
23021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23022       };
23023     }
23024   }
23025   jresult = (void *)result;
23026   return jresult;
23027 }
23028
23029
23030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23031   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23032
23033   arg1 = (Dali::Shader::Property *)jarg1;
23034   {
23035     try {
23036       delete arg1;
23037     } catch (std::out_of_range& e) {
23038       {
23039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23040       };
23041     } catch (std::exception& e) {
23042       {
23043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23044       };
23045     } catch (...) {
23046       {
23047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23048       };
23049     }
23050   }
23051 }
23052
23053
23054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23055   void * jresult ;
23056   std::string *arg1 = 0 ;
23057   std::string *arg2 = 0 ;
23058   Dali::Shader::Hint::Value arg3 ;
23059   Dali::Shader result;
23060
23061   if (!jarg1) {
23062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23063     return 0;
23064   }
23065   std::string arg1_str(jarg1);
23066   arg1 = &arg1_str;
23067   if (!jarg2) {
23068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23069     return 0;
23070   }
23071   std::string arg2_str(jarg2);
23072   arg2 = &arg2_str;
23073   arg3 = (Dali::Shader::Hint::Value)jarg3;
23074   {
23075     try {
23076       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23077     } catch (std::out_of_range& e) {
23078       {
23079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23080       };
23081     } catch (std::exception& e) {
23082       {
23083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23084       };
23085     } catch (...) {
23086       {
23087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23088       };
23089     }
23090   }
23091   jresult = new Dali::Shader((const Dali::Shader &)result);
23092
23093   //argout typemap for const std::string&
23094
23095
23096   //argout typemap for const std::string&
23097
23098   return jresult;
23099 }
23100
23101
23102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23103   void * jresult ;
23104   std::string *arg1 = 0 ;
23105   std::string *arg2 = 0 ;
23106   Dali::Shader result;
23107
23108   if (!jarg1) {
23109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23110     return 0;
23111   }
23112   std::string arg1_str(jarg1);
23113   arg1 = &arg1_str;
23114   if (!jarg2) {
23115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23116     return 0;
23117   }
23118   std::string arg2_str(jarg2);
23119   arg2 = &arg2_str;
23120   {
23121     try {
23122       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23123     } catch (std::out_of_range& e) {
23124       {
23125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23126       };
23127     } catch (std::exception& e) {
23128       {
23129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23130       };
23131     } catch (...) {
23132       {
23133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23134       };
23135     }
23136   }
23137   jresult = new Dali::Shader((const Dali::Shader &)result);
23138
23139   //argout typemap for const std::string&
23140
23141
23142   //argout typemap for const std::string&
23143
23144   return jresult;
23145 }
23146
23147
23148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23149   void * jresult ;
23150   Dali::Shader *result = 0 ;
23151
23152   {
23153     try {
23154       result = (Dali::Shader *)new Dali::Shader();
23155     } catch (std::out_of_range& e) {
23156       {
23157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23158       };
23159     } catch (std::exception& e) {
23160       {
23161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23162       };
23163     } catch (...) {
23164       {
23165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23166       };
23167     }
23168   }
23169   jresult = (void *)result;
23170   return jresult;
23171 }
23172
23173
23174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23175   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23176
23177   arg1 = (Dali::Shader *)jarg1;
23178   {
23179     try {
23180       delete arg1;
23181     } catch (std::out_of_range& e) {
23182       {
23183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23184       };
23185     } catch (std::exception& e) {
23186       {
23187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23188       };
23189     } catch (...) {
23190       {
23191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23192       };
23193     }
23194   }
23195 }
23196
23197
23198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23199   void * jresult ;
23200   Dali::Shader *arg1 = 0 ;
23201   Dali::Shader *result = 0 ;
23202
23203   arg1 = (Dali::Shader *)jarg1;
23204   if (!arg1) {
23205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23206     return 0;
23207   }
23208   {
23209     try {
23210       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23211     } catch (std::out_of_range& e) {
23212       {
23213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23214       };
23215     } catch (std::exception& e) {
23216       {
23217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23218       };
23219     } catch (...) {
23220       {
23221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23222       };
23223     }
23224   }
23225   jresult = (void *)result;
23226   return jresult;
23227 }
23228
23229
23230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23231   void * jresult ;
23232   Dali::BaseHandle arg1 ;
23233   Dali::BaseHandle *argp1 ;
23234   Dali::Shader result;
23235
23236   argp1 = (Dali::BaseHandle *)jarg1;
23237   if (!argp1) {
23238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23239     return 0;
23240   }
23241   arg1 = *argp1;
23242   {
23243     try {
23244       result = Dali::Shader::DownCast(arg1);
23245     } catch (std::out_of_range& e) {
23246       {
23247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23248       };
23249     } catch (std::exception& e) {
23250       {
23251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23252       };
23253     } catch (...) {
23254       {
23255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23256       };
23257     }
23258   }
23259   jresult = new Dali::Shader((const Dali::Shader &)result);
23260   return jresult;
23261 }
23262
23263
23264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23265   void * jresult ;
23266   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23267   Dali::Shader *arg2 = 0 ;
23268   Dali::Shader *result = 0 ;
23269
23270   arg1 = (Dali::Shader *)jarg1;
23271   arg2 = (Dali::Shader *)jarg2;
23272   if (!arg2) {
23273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23274     return 0;
23275   }
23276   {
23277     try {
23278       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23279     } catch (std::out_of_range& e) {
23280       {
23281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23282       };
23283     } catch (std::exception& e) {
23284       {
23285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23286       };
23287     } catch (...) {
23288       {
23289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23290       };
23291     }
23292   }
23293   jresult = (void *)result;
23294   return jresult;
23295 }
23296
23297
23298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23299   int jresult ;
23300   int result;
23301
23302   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23303   jresult = (int)result;
23304   return jresult;
23305 }
23306
23307
23308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23309   int jresult ;
23310   int result;
23311
23312   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23313   jresult = (int)result;
23314   return jresult;
23315 }
23316
23317
23318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23319   int jresult ;
23320   int result;
23321
23322   result = (int)Dali::Renderer::Property::BLEND_MODE;
23323   jresult = (int)result;
23324   return jresult;
23325 }
23326
23327
23328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23329   int jresult ;
23330   int result;
23331
23332   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23333   jresult = (int)result;
23334   return jresult;
23335 }
23336
23337
23338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23339   int jresult ;
23340   int result;
23341
23342   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23343   jresult = (int)result;
23344   return jresult;
23345 }
23346
23347
23348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23349   int jresult ;
23350   int result;
23351
23352   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23353   jresult = (int)result;
23354   return jresult;
23355 }
23356
23357
23358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23359   int jresult ;
23360   int result;
23361
23362   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23363   jresult = (int)result;
23364   return jresult;
23365 }
23366
23367
23368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23369   int jresult ;
23370   int result;
23371
23372   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23373   jresult = (int)result;
23374   return jresult;
23375 }
23376
23377
23378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23379   int jresult ;
23380   int result;
23381
23382   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23383   jresult = (int)result;
23384   return jresult;
23385 }
23386
23387
23388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23389   int jresult ;
23390   int result;
23391
23392   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23393   jresult = (int)result;
23394   return jresult;
23395 }
23396
23397
23398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23399   int jresult ;
23400   int result;
23401
23402   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23403   jresult = (int)result;
23404   return jresult;
23405 }
23406
23407
23408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23409   int jresult ;
23410   int result;
23411
23412   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23413   jresult = (int)result;
23414   return jresult;
23415 }
23416
23417
23418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23419   int jresult ;
23420   int result;
23421
23422   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23423   jresult = (int)result;
23424   return jresult;
23425 }
23426
23427
23428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23429   int jresult ;
23430   int result;
23431
23432   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23433   jresult = (int)result;
23434   return jresult;
23435 }
23436
23437
23438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23439   int jresult ;
23440   int result;
23441
23442   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23443   jresult = (int)result;
23444   return jresult;
23445 }
23446
23447
23448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23449   int jresult ;
23450   int result;
23451
23452   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23453   jresult = (int)result;
23454   return jresult;
23455 }
23456
23457
23458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23459   int jresult ;
23460   int result;
23461
23462   result = (int)Dali::Renderer::Property::RENDER_MODE;
23463   jresult = (int)result;
23464   return jresult;
23465 }
23466
23467
23468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23469   int jresult ;
23470   int result;
23471
23472   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23473   jresult = (int)result;
23474   return jresult;
23475 }
23476
23477
23478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23479   int jresult ;
23480   int result;
23481
23482   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23483   jresult = (int)result;
23484   return jresult;
23485 }
23486
23487
23488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23489   int jresult ;
23490   int result;
23491
23492   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23493   jresult = (int)result;
23494   return jresult;
23495 }
23496
23497
23498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23499   int jresult ;
23500   int result;
23501
23502   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23503   jresult = (int)result;
23504   return jresult;
23505 }
23506
23507
23508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23509   int jresult ;
23510   int result;
23511
23512   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23513   jresult = (int)result;
23514   return jresult;
23515 }
23516
23517
23518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23519   int jresult ;
23520   int result;
23521
23522   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23523   jresult = (int)result;
23524   return jresult;
23525 }
23526
23527
23528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23529   int jresult ;
23530   int result;
23531
23532   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23533   jresult = (int)result;
23534   return jresult;
23535 }
23536
23537
23538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23539   void * jresult ;
23540   Dali::Renderer::Property *result = 0 ;
23541
23542   {
23543     try {
23544       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23545     } catch (std::out_of_range& e) {
23546       {
23547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23548       };
23549     } catch (std::exception& e) {
23550       {
23551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23552       };
23553     } catch (...) {
23554       {
23555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23556       };
23557     }
23558   }
23559   jresult = (void *)result;
23560   return jresult;
23561 }
23562
23563
23564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23565   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23566
23567   arg1 = (Dali::Renderer::Property *)jarg1;
23568   {
23569     try {
23570       delete arg1;
23571     } catch (std::out_of_range& e) {
23572       {
23573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23574       };
23575     } catch (std::exception& e) {
23576       {
23577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23578       };
23579     } catch (...) {
23580       {
23581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23582       };
23583     }
23584   }
23585 }
23586
23587
23588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23589   void * jresult ;
23590   Dali::Geometry *arg1 = 0 ;
23591   Dali::Shader *arg2 = 0 ;
23592   Dali::Renderer result;
23593
23594   arg1 = (Dali::Geometry *)jarg1;
23595   if (!arg1) {
23596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23597     return 0;
23598   }
23599   arg2 = (Dali::Shader *)jarg2;
23600   if (!arg2) {
23601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23602     return 0;
23603   }
23604   {
23605     try {
23606       result = Dali::Renderer::New(*arg1,*arg2);
23607     } catch (std::out_of_range& e) {
23608       {
23609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23610       };
23611     } catch (std::exception& e) {
23612       {
23613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23614       };
23615     } catch (...) {
23616       {
23617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23618       };
23619     }
23620   }
23621   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23622   return jresult;
23623 }
23624
23625
23626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23627   void * jresult ;
23628   Dali::Renderer *result = 0 ;
23629
23630   {
23631     try {
23632       result = (Dali::Renderer *)new Dali::Renderer();
23633     } catch (std::out_of_range& e) {
23634       {
23635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23636       };
23637     } catch (std::exception& e) {
23638       {
23639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23640       };
23641     } catch (...) {
23642       {
23643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23644       };
23645     }
23646   }
23647   jresult = (void *)result;
23648   return jresult;
23649 }
23650
23651
23652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23653   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23654
23655   arg1 = (Dali::Renderer *)jarg1;
23656   {
23657     try {
23658       delete arg1;
23659     } catch (std::out_of_range& e) {
23660       {
23661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23662       };
23663     } catch (std::exception& e) {
23664       {
23665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23666       };
23667     } catch (...) {
23668       {
23669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23670       };
23671     }
23672   }
23673 }
23674
23675
23676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23677   void * jresult ;
23678   Dali::Renderer *arg1 = 0 ;
23679   Dali::Renderer *result = 0 ;
23680
23681   arg1 = (Dali::Renderer *)jarg1;
23682   if (!arg1) {
23683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23684     return 0;
23685   }
23686   {
23687     try {
23688       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23689     } catch (std::out_of_range& e) {
23690       {
23691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23692       };
23693     } catch (std::exception& e) {
23694       {
23695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23696       };
23697     } catch (...) {
23698       {
23699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23700       };
23701     }
23702   }
23703   jresult = (void *)result;
23704   return jresult;
23705 }
23706
23707
23708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23709   void * jresult ;
23710   Dali::BaseHandle arg1 ;
23711   Dali::BaseHandle *argp1 ;
23712   Dali::Renderer result;
23713
23714   argp1 = (Dali::BaseHandle *)jarg1;
23715   if (!argp1) {
23716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23717     return 0;
23718   }
23719   arg1 = *argp1;
23720   {
23721     try {
23722       result = Dali::Renderer::DownCast(arg1);
23723     } catch (std::out_of_range& e) {
23724       {
23725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23726       };
23727     } catch (std::exception& e) {
23728       {
23729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23730       };
23731     } catch (...) {
23732       {
23733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23734       };
23735     }
23736   }
23737   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23738   return jresult;
23739 }
23740
23741
23742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23743   void * jresult ;
23744   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23745   Dali::Renderer *arg2 = 0 ;
23746   Dali::Renderer *result = 0 ;
23747
23748   arg1 = (Dali::Renderer *)jarg1;
23749   arg2 = (Dali::Renderer *)jarg2;
23750   if (!arg2) {
23751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23752     return 0;
23753   }
23754   {
23755     try {
23756       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23757     } catch (std::out_of_range& e) {
23758       {
23759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23760       };
23761     } catch (std::exception& e) {
23762       {
23763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23764       };
23765     } catch (...) {
23766       {
23767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23768       };
23769     }
23770   }
23771   jresult = (void *)result;
23772   return jresult;
23773 }
23774
23775
23776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23777   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23778   Dali::Geometry *arg2 = 0 ;
23779
23780   arg1 = (Dali::Renderer *)jarg1;
23781   arg2 = (Dali::Geometry *)jarg2;
23782   if (!arg2) {
23783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23784     return ;
23785   }
23786   {
23787     try {
23788       (arg1)->SetGeometry(*arg2);
23789     } catch (std::out_of_range& e) {
23790       {
23791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23792       };
23793     } catch (std::exception& e) {
23794       {
23795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23796       };
23797     } catch (...) {
23798       {
23799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23800       };
23801     }
23802   }
23803 }
23804
23805
23806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23807   void * jresult ;
23808   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23809   Dali::Geometry result;
23810
23811   arg1 = (Dali::Renderer *)jarg1;
23812   {
23813     try {
23814       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23815     } catch (std::out_of_range& e) {
23816       {
23817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23818       };
23819     } catch (std::exception& e) {
23820       {
23821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23822       };
23823     } catch (...) {
23824       {
23825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23826       };
23827     }
23828   }
23829   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23830   return jresult;
23831 }
23832
23833
23834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23835   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23836   int arg2 ;
23837   int arg3 ;
23838
23839   arg1 = (Dali::Renderer *)jarg1;
23840   arg2 = (int)jarg2;
23841   arg3 = (int)jarg3;
23842   {
23843     try {
23844       (arg1)->SetIndexRange(arg2,arg3);
23845     } catch (std::out_of_range& e) {
23846       {
23847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23848       };
23849     } catch (std::exception& e) {
23850       {
23851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23852       };
23853     } catch (...) {
23854       {
23855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23856       };
23857     }
23858   }
23859 }
23860
23861
23862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23863   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23864   Dali::TextureSet *arg2 = 0 ;
23865
23866   arg1 = (Dali::Renderer *)jarg1;
23867   arg2 = (Dali::TextureSet *)jarg2;
23868   if (!arg2) {
23869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23870     return ;
23871   }
23872   {
23873     try {
23874       (arg1)->SetTextures(*arg2);
23875     } catch (std::out_of_range& e) {
23876       {
23877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23878       };
23879     } catch (std::exception& e) {
23880       {
23881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23882       };
23883     } catch (...) {
23884       {
23885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23886       };
23887     }
23888   }
23889 }
23890
23891
23892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23893   void * jresult ;
23894   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23895   Dali::TextureSet result;
23896
23897   arg1 = (Dali::Renderer *)jarg1;
23898   {
23899     try {
23900       result = ((Dali::Renderer const *)arg1)->GetTextures();
23901     } catch (std::out_of_range& e) {
23902       {
23903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23904       };
23905     } catch (std::exception& e) {
23906       {
23907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23908       };
23909     } catch (...) {
23910       {
23911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23912       };
23913     }
23914   }
23915   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23916   return jresult;
23917 }
23918
23919
23920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23921   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23922   Dali::Shader *arg2 = 0 ;
23923
23924   arg1 = (Dali::Renderer *)jarg1;
23925   arg2 = (Dali::Shader *)jarg2;
23926   if (!arg2) {
23927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23928     return ;
23929   }
23930   {
23931     try {
23932       (arg1)->SetShader(*arg2);
23933     } catch (std::out_of_range& e) {
23934       {
23935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23936       };
23937     } catch (std::exception& e) {
23938       {
23939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23940       };
23941     } catch (...) {
23942       {
23943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23944       };
23945     }
23946   }
23947 }
23948
23949
23950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
23951   void * jresult ;
23952   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23953   Dali::Shader result;
23954
23955   arg1 = (Dali::Renderer *)jarg1;
23956   {
23957     try {
23958       result = ((Dali::Renderer const *)arg1)->GetShader();
23959     } catch (std::out_of_range& e) {
23960       {
23961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23962       };
23963     } catch (std::exception& e) {
23964       {
23965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23966       };
23967     } catch (...) {
23968       {
23969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23970       };
23971     }
23972   }
23973   jresult = new Dali::Shader((const Dali::Shader &)result);
23974   return jresult;
23975 }
23976
23977
23978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
23979   void * jresult ;
23980   Dali::FrameBuffer::Attachment *result = 0 ;
23981
23982   {
23983     try {
23984       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
23985     } catch (std::out_of_range& e) {
23986       {
23987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23988       };
23989     } catch (std::exception& e) {
23990       {
23991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23992       };
23993     } catch (...) {
23994       {
23995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23996       };
23997     }
23998   }
23999   jresult = (void *)result;
24000   return jresult;
24001 }
24002
24003
24004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24005   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24006
24007   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24008   {
24009     try {
24010       delete arg1;
24011     } catch (std::out_of_range& e) {
24012       {
24013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24014       };
24015     } catch (std::exception& e) {
24016       {
24017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24018       };
24019     } catch (...) {
24020       {
24021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24022       };
24023     }
24024   }
24025 }
24026
24027
24028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24029   void * jresult ;
24030   unsigned int arg1 ;
24031   unsigned int arg2 ;
24032   unsigned int arg3 ;
24033   Dali::FrameBuffer result;
24034
24035   arg1 = (unsigned int)jarg1;
24036   arg2 = (unsigned int)jarg2;
24037   arg3 = (unsigned int)jarg3;
24038   {
24039     try {
24040       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24041     } catch (std::out_of_range& e) {
24042       {
24043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24044       };
24045     } catch (std::exception& e) {
24046       {
24047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24048       };
24049     } catch (...) {
24050       {
24051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24052       };
24053     }
24054   }
24055   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24056   return jresult;
24057 }
24058
24059
24060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24061   void * jresult ;
24062   Dali::FrameBuffer *result = 0 ;
24063
24064   {
24065     try {
24066       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24067     } catch (std::out_of_range& e) {
24068       {
24069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24070       };
24071     } catch (std::exception& e) {
24072       {
24073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24074       };
24075     } catch (...) {
24076       {
24077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24078       };
24079     }
24080   }
24081   jresult = (void *)result;
24082   return jresult;
24083 }
24084
24085
24086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24087   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24088
24089   arg1 = (Dali::FrameBuffer *)jarg1;
24090   {
24091     try {
24092       delete arg1;
24093     } catch (std::out_of_range& e) {
24094       {
24095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24096       };
24097     } catch (std::exception& e) {
24098       {
24099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24100       };
24101     } catch (...) {
24102       {
24103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24104       };
24105     }
24106   }
24107 }
24108
24109
24110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24111   void * jresult ;
24112   Dali::FrameBuffer *arg1 = 0 ;
24113   Dali::FrameBuffer *result = 0 ;
24114
24115   arg1 = (Dali::FrameBuffer *)jarg1;
24116   if (!arg1) {
24117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24118     return 0;
24119   }
24120   {
24121     try {
24122       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24123     } catch (std::out_of_range& e) {
24124       {
24125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24126       };
24127     } catch (std::exception& e) {
24128       {
24129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24130       };
24131     } catch (...) {
24132       {
24133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24134       };
24135     }
24136   }
24137   jresult = (void *)result;
24138   return jresult;
24139 }
24140
24141
24142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24143   void * jresult ;
24144   Dali::BaseHandle arg1 ;
24145   Dali::BaseHandle *argp1 ;
24146   Dali::FrameBuffer result;
24147
24148   argp1 = (Dali::BaseHandle *)jarg1;
24149   if (!argp1) {
24150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24151     return 0;
24152   }
24153   arg1 = *argp1;
24154   {
24155     try {
24156       result = Dali::FrameBuffer::DownCast(arg1);
24157     } catch (std::out_of_range& e) {
24158       {
24159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24160       };
24161     } catch (std::exception& e) {
24162       {
24163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24164       };
24165     } catch (...) {
24166       {
24167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24168       };
24169     }
24170   }
24171   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24172   return jresult;
24173 }
24174
24175
24176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24177   void * jresult ;
24178   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24179   Dali::FrameBuffer *arg2 = 0 ;
24180   Dali::FrameBuffer *result = 0 ;
24181
24182   arg1 = (Dali::FrameBuffer *)jarg1;
24183   arg2 = (Dali::FrameBuffer *)jarg2;
24184   if (!arg2) {
24185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24186     return 0;
24187   }
24188   {
24189     try {
24190       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24191     } catch (std::out_of_range& e) {
24192       {
24193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24194       };
24195     } catch (std::exception& e) {
24196       {
24197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24198       };
24199     } catch (...) {
24200       {
24201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24202       };
24203     }
24204   }
24205   jresult = (void *)result;
24206   return jresult;
24207 }
24208
24209
24210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24211   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24212   Dali::Texture *arg2 = 0 ;
24213
24214   arg1 = (Dali::FrameBuffer *)jarg1;
24215   arg2 = (Dali::Texture *)jarg2;
24216   if (!arg2) {
24217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24218     return ;
24219   }
24220   {
24221     try {
24222       (arg1)->AttachColorTexture(*arg2);
24223     } catch (std::out_of_range& e) {
24224       {
24225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24226       };
24227     } catch (std::exception& e) {
24228       {
24229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24230       };
24231     } catch (...) {
24232       {
24233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24234       };
24235     }
24236   }
24237 }
24238
24239
24240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24241   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24242   Dali::Texture *arg2 = 0 ;
24243   unsigned int arg3 ;
24244   unsigned int arg4 ;
24245
24246   arg1 = (Dali::FrameBuffer *)jarg1;
24247   arg2 = (Dali::Texture *)jarg2;
24248   if (!arg2) {
24249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24250     return ;
24251   }
24252   arg3 = (unsigned int)jarg3;
24253   arg4 = (unsigned int)jarg4;
24254   {
24255     try {
24256       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24257     } catch (std::out_of_range& e) {
24258       {
24259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24260       };
24261     } catch (std::exception& e) {
24262       {
24263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24264       };
24265     } catch (...) {
24266       {
24267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24268       };
24269     }
24270   }
24271 }
24272
24273
24274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24275   void * jresult ;
24276   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24277   Dali::Texture result;
24278
24279   arg1 = (Dali::FrameBuffer *)jarg1;
24280   {
24281     try {
24282       result = (arg1)->GetColorTexture();
24283     } catch (std::out_of_range& e) {
24284       {
24285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24286       };
24287     } catch (std::exception& e) {
24288       {
24289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24290       };
24291     } catch (...) {
24292       {
24293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24294       };
24295     }
24296   }
24297   jresult = new Dali::Texture((const Dali::Texture &)result);
24298   return jresult;
24299 }
24300
24301
24302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24303   void * jresult ;
24304   Dali::RenderTaskList *result = 0 ;
24305
24306   {
24307     try {
24308       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24309     } catch (std::out_of_range& e) {
24310       {
24311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24312       };
24313     } catch (std::exception& e) {
24314       {
24315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24316       };
24317     } catch (...) {
24318       {
24319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24320       };
24321     }
24322   }
24323   jresult = (void *)result;
24324   return jresult;
24325 }
24326
24327
24328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24329   void * jresult ;
24330   Dali::BaseHandle arg1 ;
24331   Dali::BaseHandle *argp1 ;
24332   Dali::RenderTaskList result;
24333
24334   argp1 = (Dali::BaseHandle *)jarg1;
24335   if (!argp1) {
24336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24337     return 0;
24338   }
24339   arg1 = *argp1;
24340   {
24341     try {
24342       result = Dali::RenderTaskList::DownCast(arg1);
24343     } catch (std::out_of_range& e) {
24344       {
24345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24346       };
24347     } catch (std::exception& e) {
24348       {
24349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24350       };
24351     } catch (...) {
24352       {
24353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24354       };
24355     }
24356   }
24357   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24358   return jresult;
24359 }
24360
24361
24362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24363   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24364
24365   arg1 = (Dali::RenderTaskList *)jarg1;
24366   {
24367     try {
24368       delete arg1;
24369     } catch (std::out_of_range& e) {
24370       {
24371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24372       };
24373     } catch (std::exception& e) {
24374       {
24375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24376       };
24377     } catch (...) {
24378       {
24379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24380       };
24381     }
24382   }
24383 }
24384
24385
24386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24387   void * jresult ;
24388   Dali::RenderTaskList *arg1 = 0 ;
24389   Dali::RenderTaskList *result = 0 ;
24390
24391   arg1 = (Dali::RenderTaskList *)jarg1;
24392   if (!arg1) {
24393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24394     return 0;
24395   }
24396   {
24397     try {
24398       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24399     } catch (std::out_of_range& e) {
24400       {
24401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24402       };
24403     } catch (std::exception& e) {
24404       {
24405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24406       };
24407     } catch (...) {
24408       {
24409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24410       };
24411     }
24412   }
24413   jresult = (void *)result;
24414   return jresult;
24415 }
24416
24417
24418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24419   void * jresult ;
24420   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24421   Dali::RenderTaskList *arg2 = 0 ;
24422   Dali::RenderTaskList *result = 0 ;
24423
24424   arg1 = (Dali::RenderTaskList *)jarg1;
24425   arg2 = (Dali::RenderTaskList *)jarg2;
24426   if (!arg2) {
24427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24428     return 0;
24429   }
24430   {
24431     try {
24432       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24433     } catch (std::out_of_range& e) {
24434       {
24435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24436       };
24437     } catch (std::exception& e) {
24438       {
24439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24440       };
24441     } catch (...) {
24442       {
24443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24444       };
24445     }
24446   }
24447   jresult = (void *)result;
24448   return jresult;
24449 }
24450
24451
24452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24453   void * jresult ;
24454   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24455   Dali::RenderTask result;
24456
24457   arg1 = (Dali::RenderTaskList *)jarg1;
24458   {
24459     try {
24460       result = (arg1)->CreateTask();
24461     } catch (std::out_of_range& e) {
24462       {
24463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24464       };
24465     } catch (std::exception& e) {
24466       {
24467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24468       };
24469     } catch (...) {
24470       {
24471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24472       };
24473     }
24474   }
24475   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24476   return jresult;
24477 }
24478
24479
24480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24481   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24482   Dali::RenderTask arg2 ;
24483   Dali::RenderTask *argp2 ;
24484
24485   arg1 = (Dali::RenderTaskList *)jarg1;
24486   argp2 = (Dali::RenderTask *)jarg2;
24487   if (!argp2) {
24488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24489     return ;
24490   }
24491   arg2 = *argp2;
24492   {
24493     try {
24494       (arg1)->RemoveTask(arg2);
24495     } catch (std::out_of_range& e) {
24496       {
24497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24498       };
24499     } catch (std::exception& e) {
24500       {
24501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24502       };
24503     } catch (...) {
24504       {
24505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24506       };
24507     }
24508   }
24509 }
24510
24511
24512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24513   unsigned int jresult ;
24514   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24515   unsigned int result;
24516
24517   arg1 = (Dali::RenderTaskList *)jarg1;
24518   {
24519     try {
24520       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24521     } catch (std::out_of_range& e) {
24522       {
24523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24524       };
24525     } catch (std::exception& e) {
24526       {
24527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24528       };
24529     } catch (...) {
24530       {
24531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24532       };
24533     }
24534   }
24535   jresult = result;
24536   return jresult;
24537 }
24538
24539
24540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24541   void * jresult ;
24542   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24543   unsigned int arg2 ;
24544   Dali::RenderTask result;
24545
24546   arg1 = (Dali::RenderTaskList *)jarg1;
24547   arg2 = (unsigned int)jarg2;
24548   {
24549     try {
24550       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24551     } catch (std::out_of_range& e) {
24552       {
24553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24554       };
24555     } catch (std::exception& e) {
24556       {
24557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24558       };
24559     } catch (...) {
24560       {
24561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24562       };
24563     }
24564   }
24565   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24566   return jresult;
24567 }
24568
24569
24570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24571   int jresult ;
24572   int result;
24573
24574   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24575   jresult = (int)result;
24576   return jresult;
24577 }
24578
24579
24580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24581   int jresult ;
24582   int result;
24583
24584   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24585   jresult = (int)result;
24586   return jresult;
24587 }
24588
24589
24590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24591   int jresult ;
24592   int result;
24593
24594   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24595   jresult = (int)result;
24596   return jresult;
24597 }
24598
24599
24600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24601   int jresult ;
24602   int result;
24603
24604   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24605   jresult = (int)result;
24606   return jresult;
24607 }
24608
24609
24610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24611   void * jresult ;
24612   Dali::RenderTask::Property *result = 0 ;
24613
24614   {
24615     try {
24616       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24617     } catch (std::out_of_range& e) {
24618       {
24619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24620       };
24621     } catch (std::exception& e) {
24622       {
24623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24624       };
24625     } catch (...) {
24626       {
24627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24628       };
24629     }
24630   }
24631   jresult = (void *)result;
24632   return jresult;
24633 }
24634
24635
24636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24637   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24638
24639   arg1 = (Dali::RenderTask::Property *)jarg1;
24640   {
24641     try {
24642       delete arg1;
24643     } catch (std::out_of_range& e) {
24644       {
24645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24646       };
24647     } catch (std::exception& e) {
24648       {
24649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24650       };
24651     } catch (...) {
24652       {
24653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24654       };
24655     }
24656   }
24657 }
24658
24659
24660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24661   void * jresult ;
24662   bool (*result)(Dali::Vector2 &) = 0 ;
24663
24664   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24665   jresult = (void *)result;
24666   return jresult;
24667 }
24668
24669
24670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24671   void * jresult ;
24672   bool (*result)(Dali::Vector2 &) = 0 ;
24673
24674   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24675   jresult = (void *)result;
24676   return jresult;
24677 }
24678
24679
24680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24681   unsigned int jresult ;
24682   bool result;
24683
24684   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24685   jresult = result;
24686   return jresult;
24687 }
24688
24689
24690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24691   unsigned int jresult ;
24692   bool result;
24693
24694   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24695   jresult = result;
24696   return jresult;
24697 }
24698
24699
24700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24701   void * jresult ;
24702   Dali::Vector4 *result = 0 ;
24703
24704   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24705   jresult = (void *)result;
24706   return jresult;
24707 }
24708
24709
24710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24711   unsigned int jresult ;
24712   bool result;
24713
24714   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24715   jresult = result;
24716   return jresult;
24717 }
24718
24719
24720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24721   unsigned int jresult ;
24722   bool result;
24723
24724   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24725   jresult = result;
24726   return jresult;
24727 }
24728
24729
24730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24731   unsigned int jresult ;
24732   unsigned int result;
24733
24734   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24735   jresult = result;
24736   return jresult;
24737 }
24738
24739
24740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24741   void * jresult ;
24742   Dali::RenderTask *result = 0 ;
24743
24744   {
24745     try {
24746       result = (Dali::RenderTask *)new Dali::RenderTask();
24747     } catch (std::out_of_range& e) {
24748       {
24749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24750       };
24751     } catch (std::exception& e) {
24752       {
24753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24754       };
24755     } catch (...) {
24756       {
24757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24758       };
24759     }
24760   }
24761   jresult = (void *)result;
24762   return jresult;
24763 }
24764
24765
24766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24767   void * jresult ;
24768   Dali::BaseHandle arg1 ;
24769   Dali::BaseHandle *argp1 ;
24770   Dali::RenderTask result;
24771
24772   argp1 = (Dali::BaseHandle *)jarg1;
24773   if (!argp1) {
24774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24775     return 0;
24776   }
24777   arg1 = *argp1;
24778   {
24779     try {
24780       result = Dali::RenderTask::DownCast(arg1);
24781     } catch (std::out_of_range& e) {
24782       {
24783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24784       };
24785     } catch (std::exception& e) {
24786       {
24787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24788       };
24789     } catch (...) {
24790       {
24791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24792       };
24793     }
24794   }
24795   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24796   return jresult;
24797 }
24798
24799
24800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24801   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24802
24803   arg1 = (Dali::RenderTask *)jarg1;
24804   {
24805     try {
24806       delete arg1;
24807     } catch (std::out_of_range& e) {
24808       {
24809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24810       };
24811     } catch (std::exception& e) {
24812       {
24813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24814       };
24815     } catch (...) {
24816       {
24817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24818       };
24819     }
24820   }
24821 }
24822
24823
24824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24825   void * jresult ;
24826   Dali::RenderTask *arg1 = 0 ;
24827   Dali::RenderTask *result = 0 ;
24828
24829   arg1 = (Dali::RenderTask *)jarg1;
24830   if (!arg1) {
24831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24832     return 0;
24833   }
24834   {
24835     try {
24836       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24837     } catch (std::out_of_range& e) {
24838       {
24839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24840       };
24841     } catch (std::exception& e) {
24842       {
24843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24844       };
24845     } catch (...) {
24846       {
24847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24848       };
24849     }
24850   }
24851   jresult = (void *)result;
24852   return jresult;
24853 }
24854
24855
24856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24857   void * jresult ;
24858   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24859   Dali::RenderTask *arg2 = 0 ;
24860   Dali::RenderTask *result = 0 ;
24861
24862   arg1 = (Dali::RenderTask *)jarg1;
24863   arg2 = (Dali::RenderTask *)jarg2;
24864   if (!arg2) {
24865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24866     return 0;
24867   }
24868   {
24869     try {
24870       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24871     } catch (std::out_of_range& e) {
24872       {
24873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24874       };
24875     } catch (std::exception& e) {
24876       {
24877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24878       };
24879     } catch (...) {
24880       {
24881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24882       };
24883     }
24884   }
24885   jresult = (void *)result;
24886   return jresult;
24887 }
24888
24889
24890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24891   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24892   Dali::Actor arg2 ;
24893   Dali::Actor *argp2 ;
24894
24895   arg1 = (Dali::RenderTask *)jarg1;
24896   argp2 = (Dali::Actor *)jarg2;
24897   if (!argp2) {
24898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24899     return ;
24900   }
24901   arg2 = *argp2;
24902   {
24903     try {
24904       (arg1)->SetSourceActor(arg2);
24905     } catch (std::out_of_range& e) {
24906       {
24907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24908       };
24909     } catch (std::exception& e) {
24910       {
24911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24912       };
24913     } catch (...) {
24914       {
24915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24916       };
24917     }
24918   }
24919 }
24920
24921
24922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24923   void * jresult ;
24924   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24925   Dali::Actor result;
24926
24927   arg1 = (Dali::RenderTask *)jarg1;
24928   {
24929     try {
24930       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24931     } catch (std::out_of_range& e) {
24932       {
24933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24934       };
24935     } catch (std::exception& e) {
24936       {
24937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24938       };
24939     } catch (...) {
24940       {
24941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24942       };
24943     }
24944   }
24945   jresult = new Dali::Actor((const Dali::Actor &)result);
24946   return jresult;
24947 }
24948
24949
24950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24951   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24952   bool arg2 ;
24953
24954   arg1 = (Dali::RenderTask *)jarg1;
24955   arg2 = jarg2 ? true : false;
24956   {
24957     try {
24958       (arg1)->SetExclusive(arg2);
24959     } catch (std::out_of_range& e) {
24960       {
24961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24962       };
24963     } catch (std::exception& e) {
24964       {
24965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24966       };
24967     } catch (...) {
24968       {
24969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24970       };
24971     }
24972   }
24973 }
24974
24975
24976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
24977   unsigned int jresult ;
24978   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24979   bool result;
24980
24981   arg1 = (Dali::RenderTask *)jarg1;
24982   {
24983     try {
24984       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
24985     } catch (std::out_of_range& e) {
24986       {
24987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24988       };
24989     } catch (std::exception& e) {
24990       {
24991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24992       };
24993     } catch (...) {
24994       {
24995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24996       };
24997     }
24998   }
24999   jresult = result;
25000   return jresult;
25001 }
25002
25003
25004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25005   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25006   bool arg2 ;
25007
25008   arg1 = (Dali::RenderTask *)jarg1;
25009   arg2 = jarg2 ? true : false;
25010   {
25011     try {
25012       (arg1)->SetInputEnabled(arg2);
25013     } catch (std::out_of_range& e) {
25014       {
25015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25016       };
25017     } catch (std::exception& e) {
25018       {
25019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25020       };
25021     } catch (...) {
25022       {
25023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25024       };
25025     }
25026   }
25027 }
25028
25029
25030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25031   unsigned int jresult ;
25032   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25033   bool result;
25034
25035   arg1 = (Dali::RenderTask *)jarg1;
25036   {
25037     try {
25038       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25039     } catch (std::out_of_range& e) {
25040       {
25041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25042       };
25043     } catch (std::exception& e) {
25044       {
25045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25046       };
25047     } catch (...) {
25048       {
25049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25050       };
25051     }
25052   }
25053   jresult = result;
25054   return jresult;
25055 }
25056
25057
25058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25059   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25060   Dali::CameraActor arg2 ;
25061   Dali::CameraActor *argp2 ;
25062
25063   arg1 = (Dali::RenderTask *)jarg1;
25064   argp2 = (Dali::CameraActor *)jarg2;
25065   if (!argp2) {
25066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25067     return ;
25068   }
25069   arg2 = *argp2;
25070   {
25071     try {
25072       (arg1)->SetCameraActor(arg2);
25073     } catch (std::out_of_range& e) {
25074       {
25075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25076       };
25077     } catch (std::exception& e) {
25078       {
25079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25080       };
25081     } catch (...) {
25082       {
25083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25084       };
25085     }
25086   }
25087 }
25088
25089
25090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25091   void * jresult ;
25092   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25093   Dali::CameraActor result;
25094
25095   arg1 = (Dali::RenderTask *)jarg1;
25096   {
25097     try {
25098       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25099     } catch (std::out_of_range& e) {
25100       {
25101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25102       };
25103     } catch (std::exception& e) {
25104       {
25105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25106       };
25107     } catch (...) {
25108       {
25109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25110       };
25111     }
25112   }
25113   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25114   return jresult;
25115 }
25116
25117
25118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25119   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25120   Dali::FrameBufferImage arg2 ;
25121   Dali::FrameBufferImage *argp2 ;
25122
25123   arg1 = (Dali::RenderTask *)jarg1;
25124   argp2 = (Dali::FrameBufferImage *)jarg2;
25125   if (!argp2) {
25126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25127     return ;
25128   }
25129   arg2 = *argp2;
25130   {
25131     try {
25132       (arg1)->SetTargetFrameBuffer(arg2);
25133     } catch (std::out_of_range& e) {
25134       {
25135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25136       };
25137     } catch (std::exception& e) {
25138       {
25139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25140       };
25141     } catch (...) {
25142       {
25143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25144       };
25145     }
25146   }
25147 }
25148
25149
25150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25151   void * jresult ;
25152   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25153   Dali::FrameBufferImage result;
25154
25155   arg1 = (Dali::RenderTask *)jarg1;
25156   {
25157     try {
25158       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25159     } catch (std::out_of_range& e) {
25160       {
25161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25162       };
25163     } catch (std::exception& e) {
25164       {
25165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25166       };
25167     } catch (...) {
25168       {
25169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25170       };
25171     }
25172   }
25173   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25174   return jresult;
25175 }
25176
25177
25178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25179   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25180   Dali::FrameBuffer arg2 ;
25181   Dali::FrameBuffer *argp2 ;
25182
25183   arg1 = (Dali::RenderTask *)jarg1;
25184   argp2 = (Dali::FrameBuffer *)jarg2;
25185   if (!argp2) {
25186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25187     return ;
25188   }
25189   arg2 = *argp2;
25190   {
25191     try {
25192       (arg1)->SetFrameBuffer(arg2);
25193     } catch (std::out_of_range& e) {
25194       {
25195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25196       };
25197     } catch (std::exception& e) {
25198       {
25199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25200       };
25201     } catch (...) {
25202       {
25203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25204       };
25205     }
25206   }
25207 }
25208
25209
25210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25211   void * jresult ;
25212   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25213   Dali::FrameBuffer result;
25214
25215   arg1 = (Dali::RenderTask *)jarg1;
25216   {
25217     try {
25218       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25219     } catch (std::out_of_range& e) {
25220       {
25221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25222       };
25223     } catch (std::exception& e) {
25224       {
25225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25226       };
25227     } catch (...) {
25228       {
25229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25230       };
25231     }
25232   }
25233   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25234   return jresult;
25235 }
25236
25237
25238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25239   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25240   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25241
25242   arg1 = (Dali::RenderTask *)jarg1;
25243   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25244   {
25245     try {
25246       (arg1)->SetScreenToFrameBufferFunction(arg2);
25247     } catch (std::out_of_range& e) {
25248       {
25249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25250       };
25251     } catch (std::exception& e) {
25252       {
25253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25254       };
25255     } catch (...) {
25256       {
25257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25258       };
25259     }
25260   }
25261 }
25262
25263
25264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25265   void * jresult ;
25266   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25267   Dali::RenderTask::ScreenToFrameBufferFunction result;
25268
25269   arg1 = (Dali::RenderTask *)jarg1;
25270   {
25271     try {
25272       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25273     } catch (std::out_of_range& e) {
25274       {
25275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25276       };
25277     } catch (std::exception& e) {
25278       {
25279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25280       };
25281     } catch (...) {
25282       {
25283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25284       };
25285     }
25286   }
25287   jresult = (void *)result;
25288   return jresult;
25289 }
25290
25291
25292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25293   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25294   Dali::Actor arg2 ;
25295   Dali::Actor *argp2 ;
25296
25297   arg1 = (Dali::RenderTask *)jarg1;
25298   argp2 = (Dali::Actor *)jarg2;
25299   if (!argp2) {
25300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25301     return ;
25302   }
25303   arg2 = *argp2;
25304   {
25305     try {
25306       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25307     } catch (std::out_of_range& e) {
25308       {
25309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25310       };
25311     } catch (std::exception& e) {
25312       {
25313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25314       };
25315     } catch (...) {
25316       {
25317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25318       };
25319     }
25320   }
25321 }
25322
25323
25324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25325   void * jresult ;
25326   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25327   Dali::Actor result;
25328
25329   arg1 = (Dali::RenderTask *)jarg1;
25330   {
25331     try {
25332       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25333     } catch (std::out_of_range& e) {
25334       {
25335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25336       };
25337     } catch (std::exception& e) {
25338       {
25339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25340       };
25341     } catch (...) {
25342       {
25343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25344       };
25345     }
25346   }
25347   jresult = new Dali::Actor((const Dali::Actor &)result);
25348   return jresult;
25349 }
25350
25351
25352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25353   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25354   Dali::Vector2 arg2 ;
25355   Dali::Vector2 *argp2 ;
25356
25357   arg1 = (Dali::RenderTask *)jarg1;
25358   argp2 = (Dali::Vector2 *)jarg2;
25359   if (!argp2) {
25360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25361     return ;
25362   }
25363   arg2 = *argp2;
25364   {
25365     try {
25366       (arg1)->SetViewportPosition(arg2);
25367     } catch (std::out_of_range& e) {
25368       {
25369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25370       };
25371     } catch (std::exception& e) {
25372       {
25373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25374       };
25375     } catch (...) {
25376       {
25377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25378       };
25379     }
25380   }
25381 }
25382
25383
25384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25385   void * jresult ;
25386   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25387   Dali::Vector2 result;
25388
25389   arg1 = (Dali::RenderTask *)jarg1;
25390   {
25391     try {
25392       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25393     } catch (std::out_of_range& e) {
25394       {
25395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25396       };
25397     } catch (std::exception& e) {
25398       {
25399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25400       };
25401     } catch (...) {
25402       {
25403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25404       };
25405     }
25406   }
25407   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25408   return jresult;
25409 }
25410
25411
25412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25413   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25414   Dali::Vector2 arg2 ;
25415   Dali::Vector2 *argp2 ;
25416
25417   arg1 = (Dali::RenderTask *)jarg1;
25418   argp2 = (Dali::Vector2 *)jarg2;
25419   if (!argp2) {
25420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25421     return ;
25422   }
25423   arg2 = *argp2;
25424   {
25425     try {
25426       (arg1)->SetViewportSize(arg2);
25427     } catch (std::out_of_range& e) {
25428       {
25429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25430       };
25431     } catch (std::exception& e) {
25432       {
25433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25434       };
25435     } catch (...) {
25436       {
25437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25438       };
25439     }
25440   }
25441 }
25442
25443
25444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25445   void * jresult ;
25446   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25447   Dali::Vector2 result;
25448
25449   arg1 = (Dali::RenderTask *)jarg1;
25450   {
25451     try {
25452       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25453     } catch (std::out_of_range& e) {
25454       {
25455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25456       };
25457     } catch (std::exception& e) {
25458       {
25459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25460       };
25461     } catch (...) {
25462       {
25463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25464       };
25465     }
25466   }
25467   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25468   return jresult;
25469 }
25470
25471
25472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25473   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25474   Dali::Viewport arg2 ;
25475   Dali::Viewport *argp2 ;
25476
25477   arg1 = (Dali::RenderTask *)jarg1;
25478   argp2 = (Dali::Viewport *)jarg2;
25479   if (!argp2) {
25480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25481     return ;
25482   }
25483   arg2 = *argp2;
25484   {
25485     try {
25486       (arg1)->SetViewport(arg2);
25487     } catch (std::out_of_range& e) {
25488       {
25489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25490       };
25491     } catch (std::exception& e) {
25492       {
25493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25494       };
25495     } catch (...) {
25496       {
25497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25498       };
25499     }
25500   }
25501 }
25502
25503
25504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25505   void * jresult ;
25506   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25507   Dali::Viewport result;
25508
25509   arg1 = (Dali::RenderTask *)jarg1;
25510   {
25511     try {
25512       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25513     } catch (std::out_of_range& e) {
25514       {
25515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25516       };
25517     } catch (std::exception& e) {
25518       {
25519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25520       };
25521     } catch (...) {
25522       {
25523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25524       };
25525     }
25526   }
25527   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25528   return jresult;
25529 }
25530
25531
25532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25533   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25534   Dali::Vector4 *arg2 = 0 ;
25535
25536   arg1 = (Dali::RenderTask *)jarg1;
25537   arg2 = (Dali::Vector4 *)jarg2;
25538   if (!arg2) {
25539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25540     return ;
25541   }
25542   {
25543     try {
25544       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25545     } catch (std::out_of_range& e) {
25546       {
25547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25548       };
25549     } catch (std::exception& e) {
25550       {
25551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25552       };
25553     } catch (...) {
25554       {
25555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25556       };
25557     }
25558   }
25559 }
25560
25561
25562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25563   void * jresult ;
25564   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25565   Dali::Vector4 result;
25566
25567   arg1 = (Dali::RenderTask *)jarg1;
25568   {
25569     try {
25570       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25571     } catch (std::out_of_range& e) {
25572       {
25573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25574       };
25575     } catch (std::exception& e) {
25576       {
25577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25578       };
25579     } catch (...) {
25580       {
25581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25582       };
25583     }
25584   }
25585   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25586   return jresult;
25587 }
25588
25589
25590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25591   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25592   bool arg2 ;
25593
25594   arg1 = (Dali::RenderTask *)jarg1;
25595   arg2 = jarg2 ? true : false;
25596   {
25597     try {
25598       (arg1)->SetClearEnabled(arg2);
25599     } catch (std::out_of_range& e) {
25600       {
25601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25602       };
25603     } catch (std::exception& e) {
25604       {
25605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25606       };
25607     } catch (...) {
25608       {
25609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25610       };
25611     }
25612   }
25613 }
25614
25615
25616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25617   unsigned int jresult ;
25618   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25619   bool result;
25620
25621   arg1 = (Dali::RenderTask *)jarg1;
25622   {
25623     try {
25624       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25625     } catch (std::out_of_range& e) {
25626       {
25627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25628       };
25629     } catch (std::exception& e) {
25630       {
25631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25632       };
25633     } catch (...) {
25634       {
25635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25636       };
25637     }
25638   }
25639   jresult = result;
25640   return jresult;
25641 }
25642
25643
25644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25645   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25646   bool arg2 ;
25647
25648   arg1 = (Dali::RenderTask *)jarg1;
25649   arg2 = jarg2 ? true : false;
25650   {
25651     try {
25652       (arg1)->SetCullMode(arg2);
25653     } catch (std::out_of_range& e) {
25654       {
25655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25656       };
25657     } catch (std::exception& e) {
25658       {
25659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25660       };
25661     } catch (...) {
25662       {
25663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25664       };
25665     }
25666   }
25667 }
25668
25669
25670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25671   unsigned int jresult ;
25672   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25673   bool result;
25674
25675   arg1 = (Dali::RenderTask *)jarg1;
25676   {
25677     try {
25678       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25679     } catch (std::out_of_range& e) {
25680       {
25681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25682       };
25683     } catch (std::exception& e) {
25684       {
25685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25686       };
25687     } catch (...) {
25688       {
25689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25690       };
25691     }
25692   }
25693   jresult = result;
25694   return jresult;
25695 }
25696
25697
25698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25699   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25700   unsigned int arg2 ;
25701
25702   arg1 = (Dali::RenderTask *)jarg1;
25703   arg2 = (unsigned int)jarg2;
25704   {
25705     try {
25706       (arg1)->SetRefreshRate(arg2);
25707     } catch (std::out_of_range& e) {
25708       {
25709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25710       };
25711     } catch (std::exception& e) {
25712       {
25713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25714       };
25715     } catch (...) {
25716       {
25717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25718       };
25719     }
25720   }
25721 }
25722
25723
25724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25725   unsigned int jresult ;
25726   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25727   unsigned int result;
25728
25729   arg1 = (Dali::RenderTask *)jarg1;
25730   {
25731     try {
25732       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25733     } catch (std::out_of_range& e) {
25734       {
25735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25736       };
25737     } catch (std::exception& e) {
25738       {
25739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25740       };
25741     } catch (...) {
25742       {
25743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25744       };
25745     }
25746   }
25747   jresult = result;
25748   return jresult;
25749 }
25750
25751
25752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25753   unsigned int jresult ;
25754   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25755   Dali::Vector3 *arg2 = 0 ;
25756   float *arg3 = 0 ;
25757   float *arg4 = 0 ;
25758   bool result;
25759
25760   arg1 = (Dali::RenderTask *)jarg1;
25761   arg2 = (Dali::Vector3 *)jarg2;
25762   if (!arg2) {
25763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25764     return 0;
25765   }
25766   arg3 = (float *)jarg3;
25767   arg4 = (float *)jarg4;
25768   {
25769     try {
25770       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25771     } catch (std::out_of_range& e) {
25772       {
25773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25774       };
25775     } catch (std::exception& e) {
25776       {
25777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25778       };
25779     } catch (...) {
25780       {
25781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25782       };
25783     }
25784   }
25785   jresult = result;
25786   return jresult;
25787 }
25788
25789
25790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25791   unsigned int jresult ;
25792   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25793   Dali::Actor arg2 ;
25794   float arg3 ;
25795   float arg4 ;
25796   float *arg5 = 0 ;
25797   float *arg6 = 0 ;
25798   Dali::Actor *argp2 ;
25799   bool result;
25800
25801   arg1 = (Dali::RenderTask *)jarg1;
25802   argp2 = (Dali::Actor *)jarg2;
25803   if (!argp2) {
25804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25805     return 0;
25806   }
25807   arg2 = *argp2;
25808   arg3 = (float)jarg3;
25809   arg4 = (float)jarg4;
25810   arg5 = (float *)jarg5;
25811   arg6 = (float *)jarg6;
25812   {
25813     try {
25814       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25815     } catch (std::out_of_range& e) {
25816       {
25817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25818       };
25819     } catch (std::exception& e) {
25820       {
25821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25822       };
25823     } catch (...) {
25824       {
25825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25826       };
25827     }
25828   }
25829   jresult = result;
25830   return jresult;
25831 }
25832
25833
25834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25835   void * jresult ;
25836   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25837   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25838
25839   arg1 = (Dali::RenderTask *)jarg1;
25840   {
25841     try {
25842       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25843     } catch (std::out_of_range& e) {
25844       {
25845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25846       };
25847     } catch (std::exception& e) {
25848       {
25849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25850       };
25851     } catch (...) {
25852       {
25853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25854       };
25855     }
25856   }
25857   jresult = (void *)result;
25858   return jresult;
25859 }
25860
25861
25862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25863   void * jresult ;
25864   int arg1 ;
25865   Dali::TouchPoint::State arg2 ;
25866   float arg3 ;
25867   float arg4 ;
25868   Dali::TouchPoint *result = 0 ;
25869
25870   arg1 = (int)jarg1;
25871   arg2 = (Dali::TouchPoint::State)jarg2;
25872   arg3 = (float)jarg3;
25873   arg4 = (float)jarg4;
25874   {
25875     try {
25876       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25877     } catch (std::out_of_range& e) {
25878       {
25879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25880       };
25881     } catch (std::exception& e) {
25882       {
25883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25884       };
25885     } catch (...) {
25886       {
25887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25888       };
25889     }
25890   }
25891   jresult = (void *)result;
25892   return jresult;
25893 }
25894
25895
25896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25897   void * jresult ;
25898   int arg1 ;
25899   Dali::TouchPoint::State arg2 ;
25900   float arg3 ;
25901   float arg4 ;
25902   float arg5 ;
25903   float arg6 ;
25904   Dali::TouchPoint *result = 0 ;
25905
25906   arg1 = (int)jarg1;
25907   arg2 = (Dali::TouchPoint::State)jarg2;
25908   arg3 = (float)jarg3;
25909   arg4 = (float)jarg4;
25910   arg5 = (float)jarg5;
25911   arg6 = (float)jarg6;
25912   {
25913     try {
25914       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25915     } catch (std::out_of_range& e) {
25916       {
25917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25918       };
25919     } catch (std::exception& e) {
25920       {
25921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25922       };
25923     } catch (...) {
25924       {
25925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25926       };
25927     }
25928   }
25929   jresult = (void *)result;
25930   return jresult;
25931 }
25932
25933
25934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25935   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25936
25937   arg1 = (Dali::TouchPoint *)jarg1;
25938   {
25939     try {
25940       delete arg1;
25941     } catch (std::out_of_range& e) {
25942       {
25943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25944       };
25945     } catch (std::exception& e) {
25946       {
25947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25948       };
25949     } catch (...) {
25950       {
25951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25952       };
25953     }
25954   }
25955 }
25956
25957
25958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
25959   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25960   int arg2 ;
25961
25962   arg1 = (Dali::TouchPoint *)jarg1;
25963   arg2 = (int)jarg2;
25964   if (arg1) (arg1)->deviceId = arg2;
25965 }
25966
25967
25968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
25969   int jresult ;
25970   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25971   int result;
25972
25973   arg1 = (Dali::TouchPoint *)jarg1;
25974   result = (int) ((arg1)->deviceId);
25975   jresult = result;
25976   return jresult;
25977 }
25978
25979
25980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
25981   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25982   Dali::TouchPoint::State arg2 ;
25983
25984   arg1 = (Dali::TouchPoint *)jarg1;
25985   arg2 = (Dali::TouchPoint::State)jarg2;
25986   if (arg1) (arg1)->state = arg2;
25987 }
25988
25989
25990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
25991   int jresult ;
25992   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25993   Dali::TouchPoint::State result;
25994
25995   arg1 = (Dali::TouchPoint *)jarg1;
25996   result = (Dali::TouchPoint::State) ((arg1)->state);
25997   jresult = (int)result;
25998   return jresult;
25999 }
26000
26001
26002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26003   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26004   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26005
26006   arg1 = (Dali::TouchPoint *)jarg1;
26007   arg2 = (Dali::Actor *)jarg2;
26008   if (arg1) (arg1)->hitActor = *arg2;
26009 }
26010
26011
26012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26013   void * jresult ;
26014   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26015   Dali::Actor *result = 0 ;
26016
26017   arg1 = (Dali::TouchPoint *)jarg1;
26018   result = (Dali::Actor *)& ((arg1)->hitActor);
26019   jresult = (void *)result;
26020   return jresult;
26021 }
26022
26023
26024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26025   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26026   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26027
26028   arg1 = (Dali::TouchPoint *)jarg1;
26029   arg2 = (Dali::Vector2 *)jarg2;
26030   if (arg1) (arg1)->local = *arg2;
26031 }
26032
26033
26034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26035   void * jresult ;
26036   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26037   Dali::Vector2 *result = 0 ;
26038
26039   arg1 = (Dali::TouchPoint *)jarg1;
26040   result = (Dali::Vector2 *)& ((arg1)->local);
26041   jresult = (void *)result;
26042   return jresult;
26043 }
26044
26045
26046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26047   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26048   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26049
26050   arg1 = (Dali::TouchPoint *)jarg1;
26051   arg2 = (Dali::Vector2 *)jarg2;
26052   if (arg1) (arg1)->screen = *arg2;
26053 }
26054
26055
26056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26057   void * jresult ;
26058   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26059   Dali::Vector2 *result = 0 ;
26060
26061   arg1 = (Dali::TouchPoint *)jarg1;
26062   result = (Dali::Vector2 *)& ((arg1)->screen);
26063   jresult = (void *)result;
26064   return jresult;
26065 }
26066
26067
26068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26069   void * jresult ;
26070   Dali::TouchData *result = 0 ;
26071
26072   {
26073     try {
26074       result = (Dali::TouchData *)new Dali::TouchData();
26075     } catch (std::out_of_range& e) {
26076       {
26077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26078       };
26079     } catch (std::exception& e) {
26080       {
26081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26082       };
26083     } catch (...) {
26084       {
26085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26086       };
26087     }
26088   }
26089   jresult = (void *)result;
26090   return jresult;
26091 }
26092
26093
26094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26095   void * jresult ;
26096   Dali::TouchData *arg1 = 0 ;
26097   Dali::TouchData *result = 0 ;
26098
26099   arg1 = (Dali::TouchData *)jarg1;
26100   if (!arg1) {
26101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26102     return 0;
26103   }
26104   {
26105     try {
26106       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26107     } catch (std::out_of_range& e) {
26108       {
26109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26110       };
26111     } catch (std::exception& e) {
26112       {
26113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26114       };
26115     } catch (...) {
26116       {
26117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26118       };
26119     }
26120   }
26121   jresult = (void *)result;
26122   return jresult;
26123 }
26124
26125
26126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26127   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26128
26129   arg1 = (Dali::TouchData *)jarg1;
26130   {
26131     try {
26132       delete arg1;
26133     } catch (std::out_of_range& e) {
26134       {
26135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26136       };
26137     } catch (std::exception& e) {
26138       {
26139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26140       };
26141     } catch (...) {
26142       {
26143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26144       };
26145     }
26146   }
26147 }
26148
26149
26150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26151   void * jresult ;
26152   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26153   Dali::TouchData *arg2 = 0 ;
26154   Dali::TouchData *result = 0 ;
26155
26156   arg1 = (Dali::TouchData *)jarg1;
26157   arg2 = (Dali::TouchData *)jarg2;
26158   if (!arg2) {
26159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26160     return 0;
26161   }
26162   {
26163     try {
26164       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26165     } catch (std::out_of_range& e) {
26166       {
26167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26168       };
26169     } catch (std::exception& e) {
26170       {
26171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26172       };
26173     } catch (...) {
26174       {
26175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26176       };
26177     }
26178   }
26179   jresult = (void *)result;
26180   return jresult;
26181 }
26182
26183
26184 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26185   unsigned long jresult ;
26186   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26187   unsigned long result;
26188
26189   arg1 = (Dali::TouchData *)jarg1;
26190   {
26191     try {
26192       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26193     } catch (std::out_of_range& e) {
26194       {
26195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26196       };
26197     } catch (std::exception& e) {
26198       {
26199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26200       };
26201     } catch (...) {
26202       {
26203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26204       };
26205     }
26206   }
26207   jresult = (unsigned long)result;
26208   return jresult;
26209 }
26210
26211
26212 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26213   unsigned long jresult ;
26214   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26215   std::size_t result;
26216
26217   arg1 = (Dali::TouchData *)jarg1;
26218   {
26219     try {
26220       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26221     } catch (std::out_of_range& e) {
26222       {
26223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26224       };
26225     } catch (std::exception& e) {
26226       {
26227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26228       };
26229     } catch (...) {
26230       {
26231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26232       };
26233     }
26234   }
26235   jresult = (unsigned long)result;
26236   return jresult;
26237 }
26238
26239
26240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26241   int jresult ;
26242   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26243   std::size_t arg2 ;
26244   int32_t result;
26245
26246   arg1 = (Dali::TouchData *)jarg1;
26247   arg2 = (std::size_t)jarg2;
26248   {
26249     try {
26250       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26251     } catch (std::out_of_range& e) {
26252       {
26253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26254       };
26255     } catch (std::exception& e) {
26256       {
26257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26258       };
26259     } catch (...) {
26260       {
26261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26262       };
26263     }
26264   }
26265   jresult = result;
26266   return jresult;
26267 }
26268
26269
26270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26271   int jresult ;
26272   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26273   std::size_t arg2 ;
26274   Dali::PointState::Type result;
26275
26276   arg1 = (Dali::TouchData *)jarg1;
26277   arg2 = (std::size_t)jarg2;
26278   {
26279     try {
26280       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26281     } catch (std::out_of_range& e) {
26282       {
26283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26284       };
26285     } catch (std::exception& e) {
26286       {
26287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26288       };
26289     } catch (...) {
26290       {
26291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26292       };
26293     }
26294   }
26295   jresult = (int)result;
26296   return jresult;
26297 }
26298
26299
26300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26301   void * jresult ;
26302   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26303   std::size_t arg2 ;
26304   Dali::Actor result;
26305
26306   arg1 = (Dali::TouchData *)jarg1;
26307   arg2 = (std::size_t)jarg2;
26308   {
26309     try {
26310       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26311     } catch (std::out_of_range& e) {
26312       {
26313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26314       };
26315     } catch (std::exception& e) {
26316       {
26317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26318       };
26319     } catch (...) {
26320       {
26321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26322       };
26323     }
26324   }
26325   jresult = new Dali::Actor((const Dali::Actor &)result);
26326   return jresult;
26327 }
26328
26329
26330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26331   void * jresult ;
26332   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26333   std::size_t arg2 ;
26334   Dali::Vector2 *result = 0 ;
26335
26336   arg1 = (Dali::TouchData *)jarg1;
26337   arg2 = (std::size_t)jarg2;
26338   {
26339     try {
26340       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26341     } catch (std::out_of_range& e) {
26342       {
26343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26344       };
26345     } catch (std::exception& e) {
26346       {
26347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26348       };
26349     } catch (...) {
26350       {
26351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26352       };
26353     }
26354   }
26355   jresult = (void *)result;
26356   return jresult;
26357 }
26358
26359
26360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26361   void * jresult ;
26362   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26363   std::size_t arg2 ;
26364   Dali::Vector2 *result = 0 ;
26365
26366   arg1 = (Dali::TouchData *)jarg1;
26367   arg2 = (std::size_t)jarg2;
26368   {
26369     try {
26370       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26371     } catch (std::out_of_range& e) {
26372       {
26373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26374       };
26375     } catch (std::exception& e) {
26376       {
26377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26378       };
26379     } catch (...) {
26380       {
26381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26382       };
26383     }
26384   }
26385   jresult = (void *)result;
26386   return jresult;
26387 }
26388
26389
26390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26391   float jresult ;
26392   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26393   std::size_t arg2 ;
26394   float result;
26395
26396   arg1 = (Dali::TouchData *)jarg1;
26397   arg2 = (std::size_t)jarg2;
26398   {
26399     try {
26400       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26401     } catch (std::out_of_range& e) {
26402       {
26403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26404       };
26405     } catch (std::exception& e) {
26406       {
26407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26408       };
26409     } catch (...) {
26410       {
26411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26412       };
26413     }
26414   }
26415   jresult = result;
26416   return jresult;
26417 }
26418
26419
26420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26421   void * jresult ;
26422   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26423   std::size_t arg2 ;
26424   Dali::Vector2 *result = 0 ;
26425
26426   arg1 = (Dali::TouchData *)jarg1;
26427   arg2 = (std::size_t)jarg2;
26428   {
26429     try {
26430       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26431     } catch (std::out_of_range& e) {
26432       {
26433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26434       };
26435     } catch (std::exception& e) {
26436       {
26437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26438       };
26439     } catch (...) {
26440       {
26441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26442       };
26443     }
26444   }
26445   jresult = (void *)result;
26446   return jresult;
26447 }
26448
26449
26450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26451   float jresult ;
26452   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26453   std::size_t arg2 ;
26454   float result;
26455
26456   arg1 = (Dali::TouchData *)jarg1;
26457   arg2 = (std::size_t)jarg2;
26458   {
26459     try {
26460       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26461     } catch (std::out_of_range& e) {
26462       {
26463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26464       };
26465     } catch (std::exception& e) {
26466       {
26467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26468       };
26469     } catch (...) {
26470       {
26471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26472       };
26473     }
26474   }
26475   jresult = result;
26476   return jresult;
26477 }
26478
26479
26480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26481   void * jresult ;
26482   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26483   std::size_t arg2 ;
26484   Dali::Degree result;
26485
26486   arg1 = (Dali::TouchData *)jarg1;
26487   arg2 = (std::size_t)jarg2;
26488   {
26489     try {
26490       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26491     } catch (std::out_of_range& e) {
26492       {
26493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26494       };
26495     } catch (std::exception& e) {
26496       {
26497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26498       };
26499     } catch (...) {
26500       {
26501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26502       };
26503     }
26504   }
26505   jresult = new Dali::Degree((const Dali::Degree &)result);
26506   return jresult;
26507 }
26508
26509
26510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26511   void * jresult ;
26512   Dali::GestureDetector *result = 0 ;
26513
26514   {
26515     try {
26516       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26517     } catch (std::out_of_range& e) {
26518       {
26519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26520       };
26521     } catch (std::exception& e) {
26522       {
26523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26524       };
26525     } catch (...) {
26526       {
26527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26528       };
26529     }
26530   }
26531   jresult = (void *)result;
26532   return jresult;
26533 }
26534
26535
26536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26537   void * jresult ;
26538   Dali::BaseHandle arg1 ;
26539   Dali::BaseHandle *argp1 ;
26540   Dali::GestureDetector result;
26541
26542   argp1 = (Dali::BaseHandle *)jarg1;
26543   if (!argp1) {
26544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26545     return 0;
26546   }
26547   arg1 = *argp1;
26548   {
26549     try {
26550       result = Dali::GestureDetector::DownCast(arg1);
26551     } catch (std::out_of_range& e) {
26552       {
26553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26554       };
26555     } catch (std::exception& e) {
26556       {
26557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26558       };
26559     } catch (...) {
26560       {
26561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26562       };
26563     }
26564   }
26565   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26566   return jresult;
26567 }
26568
26569
26570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26571   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26572
26573   arg1 = (Dali::GestureDetector *)jarg1;
26574   {
26575     try {
26576       delete arg1;
26577     } catch (std::out_of_range& e) {
26578       {
26579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26580       };
26581     } catch (std::exception& e) {
26582       {
26583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26584       };
26585     } catch (...) {
26586       {
26587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26588       };
26589     }
26590   }
26591 }
26592
26593
26594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26595   void * jresult ;
26596   Dali::GestureDetector *arg1 = 0 ;
26597   Dali::GestureDetector *result = 0 ;
26598
26599   arg1 = (Dali::GestureDetector *)jarg1;
26600   if (!arg1) {
26601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26602     return 0;
26603   }
26604   {
26605     try {
26606       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26607     } catch (std::out_of_range& e) {
26608       {
26609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26610       };
26611     } catch (std::exception& e) {
26612       {
26613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26614       };
26615     } catch (...) {
26616       {
26617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26618       };
26619     }
26620   }
26621   jresult = (void *)result;
26622   return jresult;
26623 }
26624
26625
26626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26627   void * jresult ;
26628   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26629   Dali::GestureDetector *arg2 = 0 ;
26630   Dali::GestureDetector *result = 0 ;
26631
26632   arg1 = (Dali::GestureDetector *)jarg1;
26633   arg2 = (Dali::GestureDetector *)jarg2;
26634   if (!arg2) {
26635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26636     return 0;
26637   }
26638   {
26639     try {
26640       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26641     } catch (std::out_of_range& e) {
26642       {
26643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26644       };
26645     } catch (std::exception& e) {
26646       {
26647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26648       };
26649     } catch (...) {
26650       {
26651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26652       };
26653     }
26654   }
26655   jresult = (void *)result;
26656   return jresult;
26657 }
26658
26659
26660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26661   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26662   Dali::Actor arg2 ;
26663   Dali::Actor *argp2 ;
26664
26665   arg1 = (Dali::GestureDetector *)jarg1;
26666   argp2 = (Dali::Actor *)jarg2;
26667   if (!argp2) {
26668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26669     return ;
26670   }
26671   arg2 = *argp2;
26672   {
26673     try {
26674       (arg1)->Attach(arg2);
26675     } catch (std::out_of_range& e) {
26676       {
26677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26678       };
26679     } catch (std::exception& e) {
26680       {
26681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26682       };
26683     } catch (...) {
26684       {
26685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26686       };
26687     }
26688   }
26689 }
26690
26691
26692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26693   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26694   Dali::Actor arg2 ;
26695   Dali::Actor *argp2 ;
26696
26697   arg1 = (Dali::GestureDetector *)jarg1;
26698   argp2 = (Dali::Actor *)jarg2;
26699   if (!argp2) {
26700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26701     return ;
26702   }
26703   arg2 = *argp2;
26704   {
26705     try {
26706       (arg1)->Detach(arg2);
26707     } catch (std::out_of_range& e) {
26708       {
26709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26710       };
26711     } catch (std::exception& e) {
26712       {
26713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26714       };
26715     } catch (...) {
26716       {
26717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26718       };
26719     }
26720   }
26721 }
26722
26723
26724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26725   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26726
26727   arg1 = (Dali::GestureDetector *)jarg1;
26728   {
26729     try {
26730       (arg1)->DetachAll();
26731     } catch (std::out_of_range& e) {
26732       {
26733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26734       };
26735     } catch (std::exception& e) {
26736       {
26737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26738       };
26739     } catch (...) {
26740       {
26741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26742       };
26743     }
26744   }
26745 }
26746
26747
26748 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26749   unsigned long jresult ;
26750   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26751   size_t result;
26752
26753   arg1 = (Dali::GestureDetector *)jarg1;
26754   {
26755     try {
26756       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26757     } catch (std::out_of_range& e) {
26758       {
26759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26760       };
26761     } catch (std::exception& e) {
26762       {
26763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26764       };
26765     } catch (...) {
26766       {
26767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26768       };
26769     }
26770   }
26771   jresult = (unsigned long)result;
26772   return jresult;
26773 }
26774
26775
26776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26777   void * jresult ;
26778   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26779   size_t arg2 ;
26780   Dali::Actor result;
26781
26782   arg1 = (Dali::GestureDetector *)jarg1;
26783   arg2 = (size_t)jarg2;
26784   {
26785     try {
26786       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26787     } catch (std::out_of_range& e) {
26788       {
26789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26790       };
26791     } catch (std::exception& e) {
26792       {
26793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26794       };
26795     } catch (...) {
26796       {
26797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26798       };
26799     }
26800   }
26801   jresult = new Dali::Actor((const Dali::Actor &)result);
26802   return jresult;
26803 }
26804
26805
26806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26807   void * jresult ;
26808   Dali::Gesture *arg1 = 0 ;
26809   Dali::Gesture *result = 0 ;
26810
26811   arg1 = (Dali::Gesture *)jarg1;
26812   if (!arg1) {
26813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26814     return 0;
26815   }
26816   {
26817     try {
26818       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26819     } catch (std::out_of_range& e) {
26820       {
26821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26822       };
26823     } catch (std::exception& e) {
26824       {
26825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26826       };
26827     } catch (...) {
26828       {
26829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26830       };
26831     }
26832   }
26833   jresult = (void *)result;
26834   return jresult;
26835 }
26836
26837
26838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26839   void * jresult ;
26840   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26841   Dali::Gesture *arg2 = 0 ;
26842   Dali::Gesture *result = 0 ;
26843
26844   arg1 = (Dali::Gesture *)jarg1;
26845   arg2 = (Dali::Gesture *)jarg2;
26846   if (!arg2) {
26847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26848     return 0;
26849   }
26850   {
26851     try {
26852       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26853     } catch (std::out_of_range& e) {
26854       {
26855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26856       };
26857     } catch (std::exception& e) {
26858       {
26859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26860       };
26861     } catch (...) {
26862       {
26863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26864       };
26865     }
26866   }
26867   jresult = (void *)result;
26868   return jresult;
26869 }
26870
26871
26872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26873   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26874
26875   arg1 = (Dali::Gesture *)jarg1;
26876   {
26877     try {
26878       delete arg1;
26879     } catch (std::out_of_range& e) {
26880       {
26881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26882       };
26883     } catch (std::exception& e) {
26884       {
26885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26886       };
26887     } catch (...) {
26888       {
26889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26890       };
26891     }
26892   }
26893 }
26894
26895
26896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26897   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26898   Dali::Gesture::Type arg2 ;
26899
26900   arg1 = (Dali::Gesture *)jarg1;
26901   arg2 = (Dali::Gesture::Type)jarg2;
26902   if (arg1) (arg1)->type = arg2;
26903 }
26904
26905
26906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26907   int jresult ;
26908   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26909   Dali::Gesture::Type result;
26910
26911   arg1 = (Dali::Gesture *)jarg1;
26912   result = (Dali::Gesture::Type) ((arg1)->type);
26913   jresult = (int)result;
26914   return jresult;
26915 }
26916
26917
26918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26919   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26920   Dali::Gesture::State arg2 ;
26921
26922   arg1 = (Dali::Gesture *)jarg1;
26923   arg2 = (Dali::Gesture::State)jarg2;
26924   if (arg1) (arg1)->state = arg2;
26925 }
26926
26927
26928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26929   int jresult ;
26930   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26931   Dali::Gesture::State result;
26932
26933   arg1 = (Dali::Gesture *)jarg1;
26934   result = (Dali::Gesture::State) ((arg1)->state);
26935   jresult = (int)result;
26936   return jresult;
26937 }
26938
26939
26940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26941   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26942   unsigned int arg2 ;
26943
26944   arg1 = (Dali::Gesture *)jarg1;
26945   arg2 = (unsigned int)jarg2;
26946   if (arg1) (arg1)->time = arg2;
26947 }
26948
26949
26950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
26951   unsigned int jresult ;
26952   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26953   unsigned int result;
26954
26955   arg1 = (Dali::Gesture *)jarg1;
26956   result = (unsigned int) ((arg1)->time);
26957   jresult = result;
26958   return jresult;
26959 }
26960
26961
26962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
26963   void * jresult ;
26964   Dali::HoverEvent *result = 0 ;
26965
26966   {
26967     try {
26968       result = (Dali::HoverEvent *)new Dali::HoverEvent();
26969     } catch (std::out_of_range& e) {
26970       {
26971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26972       };
26973     } catch (std::exception& e) {
26974       {
26975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26976       };
26977     } catch (...) {
26978       {
26979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26980       };
26981     }
26982   }
26983   jresult = (void *)result;
26984   return jresult;
26985 }
26986
26987
26988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
26989   void * jresult ;
26990   unsigned long arg1 ;
26991   Dali::HoverEvent *result = 0 ;
26992
26993   arg1 = (unsigned long)jarg1;
26994   {
26995     try {
26996       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
26997     } catch (std::out_of_range& e) {
26998       {
26999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27000       };
27001     } catch (std::exception& e) {
27002       {
27003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27004       };
27005     } catch (...) {
27006       {
27007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27008       };
27009     }
27010   }
27011   jresult = (void *)result;
27012   return jresult;
27013 }
27014
27015
27016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27017   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27018
27019   arg1 = (Dali::HoverEvent *)jarg1;
27020   {
27021     try {
27022       delete arg1;
27023     } catch (std::out_of_range& e) {
27024       {
27025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27026       };
27027     } catch (std::exception& e) {
27028       {
27029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27030       };
27031     } catch (...) {
27032       {
27033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27034       };
27035     }
27036   }
27037 }
27038
27039
27040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27041   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27042   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27043
27044   arg1 = (Dali::HoverEvent *)jarg1;
27045   arg2 = (Dali::TouchPointContainer *)jarg2;
27046   if (arg1) (arg1)->points = *arg2;
27047 }
27048
27049
27050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27051   void * jresult ;
27052   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27053   Dali::TouchPointContainer *result = 0 ;
27054
27055   arg1 = (Dali::HoverEvent *)jarg1;
27056   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27057   jresult = (void *)result;
27058   return jresult;
27059 }
27060
27061
27062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27063   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27064   unsigned long arg2 ;
27065
27066   arg1 = (Dali::HoverEvent *)jarg1;
27067   arg2 = (unsigned long)jarg2;
27068   if (arg1) (arg1)->time = arg2;
27069 }
27070
27071
27072 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27073   unsigned long jresult ;
27074   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27075   unsigned long result;
27076
27077   arg1 = (Dali::HoverEvent *)jarg1;
27078   result = (unsigned long) ((arg1)->time);
27079   jresult = (unsigned long)result;
27080   return jresult;
27081 }
27082
27083
27084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27085   unsigned int jresult ;
27086   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27087   unsigned int result;
27088
27089   arg1 = (Dali::HoverEvent *)jarg1;
27090   {
27091     try {
27092       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27093     } catch (std::out_of_range& e) {
27094       {
27095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27096       };
27097     } catch (std::exception& e) {
27098       {
27099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27100       };
27101     } catch (...) {
27102       {
27103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27104       };
27105     }
27106   }
27107   jresult = result;
27108   return jresult;
27109 }
27110
27111
27112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27113   void * jresult ;
27114   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27115   unsigned int arg2 ;
27116   Dali::TouchPoint *result = 0 ;
27117
27118   arg1 = (Dali::HoverEvent *)jarg1;
27119   arg2 = (unsigned int)jarg2;
27120   {
27121     try {
27122       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27123     } catch (std::out_of_range& e) {
27124       {
27125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27126       };
27127     } catch (std::exception& e) {
27128       {
27129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27130       };
27131     } catch (...) {
27132       {
27133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27134       };
27135     }
27136   }
27137   jresult = (void *)result;
27138   return jresult;
27139 }
27140
27141
27142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27143   void * jresult ;
27144   Dali::KeyEvent *result = 0 ;
27145
27146   {
27147     try {
27148       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27149     } catch (std::out_of_range& e) {
27150       {
27151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27152       };
27153     } catch (std::exception& e) {
27154       {
27155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27156       };
27157     } catch (...) {
27158       {
27159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27160       };
27161     }
27162   }
27163   jresult = (void *)result;
27164   return jresult;
27165 }
27166
27167
27168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27169   void * jresult ;
27170   std::string *arg1 = 0 ;
27171   std::string *arg2 = 0 ;
27172   int arg3 ;
27173   int arg4 ;
27174   unsigned long arg5 ;
27175   Dali::KeyEvent::State *arg6 = 0 ;
27176   Dali::KeyEvent::State temp6 ;
27177   Dali::KeyEvent *result = 0 ;
27178
27179   if (!jarg1) {
27180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27181     return 0;
27182   }
27183   std::string arg1_str(jarg1);
27184   arg1 = &arg1_str;
27185   if (!jarg2) {
27186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27187     return 0;
27188   }
27189   std::string arg2_str(jarg2);
27190   arg2 = &arg2_str;
27191   arg3 = (int)jarg3;
27192   arg4 = (int)jarg4;
27193   arg5 = (unsigned long)jarg5;
27194   temp6 = (Dali::KeyEvent::State)jarg6;
27195   arg6 = &temp6;
27196   {
27197     try {
27198       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27199     } catch (std::out_of_range& e) {
27200       {
27201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27202       };
27203     } catch (std::exception& e) {
27204       {
27205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27206       };
27207     } catch (...) {
27208       {
27209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27210       };
27211     }
27212   }
27213   jresult = (void *)result;
27214
27215   //argout typemap for const std::string&
27216
27217
27218   //argout typemap for const std::string&
27219
27220   return jresult;
27221 }
27222
27223
27224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27225   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27226
27227   arg1 = (Dali::KeyEvent *)jarg1;
27228   {
27229     try {
27230       delete arg1;
27231     } catch (std::out_of_range& e) {
27232       {
27233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27234       };
27235     } catch (std::exception& e) {
27236       {
27237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27238       };
27239     } catch (...) {
27240       {
27241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27242       };
27243     }
27244   }
27245 }
27246
27247
27248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27249   unsigned int jresult ;
27250   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27251   bool result;
27252
27253   arg1 = (Dali::KeyEvent *)jarg1;
27254   {
27255     try {
27256       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27257     } catch (std::out_of_range& e) {
27258       {
27259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27260       };
27261     } catch (std::exception& e) {
27262       {
27263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27264       };
27265     } catch (...) {
27266       {
27267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27268       };
27269     }
27270   }
27271   jresult = result;
27272   return jresult;
27273 }
27274
27275
27276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27277   unsigned int jresult ;
27278   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27279   bool result;
27280
27281   arg1 = (Dali::KeyEvent *)jarg1;
27282   {
27283     try {
27284       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27285     } catch (std::out_of_range& e) {
27286       {
27287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27288       };
27289     } catch (std::exception& e) {
27290       {
27291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27292       };
27293     } catch (...) {
27294       {
27295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27296       };
27297     }
27298   }
27299   jresult = result;
27300   return jresult;
27301 }
27302
27303
27304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27305   unsigned int jresult ;
27306   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27307   bool result;
27308
27309   arg1 = (Dali::KeyEvent *)jarg1;
27310   {
27311     try {
27312       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27313     } catch (std::out_of_range& e) {
27314       {
27315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27316       };
27317     } catch (std::exception& e) {
27318       {
27319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27320       };
27321     } catch (...) {
27322       {
27323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27324       };
27325     }
27326   }
27327   jresult = result;
27328   return jresult;
27329 }
27330
27331
27332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27333   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27334   std::string *arg2 = 0 ;
27335
27336   arg1 = (Dali::KeyEvent *)jarg1;
27337   if (!jarg2) {
27338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27339     return ;
27340   }
27341   std::string arg2_str(jarg2);
27342   arg2 = &arg2_str;
27343   if (arg1) (arg1)->keyPressedName = *arg2;
27344
27345   //argout typemap for const std::string&
27346
27347 }
27348
27349
27350 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27351   char * jresult ;
27352   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27353   std::string *result = 0 ;
27354
27355   arg1 = (Dali::KeyEvent *)jarg1;
27356   result = (std::string *) & ((arg1)->keyPressedName);
27357   jresult = SWIG_csharp_string_callback(result->c_str());
27358   return jresult;
27359 }
27360
27361
27362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27363   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27364   std::string *arg2 = 0 ;
27365
27366   arg1 = (Dali::KeyEvent *)jarg1;
27367   if (!jarg2) {
27368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27369     return ;
27370   }
27371   std::string arg2_str(jarg2);
27372   arg2 = &arg2_str;
27373   if (arg1) (arg1)->keyPressed = *arg2;
27374
27375   //argout typemap for const std::string&
27376
27377 }
27378
27379
27380 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27381   char * jresult ;
27382   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27383   std::string *result = 0 ;
27384
27385   arg1 = (Dali::KeyEvent *)jarg1;
27386   result = (std::string *) & ((arg1)->keyPressed);
27387   jresult = SWIG_csharp_string_callback(result->c_str());
27388   return jresult;
27389 }
27390
27391
27392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27393   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27394   int arg2 ;
27395
27396   arg1 = (Dali::KeyEvent *)jarg1;
27397   arg2 = (int)jarg2;
27398   if (arg1) (arg1)->keyCode = arg2;
27399 }
27400
27401
27402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27403   int jresult ;
27404   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27405   int result;
27406
27407   arg1 = (Dali::KeyEvent *)jarg1;
27408   result = (int) ((arg1)->keyCode);
27409   jresult = result;
27410   return jresult;
27411 }
27412
27413
27414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27415   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27416   int arg2 ;
27417
27418   arg1 = (Dali::KeyEvent *)jarg1;
27419   arg2 = (int)jarg2;
27420   if (arg1) (arg1)->keyModifier = arg2;
27421 }
27422
27423
27424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27425   int jresult ;
27426   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27427   int result;
27428
27429   arg1 = (Dali::KeyEvent *)jarg1;
27430   result = (int) ((arg1)->keyModifier);
27431   jresult = result;
27432   return jresult;
27433 }
27434
27435
27436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27437   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27438   unsigned long arg2 ;
27439
27440   arg1 = (Dali::KeyEvent *)jarg1;
27441   arg2 = (unsigned long)jarg2;
27442   if (arg1) (arg1)->time = arg2;
27443 }
27444
27445
27446 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27447   unsigned long jresult ;
27448   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27449   unsigned long result;
27450
27451   arg1 = (Dali::KeyEvent *)jarg1;
27452   result = (unsigned long) ((arg1)->time);
27453   jresult = (unsigned long)result;
27454   return jresult;
27455 }
27456
27457
27458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27459   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27460   Dali::KeyEvent::State arg2 ;
27461
27462   arg1 = (Dali::KeyEvent *)jarg1;
27463   arg2 = (Dali::KeyEvent::State)jarg2;
27464   if (arg1) (arg1)->state = arg2;
27465 }
27466
27467
27468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27469   int jresult ;
27470   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27471   Dali::KeyEvent::State result;
27472
27473   arg1 = (Dali::KeyEvent *)jarg1;
27474   result = (Dali::KeyEvent::State) ((arg1)->state);
27475   jresult = (int)result;
27476   return jresult;
27477 }
27478
27479
27480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27481   void * jresult ;
27482   Dali::LongPressGestureDetector *result = 0 ;
27483
27484   {
27485     try {
27486       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27487     } catch (std::out_of_range& e) {
27488       {
27489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27490       };
27491     } catch (std::exception& e) {
27492       {
27493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27494       };
27495     } catch (...) {
27496       {
27497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27498       };
27499     }
27500   }
27501   jresult = (void *)result;
27502   return jresult;
27503 }
27504
27505
27506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27507   void * jresult ;
27508   Dali::LongPressGestureDetector result;
27509
27510   {
27511     try {
27512       result = Dali::LongPressGestureDetector::New();
27513     } catch (std::out_of_range& e) {
27514       {
27515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27516       };
27517     } catch (std::exception& e) {
27518       {
27519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27520       };
27521     } catch (...) {
27522       {
27523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27524       };
27525     }
27526   }
27527   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27528   return jresult;
27529 }
27530
27531
27532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27533   void * jresult ;
27534   unsigned int arg1 ;
27535   Dali::LongPressGestureDetector result;
27536
27537   arg1 = (unsigned int)jarg1;
27538   {
27539     try {
27540       result = Dali::LongPressGestureDetector::New(arg1);
27541     } catch (std::out_of_range& e) {
27542       {
27543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27544       };
27545     } catch (std::exception& e) {
27546       {
27547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27548       };
27549     } catch (...) {
27550       {
27551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27552       };
27553     }
27554   }
27555   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27556   return jresult;
27557 }
27558
27559
27560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27561   void * jresult ;
27562   unsigned int arg1 ;
27563   unsigned int arg2 ;
27564   Dali::LongPressGestureDetector result;
27565
27566   arg1 = (unsigned int)jarg1;
27567   arg2 = (unsigned int)jarg2;
27568   {
27569     try {
27570       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27571     } catch (std::out_of_range& e) {
27572       {
27573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27574       };
27575     } catch (std::exception& e) {
27576       {
27577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27578       };
27579     } catch (...) {
27580       {
27581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27582       };
27583     }
27584   }
27585   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27586   return jresult;
27587 }
27588
27589
27590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27591   void * jresult ;
27592   Dali::BaseHandle arg1 ;
27593   Dali::BaseHandle *argp1 ;
27594   Dali::LongPressGestureDetector result;
27595
27596   argp1 = (Dali::BaseHandle *)jarg1;
27597   if (!argp1) {
27598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27599     return 0;
27600   }
27601   arg1 = *argp1;
27602   {
27603     try {
27604       result = Dali::LongPressGestureDetector::DownCast(arg1);
27605     } catch (std::out_of_range& e) {
27606       {
27607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27608       };
27609     } catch (std::exception& e) {
27610       {
27611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27612       };
27613     } catch (...) {
27614       {
27615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27616       };
27617     }
27618   }
27619   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27620   return jresult;
27621 }
27622
27623
27624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27625   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27626
27627   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27628   {
27629     try {
27630       delete arg1;
27631     } catch (std::out_of_range& e) {
27632       {
27633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27634       };
27635     } catch (std::exception& e) {
27636       {
27637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27638       };
27639     } catch (...) {
27640       {
27641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27642       };
27643     }
27644   }
27645 }
27646
27647
27648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27649   void * jresult ;
27650   Dali::LongPressGestureDetector *arg1 = 0 ;
27651   Dali::LongPressGestureDetector *result = 0 ;
27652
27653   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27654   if (!arg1) {
27655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27656     return 0;
27657   }
27658   {
27659     try {
27660       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27661     } catch (std::out_of_range& e) {
27662       {
27663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27664       };
27665     } catch (std::exception& e) {
27666       {
27667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27668       };
27669     } catch (...) {
27670       {
27671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27672       };
27673     }
27674   }
27675   jresult = (void *)result;
27676   return jresult;
27677 }
27678
27679
27680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27681   void * jresult ;
27682   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27683   Dali::LongPressGestureDetector *arg2 = 0 ;
27684   Dali::LongPressGestureDetector *result = 0 ;
27685
27686   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27687   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27688   if (!arg2) {
27689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27690     return 0;
27691   }
27692   {
27693     try {
27694       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27695     } catch (std::out_of_range& e) {
27696       {
27697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27698       };
27699     } catch (std::exception& e) {
27700       {
27701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27702       };
27703     } catch (...) {
27704       {
27705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27706       };
27707     }
27708   }
27709   jresult = (void *)result;
27710   return jresult;
27711 }
27712
27713
27714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27715   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27716   unsigned int arg2 ;
27717
27718   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27719   arg2 = (unsigned int)jarg2;
27720   {
27721     try {
27722       (arg1)->SetTouchesRequired(arg2);
27723     } catch (std::out_of_range& e) {
27724       {
27725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27726       };
27727     } catch (std::exception& e) {
27728       {
27729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27730       };
27731     } catch (...) {
27732       {
27733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27734       };
27735     }
27736   }
27737 }
27738
27739
27740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27741   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27742   unsigned int arg2 ;
27743   unsigned int arg3 ;
27744
27745   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27746   arg2 = (unsigned int)jarg2;
27747   arg3 = (unsigned int)jarg3;
27748   {
27749     try {
27750       (arg1)->SetTouchesRequired(arg2,arg3);
27751     } catch (std::out_of_range& e) {
27752       {
27753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27754       };
27755     } catch (std::exception& e) {
27756       {
27757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27758       };
27759     } catch (...) {
27760       {
27761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27762       };
27763     }
27764   }
27765 }
27766
27767
27768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27769   unsigned int jresult ;
27770   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27771   unsigned int result;
27772
27773   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27774   {
27775     try {
27776       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27777     } catch (std::out_of_range& e) {
27778       {
27779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27780       };
27781     } catch (std::exception& e) {
27782       {
27783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27784       };
27785     } catch (...) {
27786       {
27787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27788       };
27789     }
27790   }
27791   jresult = result;
27792   return jresult;
27793 }
27794
27795
27796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27797   unsigned int jresult ;
27798   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27799   unsigned int result;
27800
27801   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27802   {
27803     try {
27804       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27805     } catch (std::out_of_range& e) {
27806       {
27807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27808       };
27809     } catch (std::exception& e) {
27810       {
27811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27812       };
27813     } catch (...) {
27814       {
27815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27816       };
27817     }
27818   }
27819   jresult = result;
27820   return jresult;
27821 }
27822
27823
27824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27825   void * jresult ;
27826   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27827   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27828
27829   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27830   {
27831     try {
27832       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27833     } catch (std::out_of_range& e) {
27834       {
27835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27836       };
27837     } catch (std::exception& e) {
27838       {
27839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27840       };
27841     } catch (...) {
27842       {
27843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27844       };
27845     }
27846   }
27847   jresult = (void *)result;
27848   return jresult;
27849 }
27850
27851
27852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27853   void * jresult ;
27854   Dali::Gesture::State arg1 ;
27855   Dali::LongPressGesture *result = 0 ;
27856
27857   arg1 = (Dali::Gesture::State)jarg1;
27858   {
27859     try {
27860       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27861     } catch (std::out_of_range& e) {
27862       {
27863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27864       };
27865     } catch (std::exception& e) {
27866       {
27867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27868       };
27869     } catch (...) {
27870       {
27871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27872       };
27873     }
27874   }
27875   jresult = (void *)result;
27876   return jresult;
27877 }
27878
27879
27880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27881   void * jresult ;
27882   Dali::LongPressGesture *arg1 = 0 ;
27883   Dali::LongPressGesture *result = 0 ;
27884
27885   arg1 = (Dali::LongPressGesture *)jarg1;
27886   if (!arg1) {
27887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27888     return 0;
27889   }
27890   {
27891     try {
27892       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27893     } catch (std::out_of_range& e) {
27894       {
27895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27896       };
27897     } catch (std::exception& e) {
27898       {
27899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27900       };
27901     } catch (...) {
27902       {
27903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27904       };
27905     }
27906   }
27907   jresult = (void *)result;
27908   return jresult;
27909 }
27910
27911
27912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27913   void * jresult ;
27914   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27915   Dali::LongPressGesture *arg2 = 0 ;
27916   Dali::LongPressGesture *result = 0 ;
27917
27918   arg1 = (Dali::LongPressGesture *)jarg1;
27919   arg2 = (Dali::LongPressGesture *)jarg2;
27920   if (!arg2) {
27921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27922     return 0;
27923   }
27924   {
27925     try {
27926       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27927     } catch (std::out_of_range& e) {
27928       {
27929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27930       };
27931     } catch (std::exception& e) {
27932       {
27933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27934       };
27935     } catch (...) {
27936       {
27937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27938       };
27939     }
27940   }
27941   jresult = (void *)result;
27942   return jresult;
27943 }
27944
27945
27946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
27947   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27948
27949   arg1 = (Dali::LongPressGesture *)jarg1;
27950   {
27951     try {
27952       delete arg1;
27953     } catch (std::out_of_range& e) {
27954       {
27955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27956       };
27957     } catch (std::exception& e) {
27958       {
27959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27960       };
27961     } catch (...) {
27962       {
27963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27964       };
27965     }
27966   }
27967 }
27968
27969
27970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
27971   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27972   unsigned int arg2 ;
27973
27974   arg1 = (Dali::LongPressGesture *)jarg1;
27975   arg2 = (unsigned int)jarg2;
27976   if (arg1) (arg1)->numberOfTouches = arg2;
27977 }
27978
27979
27980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
27981   unsigned int jresult ;
27982   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27983   unsigned int result;
27984
27985   arg1 = (Dali::LongPressGesture *)jarg1;
27986   result = (unsigned int) ((arg1)->numberOfTouches);
27987   jresult = result;
27988   return jresult;
27989 }
27990
27991
27992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
27993   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27994   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
27995
27996   arg1 = (Dali::LongPressGesture *)jarg1;
27997   arg2 = (Dali::Vector2 *)jarg2;
27998   if (arg1) (arg1)->screenPoint = *arg2;
27999 }
28000
28001
28002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28003   void * jresult ;
28004   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28005   Dali::Vector2 *result = 0 ;
28006
28007   arg1 = (Dali::LongPressGesture *)jarg1;
28008   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28009   jresult = (void *)result;
28010   return jresult;
28011 }
28012
28013
28014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28015   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28016   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28017
28018   arg1 = (Dali::LongPressGesture *)jarg1;
28019   arg2 = (Dali::Vector2 *)jarg2;
28020   if (arg1) (arg1)->localPoint = *arg2;
28021 }
28022
28023
28024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28025   void * jresult ;
28026   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28027   Dali::Vector2 *result = 0 ;
28028
28029   arg1 = (Dali::LongPressGesture *)jarg1;
28030   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28031   jresult = (void *)result;
28032   return jresult;
28033 }
28034
28035
28036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28037   void * jresult ;
28038   Dali::WheelEvent *result = 0 ;
28039
28040   {
28041     try {
28042       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28043     } catch (std::out_of_range& e) {
28044       {
28045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28046       };
28047     } catch (std::exception& e) {
28048       {
28049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28050       };
28051     } catch (...) {
28052       {
28053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28054       };
28055     }
28056   }
28057   jresult = (void *)result;
28058   return jresult;
28059 }
28060
28061
28062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28063   void * jresult ;
28064   Dali::WheelEvent::Type arg1 ;
28065   int arg2 ;
28066   unsigned int arg3 ;
28067   Dali::Vector2 arg4 ;
28068   int arg5 ;
28069   unsigned int arg6 ;
28070   Dali::Vector2 *argp4 ;
28071   Dali::WheelEvent *result = 0 ;
28072
28073   arg1 = (Dali::WheelEvent::Type)jarg1;
28074   arg2 = (int)jarg2;
28075   arg3 = (unsigned int)jarg3;
28076   argp4 = (Dali::Vector2 *)jarg4;
28077   if (!argp4) {
28078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28079     return 0;
28080   }
28081   arg4 = *argp4;
28082   arg5 = (int)jarg5;
28083   arg6 = (unsigned int)jarg6;
28084   {
28085     try {
28086       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28087     } catch (std::out_of_range& e) {
28088       {
28089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28090       };
28091     } catch (std::exception& e) {
28092       {
28093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28094       };
28095     } catch (...) {
28096       {
28097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28098       };
28099     }
28100   }
28101   jresult = (void *)result;
28102   return jresult;
28103 }
28104
28105
28106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28107   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28108
28109   arg1 = (Dali::WheelEvent *)jarg1;
28110   {
28111     try {
28112       delete arg1;
28113     } catch (std::out_of_range& e) {
28114       {
28115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28116       };
28117     } catch (std::exception& e) {
28118       {
28119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28120       };
28121     } catch (...) {
28122       {
28123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28124       };
28125     }
28126   }
28127 }
28128
28129
28130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28131   unsigned int jresult ;
28132   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28133   bool result;
28134
28135   arg1 = (Dali::WheelEvent *)jarg1;
28136   {
28137     try {
28138       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28139     } catch (std::out_of_range& e) {
28140       {
28141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28142       };
28143     } catch (std::exception& e) {
28144       {
28145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28146       };
28147     } catch (...) {
28148       {
28149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28150       };
28151     }
28152   }
28153   jresult = result;
28154   return jresult;
28155 }
28156
28157
28158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28159   unsigned int jresult ;
28160   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28161   bool result;
28162
28163   arg1 = (Dali::WheelEvent *)jarg1;
28164   {
28165     try {
28166       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28167     } catch (std::out_of_range& e) {
28168       {
28169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28170       };
28171     } catch (std::exception& e) {
28172       {
28173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28174       };
28175     } catch (...) {
28176       {
28177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28178       };
28179     }
28180   }
28181   jresult = result;
28182   return jresult;
28183 }
28184
28185
28186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28187   unsigned int jresult ;
28188   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28189   bool result;
28190
28191   arg1 = (Dali::WheelEvent *)jarg1;
28192   {
28193     try {
28194       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28195     } catch (std::out_of_range& e) {
28196       {
28197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28198       };
28199     } catch (std::exception& e) {
28200       {
28201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28202       };
28203     } catch (...) {
28204       {
28205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28206       };
28207     }
28208   }
28209   jresult = result;
28210   return jresult;
28211 }
28212
28213
28214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28215   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28216   Dali::WheelEvent::Type arg2 ;
28217
28218   arg1 = (Dali::WheelEvent *)jarg1;
28219   arg2 = (Dali::WheelEvent::Type)jarg2;
28220   if (arg1) (arg1)->type = arg2;
28221 }
28222
28223
28224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28225   int jresult ;
28226   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28227   Dali::WheelEvent::Type result;
28228
28229   arg1 = (Dali::WheelEvent *)jarg1;
28230   result = (Dali::WheelEvent::Type) ((arg1)->type);
28231   jresult = (int)result;
28232   return jresult;
28233 }
28234
28235
28236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28237   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28238   int arg2 ;
28239
28240   arg1 = (Dali::WheelEvent *)jarg1;
28241   arg2 = (int)jarg2;
28242   if (arg1) (arg1)->direction = arg2;
28243 }
28244
28245
28246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28247   int jresult ;
28248   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28249   int result;
28250
28251   arg1 = (Dali::WheelEvent *)jarg1;
28252   result = (int) ((arg1)->direction);
28253   jresult = result;
28254   return jresult;
28255 }
28256
28257
28258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28259   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28260   unsigned int arg2 ;
28261
28262   arg1 = (Dali::WheelEvent *)jarg1;
28263   arg2 = (unsigned int)jarg2;
28264   if (arg1) (arg1)->modifiers = arg2;
28265 }
28266
28267
28268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28269   unsigned int jresult ;
28270   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28271   unsigned int result;
28272
28273   arg1 = (Dali::WheelEvent *)jarg1;
28274   result = (unsigned int) ((arg1)->modifiers);
28275   jresult = result;
28276   return jresult;
28277 }
28278
28279
28280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28281   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28282   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28283
28284   arg1 = (Dali::WheelEvent *)jarg1;
28285   arg2 = (Dali::Vector2 *)jarg2;
28286   if (arg1) (arg1)->point = *arg2;
28287 }
28288
28289
28290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28291   void * jresult ;
28292   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28293   Dali::Vector2 *result = 0 ;
28294
28295   arg1 = (Dali::WheelEvent *)jarg1;
28296   result = (Dali::Vector2 *)& ((arg1)->point);
28297   jresult = (void *)result;
28298   return jresult;
28299 }
28300
28301
28302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28303   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28304   int arg2 ;
28305
28306   arg1 = (Dali::WheelEvent *)jarg1;
28307   arg2 = (int)jarg2;
28308   if (arg1) (arg1)->z = arg2;
28309 }
28310
28311
28312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28313   int jresult ;
28314   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28315   int result;
28316
28317   arg1 = (Dali::WheelEvent *)jarg1;
28318   result = (int) ((arg1)->z);
28319   jresult = result;
28320   return jresult;
28321 }
28322
28323
28324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28325   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28326   unsigned int arg2 ;
28327
28328   arg1 = (Dali::WheelEvent *)jarg1;
28329   arg2 = (unsigned int)jarg2;
28330   if (arg1) (arg1)->timeStamp = arg2;
28331 }
28332
28333
28334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28335   unsigned int jresult ;
28336   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28337   unsigned int result;
28338
28339   arg1 = (Dali::WheelEvent *)jarg1;
28340   result = (unsigned int) ((arg1)->timeStamp);
28341   jresult = result;
28342   return jresult;
28343 }
28344
28345
28346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28347   int jresult ;
28348   int result;
28349
28350   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28351   jresult = (int)result;
28352   return jresult;
28353 }
28354
28355
28356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28357   int jresult ;
28358   int result;
28359
28360   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28361   jresult = (int)result;
28362   return jresult;
28363 }
28364
28365
28366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28367   int jresult ;
28368   int result;
28369
28370   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28371   jresult = (int)result;
28372   return jresult;
28373 }
28374
28375
28376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28377   int jresult ;
28378   int result;
28379
28380   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28381   jresult = (int)result;
28382   return jresult;
28383 }
28384
28385
28386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28387   int jresult ;
28388   int result;
28389
28390   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28391   jresult = (int)result;
28392   return jresult;
28393 }
28394
28395
28396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28397   int jresult ;
28398   int result;
28399
28400   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28401   jresult = (int)result;
28402   return jresult;
28403 }
28404
28405
28406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28407   int jresult ;
28408   int result;
28409
28410   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28411   jresult = (int)result;
28412   return jresult;
28413 }
28414
28415
28416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28417   int jresult ;
28418   int result;
28419
28420   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28421   jresult = (int)result;
28422   return jresult;
28423 }
28424
28425
28426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28427   int jresult ;
28428   int result;
28429
28430   result = (int)Dali::Actor::Property::SIZE;
28431   jresult = (int)result;
28432   return jresult;
28433 }
28434
28435
28436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28437   int jresult ;
28438   int result;
28439
28440   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28441   jresult = (int)result;
28442   return jresult;
28443 }
28444
28445
28446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28447   int jresult ;
28448   int result;
28449
28450   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28451   jresult = (int)result;
28452   return jresult;
28453 }
28454
28455
28456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28457   int jresult ;
28458   int result;
28459
28460   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28461   jresult = (int)result;
28462   return jresult;
28463 }
28464
28465
28466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28467   int jresult ;
28468   int result;
28469
28470   result = (int)Dali::Actor::Property::POSITION;
28471   jresult = (int)result;
28472   return jresult;
28473 }
28474
28475
28476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28477   int jresult ;
28478   int result;
28479
28480   result = (int)Dali::Actor::Property::POSITION_X;
28481   jresult = (int)result;
28482   return jresult;
28483 }
28484
28485
28486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28487   int jresult ;
28488   int result;
28489
28490   result = (int)Dali::Actor::Property::POSITION_Y;
28491   jresult = (int)result;
28492   return jresult;
28493 }
28494
28495
28496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28497   int jresult ;
28498   int result;
28499
28500   result = (int)Dali::Actor::Property::POSITION_Z;
28501   jresult = (int)result;
28502   return jresult;
28503 }
28504
28505
28506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28507   int jresult ;
28508   int result;
28509
28510   result = (int)Dali::Actor::Property::WORLD_POSITION;
28511   jresult = (int)result;
28512   return jresult;
28513 }
28514
28515
28516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28517   int jresult ;
28518   int result;
28519
28520   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28521   jresult = (int)result;
28522   return jresult;
28523 }
28524
28525
28526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28527   int jresult ;
28528   int result;
28529
28530   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28531   jresult = (int)result;
28532   return jresult;
28533 }
28534
28535
28536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28537   int jresult ;
28538   int result;
28539
28540   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28541   jresult = (int)result;
28542   return jresult;
28543 }
28544
28545
28546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28547   int jresult ;
28548   int result;
28549
28550   result = (int)Dali::Actor::Property::ORIENTATION;
28551   jresult = (int)result;
28552   return jresult;
28553 }
28554
28555
28556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28557   int jresult ;
28558   int result;
28559
28560   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28561   jresult = (int)result;
28562   return jresult;
28563 }
28564
28565
28566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28567   int jresult ;
28568   int result;
28569
28570   result = (int)Dali::Actor::Property::SCALE;
28571   jresult = (int)result;
28572   return jresult;
28573 }
28574
28575
28576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28577   int jresult ;
28578   int result;
28579
28580   result = (int)Dali::Actor::Property::SCALE_X;
28581   jresult = (int)result;
28582   return jresult;
28583 }
28584
28585
28586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28587   int jresult ;
28588   int result;
28589
28590   result = (int)Dali::Actor::Property::SCALE_Y;
28591   jresult = (int)result;
28592   return jresult;
28593 }
28594
28595
28596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28597   int jresult ;
28598   int result;
28599
28600   result = (int)Dali::Actor::Property::SCALE_Z;
28601   jresult = (int)result;
28602   return jresult;
28603 }
28604
28605
28606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28607   int jresult ;
28608   int result;
28609
28610   result = (int)Dali::Actor::Property::WORLD_SCALE;
28611   jresult = (int)result;
28612   return jresult;
28613 }
28614
28615
28616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28617   int jresult ;
28618   int result;
28619
28620   result = (int)Dali::Actor::Property::VISIBLE;
28621   jresult = (int)result;
28622   return jresult;
28623 }
28624
28625
28626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28627   int jresult ;
28628   int result;
28629
28630   result = (int)Dali::Actor::Property::COLOR;
28631   jresult = (int)result;
28632   return jresult;
28633 }
28634
28635
28636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28637   int jresult ;
28638   int result;
28639
28640   result = (int)Dali::Actor::Property::COLOR_RED;
28641   jresult = (int)result;
28642   return jresult;
28643 }
28644
28645
28646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28647   int jresult ;
28648   int result;
28649
28650   result = (int)Dali::Actor::Property::COLOR_GREEN;
28651   jresult = (int)result;
28652   return jresult;
28653 }
28654
28655
28656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28657   int jresult ;
28658   int result;
28659
28660   result = (int)Dali::Actor::Property::COLOR_BLUE;
28661   jresult = (int)result;
28662   return jresult;
28663 }
28664
28665
28666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
28667   int jresult ;
28668   int result;
28669
28670   result = (int)Dali::Actor::Property::COLOR_ALPHA;
28671   jresult = (int)result;
28672   return jresult;
28673 }
28674
28675
28676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
28677   int jresult ;
28678   int result;
28679
28680   result = (int)Dali::Actor::Property::WORLD_COLOR;
28681   jresult = (int)result;
28682   return jresult;
28683 }
28684
28685
28686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
28687   int jresult ;
28688   int result;
28689
28690   result = (int)Dali::Actor::Property::WORLD_MATRIX;
28691   jresult = (int)result;
28692   return jresult;
28693 }
28694
28695
28696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
28697   int jresult ;
28698   int result;
28699
28700   result = (int)Dali::Actor::Property::NAME;
28701   jresult = (int)result;
28702   return jresult;
28703 }
28704
28705
28706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
28707   int jresult ;
28708   int result;
28709
28710   result = (int)Dali::Actor::Property::SENSITIVE;
28711   jresult = (int)result;
28712   return jresult;
28713 }
28714
28715
28716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
28717   int jresult ;
28718   int result;
28719
28720   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
28721   jresult = (int)result;
28722   return jresult;
28723 }
28724
28725
28726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
28727   int jresult ;
28728   int result;
28729
28730   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
28731   jresult = (int)result;
28732   return jresult;
28733 }
28734
28735
28736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
28737   int jresult ;
28738   int result;
28739
28740   result = (int)Dali::Actor::Property::INHERIT_SCALE;
28741   jresult = (int)result;
28742   return jresult;
28743 }
28744
28745
28746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
28747   int jresult ;
28748   int result;
28749
28750   result = (int)Dali::Actor::Property::COLOR_MODE;
28751   jresult = (int)result;
28752   return jresult;
28753 }
28754
28755
28756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
28757   int jresult ;
28758   int result;
28759
28760   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
28761   jresult = (int)result;
28762   return jresult;
28763 }
28764
28765
28766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
28767   int jresult ;
28768   int result;
28769
28770   result = (int)Dali::Actor::Property::DRAW_MODE;
28771   jresult = (int)result;
28772   return jresult;
28773 }
28774
28775
28776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
28777   int jresult ;
28778   int result;
28779
28780   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
28781   jresult = (int)result;
28782   return jresult;
28783 }
28784
28785
28786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
28787   int jresult ;
28788   int result;
28789
28790   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
28791   jresult = (int)result;
28792   return jresult;
28793 }
28794
28795
28796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
28797   int jresult ;
28798   int result;
28799
28800   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
28801   jresult = (int)result;
28802   return jresult;
28803 }
28804
28805
28806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
28807   int jresult ;
28808   int result;
28809
28810   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
28811   jresult = (int)result;
28812   return jresult;
28813 }
28814
28815
28816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
28817   int jresult ;
28818   int result;
28819
28820   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
28821   jresult = (int)result;
28822   return jresult;
28823 }
28824
28825
28826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
28827   int jresult ;
28828   int result;
28829
28830   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
28831   jresult = (int)result;
28832   return jresult;
28833 }
28834
28835
28836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
28837   int jresult ;
28838   int result;
28839
28840   result = (int)Dali::Actor::Property::PADDING;
28841   jresult = (int)result;
28842   return jresult;
28843 }
28844
28845
28846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
28847   int jresult ;
28848   int result;
28849
28850   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
28851   jresult = (int)result;
28852   return jresult;
28853 }
28854
28855
28856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
28857   int jresult ;
28858   int result;
28859
28860   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
28861   jresult = (int)result;
28862   return jresult;
28863 }
28864
28865
28866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
28867   int jresult ;
28868   int result;
28869
28870   result = (int)Dali::Actor::Property::INHERIT_POSITION;
28871   jresult = (int)result;
28872   return jresult;
28873 }
28874
28875
28876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
28877   int jresult ;
28878   int result;
28879
28880   result = (int)Dali::Actor::Property::CLIPPING_MODE;
28881   jresult = (int)result;
28882   return jresult;
28883 }
28884
28885
28886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
28887   void * jresult ;
28888   Dali::Actor::Property *result = 0 ;
28889
28890   {
28891     try {
28892       result = (Dali::Actor::Property *)new Dali::Actor::Property();
28893     } catch (std::out_of_range& e) {
28894       {
28895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28896       };
28897     } catch (std::exception& e) {
28898       {
28899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28900       };
28901     } catch (...) {
28902       {
28903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28904       };
28905     }
28906   }
28907   jresult = (void *)result;
28908   return jresult;
28909 }
28910
28911
28912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
28913   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
28914
28915   arg1 = (Dali::Actor::Property *)jarg1;
28916   {
28917     try {
28918       delete arg1;
28919     } catch (std::out_of_range& e) {
28920       {
28921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28922       };
28923     } catch (std::exception& e) {
28924       {
28925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28926       };
28927     } catch (...) {
28928       {
28929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28930       };
28931     }
28932   }
28933 }
28934
28935
28936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
28937   void * jresult ;
28938   Dali::Actor *result = 0 ;
28939
28940   {
28941     try {
28942       result = (Dali::Actor *)new Dali::Actor();
28943     } catch (std::out_of_range& e) {
28944       {
28945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28946       };
28947     } catch (std::exception& e) {
28948       {
28949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28950       };
28951     } catch (...) {
28952       {
28953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28954       };
28955     }
28956   }
28957   jresult = (void *)result;
28958   return jresult;
28959 }
28960
28961
28962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
28963   void * jresult ;
28964   Dali::Actor result;
28965
28966   {
28967     try {
28968       result = Dali::Actor::New();
28969     } catch (std::out_of_range& e) {
28970       {
28971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28972       };
28973     } catch (std::exception& e) {
28974       {
28975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28976       };
28977     } catch (...) {
28978       {
28979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28980       };
28981     }
28982   }
28983   jresult = new Dali::Actor((const Dali::Actor &)result);
28984   return jresult;
28985 }
28986
28987
28988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
28989   void * jresult ;
28990   Dali::BaseHandle arg1 ;
28991   Dali::BaseHandle *argp1 ;
28992   Dali::Actor result;
28993
28994   argp1 = (Dali::BaseHandle *)jarg1;
28995   if (!argp1) {
28996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28997     return 0;
28998   }
28999   arg1 = *argp1;
29000   {
29001     try {
29002       result = Dali::Actor::DownCast(arg1);
29003     } catch (std::out_of_range& e) {
29004       {
29005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29006       };
29007     } catch (std::exception& e) {
29008       {
29009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29010       };
29011     } catch (...) {
29012       {
29013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29014       };
29015     }
29016   }
29017   jresult = new Dali::Actor((const Dali::Actor &)result);
29018   return jresult;
29019 }
29020
29021
29022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29023   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29024
29025   arg1 = (Dali::Actor *)jarg1;
29026   {
29027     try {
29028       delete arg1;
29029     } catch (std::out_of_range& e) {
29030       {
29031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29032       };
29033     } catch (std::exception& e) {
29034       {
29035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29036       };
29037     } catch (...) {
29038       {
29039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29040       };
29041     }
29042   }
29043 }
29044
29045
29046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29047   void * jresult ;
29048   Dali::Actor *arg1 = 0 ;
29049   Dali::Actor *result = 0 ;
29050
29051   arg1 = (Dali::Actor *)jarg1;
29052   if (!arg1) {
29053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29054     return 0;
29055   }
29056   {
29057     try {
29058       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29059     } catch (std::out_of_range& e) {
29060       {
29061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29062       };
29063     } catch (std::exception& e) {
29064       {
29065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29066       };
29067     } catch (...) {
29068       {
29069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29070       };
29071     }
29072   }
29073   jresult = (void *)result;
29074   return jresult;
29075 }
29076
29077
29078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29079   void * jresult ;
29080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29081   Dali::Actor *arg2 = 0 ;
29082   Dali::Actor *result = 0 ;
29083
29084   arg1 = (Dali::Actor *)jarg1;
29085   arg2 = (Dali::Actor *)jarg2;
29086   if (!arg2) {
29087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29088     return 0;
29089   }
29090   {
29091     try {
29092       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29093     } catch (std::out_of_range& e) {
29094       {
29095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29096       };
29097     } catch (std::exception& e) {
29098       {
29099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29100       };
29101     } catch (...) {
29102       {
29103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29104       };
29105     }
29106   }
29107   jresult = (void *)result;
29108   return jresult;
29109 }
29110
29111
29112 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29113   char * jresult ;
29114   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29115   std::string *result = 0 ;
29116
29117   arg1 = (Dali::Actor *)jarg1;
29118   {
29119     try {
29120       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29121     } catch (std::out_of_range& e) {
29122       {
29123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29124       };
29125     } catch (std::exception& e) {
29126       {
29127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29128       };
29129     } catch (...) {
29130       {
29131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29132       };
29133     }
29134   }
29135   jresult = SWIG_csharp_string_callback(result->c_str());
29136   return jresult;
29137 }
29138
29139
29140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29141   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29142   std::string *arg2 = 0 ;
29143
29144   arg1 = (Dali::Actor *)jarg1;
29145   if (!jarg2) {
29146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29147     return ;
29148   }
29149   std::string arg2_str(jarg2);
29150   arg2 = &arg2_str;
29151   {
29152     try {
29153       (arg1)->SetName((std::string const &)*arg2);
29154     } catch (std::out_of_range& e) {
29155       {
29156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29157       };
29158     } catch (std::exception& e) {
29159       {
29160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29161       };
29162     } catch (...) {
29163       {
29164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29165       };
29166     }
29167   }
29168
29169   //argout typemap for const std::string&
29170
29171 }
29172
29173
29174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29175   unsigned int jresult ;
29176   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29177   unsigned int result;
29178
29179   arg1 = (Dali::Actor *)jarg1;
29180   {
29181     try {
29182       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29183     } catch (std::out_of_range& e) {
29184       {
29185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29186       };
29187     } catch (std::exception& e) {
29188       {
29189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29190       };
29191     } catch (...) {
29192       {
29193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29194       };
29195     }
29196   }
29197   jresult = result;
29198   return jresult;
29199 }
29200
29201
29202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29203   unsigned int jresult ;
29204   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29205   bool result;
29206
29207   arg1 = (Dali::Actor *)jarg1;
29208   {
29209     try {
29210       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29211     } catch (std::out_of_range& e) {
29212       {
29213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29214       };
29215     } catch (std::exception& e) {
29216       {
29217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29218       };
29219     } catch (...) {
29220       {
29221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29222       };
29223     }
29224   }
29225   jresult = result;
29226   return jresult;
29227 }
29228
29229
29230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29231   unsigned int jresult ;
29232   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29233   bool result;
29234
29235   arg1 = (Dali::Actor *)jarg1;
29236   {
29237     try {
29238       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29239     } catch (std::out_of_range& e) {
29240       {
29241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29242       };
29243     } catch (std::exception& e) {
29244       {
29245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29246       };
29247     } catch (...) {
29248       {
29249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29250       };
29251     }
29252   }
29253   jresult = result;
29254   return jresult;
29255 }
29256
29257
29258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29259   unsigned int jresult ;
29260   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29261   bool result;
29262
29263   arg1 = (Dali::Actor *)jarg1;
29264   {
29265     try {
29266       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29267     } catch (std::out_of_range& e) {
29268       {
29269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29270       };
29271     } catch (std::exception& e) {
29272       {
29273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29274       };
29275     } catch (...) {
29276       {
29277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29278       };
29279     }
29280   }
29281   jresult = result;
29282   return jresult;
29283 }
29284
29285
29286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29287   void * jresult ;
29288   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29289   Dali::Layer result;
29290
29291   arg1 = (Dali::Actor *)jarg1;
29292   {
29293     try {
29294       result = (arg1)->GetLayer();
29295     } catch (std::out_of_range& e) {
29296       {
29297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29298       };
29299     } catch (std::exception& e) {
29300       {
29301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29302       };
29303     } catch (...) {
29304       {
29305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29306       };
29307     }
29308   }
29309   jresult = new Dali::Layer((const Dali::Layer &)result);
29310   return jresult;
29311 }
29312
29313
29314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29315   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29316   Dali::Actor arg2 ;
29317   Dali::Actor *argp2 ;
29318
29319   arg1 = (Dali::Actor *)jarg1;
29320   argp2 = (Dali::Actor *)jarg2;
29321   if (!argp2) {
29322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29323     return ;
29324   }
29325   arg2 = *argp2;
29326   {
29327     try {
29328       (arg1)->Add(arg2);
29329     } catch (std::out_of_range& e) {
29330       {
29331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29332       };
29333     } catch (std::exception& e) {
29334       {
29335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29336       };
29337     } catch (...) {
29338       {
29339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29340       };
29341     }
29342   }
29343 }
29344
29345
29346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29347   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29348   Dali::Actor arg2 ;
29349   Dali::Actor *argp2 ;
29350
29351   arg1 = (Dali::Actor *)jarg1;
29352   argp2 = (Dali::Actor *)jarg2;
29353   if (!argp2) {
29354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29355     return ;
29356   }
29357   arg2 = *argp2;
29358   {
29359     try {
29360       (arg1)->Remove(arg2);
29361     } catch (std::out_of_range& e) {
29362       {
29363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29364       };
29365     } catch (std::exception& e) {
29366       {
29367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29368       };
29369     } catch (...) {
29370       {
29371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29372       };
29373     }
29374   }
29375 }
29376
29377
29378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29380
29381   arg1 = (Dali::Actor *)jarg1;
29382   {
29383     try {
29384       (arg1)->Unparent();
29385     } catch (std::out_of_range& e) {
29386       {
29387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29388       };
29389     } catch (std::exception& e) {
29390       {
29391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29392       };
29393     } catch (...) {
29394       {
29395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29396       };
29397     }
29398   }
29399 }
29400
29401
29402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29403   unsigned int jresult ;
29404   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29405   unsigned int result;
29406
29407   arg1 = (Dali::Actor *)jarg1;
29408   {
29409     try {
29410       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29411     } catch (std::out_of_range& e) {
29412       {
29413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29414       };
29415     } catch (std::exception& e) {
29416       {
29417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29418       };
29419     } catch (...) {
29420       {
29421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29422       };
29423     }
29424   }
29425   jresult = result;
29426   return jresult;
29427 }
29428
29429
29430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29431   void * jresult ;
29432   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29433   unsigned int arg2 ;
29434   Dali::Actor result;
29435
29436   arg1 = (Dali::Actor *)jarg1;
29437   arg2 = (unsigned int)jarg2;
29438   {
29439     try {
29440       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29441     } catch (std::out_of_range& e) {
29442       {
29443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29444       };
29445     } catch (std::exception& e) {
29446       {
29447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29448       };
29449     } catch (...) {
29450       {
29451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29452       };
29453     }
29454   }
29455   jresult = new Dali::Actor((const Dali::Actor &)result);
29456   return jresult;
29457 }
29458
29459
29460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29461   void * jresult ;
29462   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29463   std::string *arg2 = 0 ;
29464   Dali::Actor result;
29465
29466   arg1 = (Dali::Actor *)jarg1;
29467   if (!jarg2) {
29468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29469     return 0;
29470   }
29471   std::string arg2_str(jarg2);
29472   arg2 = &arg2_str;
29473   {
29474     try {
29475       result = (arg1)->FindChildByName((std::string const &)*arg2);
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
29492   //argout typemap for const std::string&
29493
29494   return jresult;
29495 }
29496
29497
29498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29499   void * jresult ;
29500   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29501   unsigned int arg2 ;
29502   Dali::Actor result;
29503
29504   arg1 = (Dali::Actor *)jarg1;
29505   arg2 = (unsigned int)jarg2;
29506   {
29507     try {
29508       result = (arg1)->FindChildById(arg2);
29509     } catch (std::out_of_range& e) {
29510       {
29511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29512       };
29513     } catch (std::exception& e) {
29514       {
29515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29516       };
29517     } catch (...) {
29518       {
29519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29520       };
29521     }
29522   }
29523   jresult = new Dali::Actor((const Dali::Actor &)result);
29524   return jresult;
29525 }
29526
29527
29528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29529   void * jresult ;
29530   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29531   Dali::Actor result;
29532
29533   arg1 = (Dali::Actor *)jarg1;
29534   {
29535     try {
29536       result = ((Dali::Actor const *)arg1)->GetParent();
29537     } catch (std::out_of_range& e) {
29538       {
29539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29540       };
29541     } catch (std::exception& e) {
29542       {
29543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29544       };
29545     } catch (...) {
29546       {
29547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29548       };
29549     }
29550   }
29551   jresult = new Dali::Actor((const Dali::Actor &)result);
29552   return jresult;
29553 }
29554
29555
29556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29557   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29558   Dali::Vector3 *arg2 = 0 ;
29559
29560   arg1 = (Dali::Actor *)jarg1;
29561   arg2 = (Dali::Vector3 *)jarg2;
29562   if (!arg2) {
29563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29564     return ;
29565   }
29566   {
29567     try {
29568       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29569     } catch (std::out_of_range& e) {
29570       {
29571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29572       };
29573     } catch (std::exception& e) {
29574       {
29575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29576       };
29577     } catch (...) {
29578       {
29579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29580       };
29581     }
29582   }
29583 }
29584
29585
29586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29587   void * jresult ;
29588   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29589   Dali::Vector3 result;
29590
29591   arg1 = (Dali::Actor *)jarg1;
29592   {
29593     try {
29594       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29595     } catch (std::out_of_range& e) {
29596       {
29597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29598       };
29599     } catch (std::exception& e) {
29600       {
29601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29602       };
29603     } catch (...) {
29604       {
29605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29606       };
29607     }
29608   }
29609   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29610   return jresult;
29611 }
29612
29613
29614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29615   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29616   Dali::Vector3 *arg2 = 0 ;
29617
29618   arg1 = (Dali::Actor *)jarg1;
29619   arg2 = (Dali::Vector3 *)jarg2;
29620   if (!arg2) {
29621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29622     return ;
29623   }
29624   {
29625     try {
29626       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29627     } catch (std::out_of_range& e) {
29628       {
29629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29630       };
29631     } catch (std::exception& e) {
29632       {
29633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29634       };
29635     } catch (...) {
29636       {
29637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29638       };
29639     }
29640   }
29641 }
29642
29643
29644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29645   void * jresult ;
29646   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29647   Dali::Vector3 result;
29648
29649   arg1 = (Dali::Actor *)jarg1;
29650   {
29651     try {
29652       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29653     } catch (std::out_of_range& e) {
29654       {
29655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29656       };
29657     } catch (std::exception& e) {
29658       {
29659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29660       };
29661     } catch (...) {
29662       {
29663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29664       };
29665     }
29666   }
29667   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29668   return jresult;
29669 }
29670
29671
29672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29673   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29674   float arg2 ;
29675   float arg3 ;
29676
29677   arg1 = (Dali::Actor *)jarg1;
29678   arg2 = (float)jarg2;
29679   arg3 = (float)jarg3;
29680   {
29681     try {
29682       (arg1)->SetSize(arg2,arg3);
29683     } catch (std::out_of_range& e) {
29684       {
29685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29686       };
29687     } catch (std::exception& e) {
29688       {
29689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29690       };
29691     } catch (...) {
29692       {
29693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29694       };
29695     }
29696   }
29697 }
29698
29699
29700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29701   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29702   float arg2 ;
29703   float arg3 ;
29704   float arg4 ;
29705
29706   arg1 = (Dali::Actor *)jarg1;
29707   arg2 = (float)jarg2;
29708   arg3 = (float)jarg3;
29709   arg4 = (float)jarg4;
29710   {
29711     try {
29712       (arg1)->SetSize(arg2,arg3,arg4);
29713     } catch (std::out_of_range& e) {
29714       {
29715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29716       };
29717     } catch (std::exception& e) {
29718       {
29719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29720       };
29721     } catch (...) {
29722       {
29723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29724       };
29725     }
29726   }
29727 }
29728
29729
29730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
29731   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29732   Dali::Vector2 *arg2 = 0 ;
29733
29734   arg1 = (Dali::Actor *)jarg1;
29735   arg2 = (Dali::Vector2 *)jarg2;
29736   if (!arg2) {
29737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29738     return ;
29739   }
29740   {
29741     try {
29742       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
29743     } catch (std::out_of_range& e) {
29744       {
29745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29746       };
29747     } catch (std::exception& e) {
29748       {
29749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29750       };
29751     } catch (...) {
29752       {
29753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29754       };
29755     }
29756   }
29757 }
29758
29759
29760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
29761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29762   Dali::Vector3 *arg2 = 0 ;
29763
29764   arg1 = (Dali::Actor *)jarg1;
29765   arg2 = (Dali::Vector3 *)jarg2;
29766   if (!arg2) {
29767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29768     return ;
29769   }
29770   {
29771     try {
29772       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
29773     } catch (std::out_of_range& e) {
29774       {
29775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29776       };
29777     } catch (std::exception& e) {
29778       {
29779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29780       };
29781     } catch (...) {
29782       {
29783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29784       };
29785     }
29786   }
29787 }
29788
29789
29790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
29791   void * jresult ;
29792   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29793   Dali::Vector3 result;
29794
29795   arg1 = (Dali::Actor *)jarg1;
29796   {
29797     try {
29798       result = ((Dali::Actor const *)arg1)->GetTargetSize();
29799     } catch (std::out_of_range& e) {
29800       {
29801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29802       };
29803     } catch (std::exception& e) {
29804       {
29805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29806       };
29807     } catch (...) {
29808       {
29809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29810       };
29811     }
29812   }
29813   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29814   return jresult;
29815 }
29816
29817
29818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
29819   void * jresult ;
29820   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29821   Dali::Vector3 result;
29822
29823   arg1 = (Dali::Actor *)jarg1;
29824   {
29825     try {
29826       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
29827     } catch (std::out_of_range& e) {
29828       {
29829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29830       };
29831     } catch (std::exception& e) {
29832       {
29833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29834       };
29835     } catch (...) {
29836       {
29837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29838       };
29839     }
29840   }
29841   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29842   return jresult;
29843 }
29844
29845
29846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
29847   void * jresult ;
29848   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29849   Dali::Vector3 result;
29850
29851   arg1 = (Dali::Actor *)jarg1;
29852   {
29853     try {
29854       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
29855     } catch (std::out_of_range& e) {
29856       {
29857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29858       };
29859     } catch (std::exception& e) {
29860       {
29861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29862       };
29863     } catch (...) {
29864       {
29865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29866       };
29867     }
29868   }
29869   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29870   return jresult;
29871 }
29872
29873
29874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29875   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29876   float arg2 ;
29877   float arg3 ;
29878
29879   arg1 = (Dali::Actor *)jarg1;
29880   arg2 = (float)jarg2;
29881   arg3 = (float)jarg3;
29882   {
29883     try {
29884       (arg1)->SetPosition(arg2,arg3);
29885     } catch (std::out_of_range& e) {
29886       {
29887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29888       };
29889     } catch (std::exception& e) {
29890       {
29891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29892       };
29893     } catch (...) {
29894       {
29895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29896       };
29897     }
29898   }
29899 }
29900
29901
29902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29903   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29904   float arg2 ;
29905   float arg3 ;
29906   float arg4 ;
29907
29908   arg1 = (Dali::Actor *)jarg1;
29909   arg2 = (float)jarg2;
29910   arg3 = (float)jarg3;
29911   arg4 = (float)jarg4;
29912   {
29913     try {
29914       (arg1)->SetPosition(arg2,arg3,arg4);
29915     } catch (std::out_of_range& e) {
29916       {
29917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29918       };
29919     } catch (std::exception& e) {
29920       {
29921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29922       };
29923     } catch (...) {
29924       {
29925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29926       };
29927     }
29928   }
29929 }
29930
29931
29932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
29933   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29934   Dali::Vector3 *arg2 = 0 ;
29935
29936   arg1 = (Dali::Actor *)jarg1;
29937   arg2 = (Dali::Vector3 *)jarg2;
29938   if (!arg2) {
29939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29940     return ;
29941   }
29942   {
29943     try {
29944       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
29945     } catch (std::out_of_range& e) {
29946       {
29947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29948       };
29949     } catch (std::exception& e) {
29950       {
29951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29952       };
29953     } catch (...) {
29954       {
29955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29956       };
29957     }
29958   }
29959 }
29960
29961
29962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
29963   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29964   float arg2 ;
29965
29966   arg1 = (Dali::Actor *)jarg1;
29967   arg2 = (float)jarg2;
29968   {
29969     try {
29970       (arg1)->SetX(arg2);
29971     } catch (std::out_of_range& e) {
29972       {
29973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29974       };
29975     } catch (std::exception& e) {
29976       {
29977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29978       };
29979     } catch (...) {
29980       {
29981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29982       };
29983     }
29984   }
29985 }
29986
29987
29988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
29989   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29990   float arg2 ;
29991
29992   arg1 = (Dali::Actor *)jarg1;
29993   arg2 = (float)jarg2;
29994   {
29995     try {
29996       (arg1)->SetY(arg2);
29997     } catch (std::out_of_range& e) {
29998       {
29999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30000       };
30001     } catch (std::exception& e) {
30002       {
30003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30004       };
30005     } catch (...) {
30006       {
30007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30008       };
30009     }
30010   }
30011 }
30012
30013
30014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30015   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30016   float arg2 ;
30017
30018   arg1 = (Dali::Actor *)jarg1;
30019   arg2 = (float)jarg2;
30020   {
30021     try {
30022       (arg1)->SetZ(arg2);
30023     } catch (std::out_of_range& e) {
30024       {
30025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30026       };
30027     } catch (std::exception& e) {
30028       {
30029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30030       };
30031     } catch (...) {
30032       {
30033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30034       };
30035     }
30036   }
30037 }
30038
30039
30040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30041   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30042   Dali::Vector3 *arg2 = 0 ;
30043
30044   arg1 = (Dali::Actor *)jarg1;
30045   arg2 = (Dali::Vector3 *)jarg2;
30046   if (!arg2) {
30047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30048     return ;
30049   }
30050   {
30051     try {
30052       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30053     } catch (std::out_of_range& e) {
30054       {
30055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30056       };
30057     } catch (std::exception& e) {
30058       {
30059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30060       };
30061     } catch (...) {
30062       {
30063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30064       };
30065     }
30066   }
30067 }
30068
30069
30070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30071   void * jresult ;
30072   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30073   Dali::Vector3 result;
30074
30075   arg1 = (Dali::Actor *)jarg1;
30076   {
30077     try {
30078       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30079     } catch (std::out_of_range& e) {
30080       {
30081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30082       };
30083     } catch (std::exception& e) {
30084       {
30085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30086       };
30087     } catch (...) {
30088       {
30089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30090       };
30091     }
30092   }
30093   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30094   return jresult;
30095 }
30096
30097
30098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30099   void * jresult ;
30100   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30101   Dali::Vector3 result;
30102
30103   arg1 = (Dali::Actor *)jarg1;
30104   {
30105     try {
30106       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30107     } catch (std::out_of_range& e) {
30108       {
30109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30110       };
30111     } catch (std::exception& e) {
30112       {
30113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30114       };
30115     } catch (...) {
30116       {
30117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30118       };
30119     }
30120   }
30121   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30122   return jresult;
30123 }
30124
30125
30126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30127   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30128   bool arg2 ;
30129
30130   arg1 = (Dali::Actor *)jarg1;
30131   arg2 = jarg2 ? true : false;
30132   {
30133     try {
30134       (arg1)->SetInheritPosition(arg2);
30135     } catch (std::out_of_range& e) {
30136       {
30137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30138       };
30139     } catch (std::exception& e) {
30140       {
30141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30142       };
30143     } catch (...) {
30144       {
30145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30146       };
30147     }
30148   }
30149 }
30150
30151
30152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30153   int jresult ;
30154   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30155   Dali::PositionInheritanceMode result;
30156
30157   arg1 = (Dali::Actor *)jarg1;
30158   {
30159     try {
30160       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30161     } catch (std::out_of_range& e) {
30162       {
30163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30164       };
30165     } catch (std::exception& e) {
30166       {
30167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30168       };
30169     } catch (...) {
30170       {
30171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30172       };
30173     }
30174   }
30175   jresult = (int)result;
30176   return jresult;
30177 }
30178
30179
30180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30181   unsigned int jresult ;
30182   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30183   bool result;
30184
30185   arg1 = (Dali::Actor *)jarg1;
30186   {
30187     try {
30188       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30189     } catch (std::out_of_range& e) {
30190       {
30191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30192       };
30193     } catch (std::exception& e) {
30194       {
30195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30196       };
30197     } catch (...) {
30198       {
30199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30200       };
30201     }
30202   }
30203   jresult = result;
30204   return jresult;
30205 }
30206
30207
30208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30209   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30210   Dali::Degree *arg2 = 0 ;
30211   Dali::Vector3 *arg3 = 0 ;
30212
30213   arg1 = (Dali::Actor *)jarg1;
30214   arg2 = (Dali::Degree *)jarg2;
30215   if (!arg2) {
30216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30217     return ;
30218   }
30219   arg3 = (Dali::Vector3 *)jarg3;
30220   if (!arg3) {
30221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30222     return ;
30223   }
30224   {
30225     try {
30226       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30227     } catch (std::out_of_range& e) {
30228       {
30229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30230       };
30231     } catch (std::exception& e) {
30232       {
30233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30234       };
30235     } catch (...) {
30236       {
30237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30238       };
30239     }
30240   }
30241 }
30242
30243
30244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30245   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30246   Dali::Radian *arg2 = 0 ;
30247   Dali::Vector3 *arg3 = 0 ;
30248
30249   arg1 = (Dali::Actor *)jarg1;
30250   arg2 = (Dali::Radian *)jarg2;
30251   if (!arg2) {
30252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30253     return ;
30254   }
30255   arg3 = (Dali::Vector3 *)jarg3;
30256   if (!arg3) {
30257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30258     return ;
30259   }
30260   {
30261     try {
30262       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30263     } catch (std::out_of_range& e) {
30264       {
30265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30266       };
30267     } catch (std::exception& e) {
30268       {
30269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30270       };
30271     } catch (...) {
30272       {
30273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30274       };
30275     }
30276   }
30277 }
30278
30279
30280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30281   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30282   Dali::Quaternion *arg2 = 0 ;
30283
30284   arg1 = (Dali::Actor *)jarg1;
30285   arg2 = (Dali::Quaternion *)jarg2;
30286   if (!arg2) {
30287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30288     return ;
30289   }
30290   {
30291     try {
30292       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30293     } catch (std::out_of_range& e) {
30294       {
30295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30296       };
30297     } catch (std::exception& e) {
30298       {
30299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30300       };
30301     } catch (...) {
30302       {
30303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30304       };
30305     }
30306   }
30307 }
30308
30309
30310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30311   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30312   Dali::Degree *arg2 = 0 ;
30313   Dali::Vector3 *arg3 = 0 ;
30314
30315   arg1 = (Dali::Actor *)jarg1;
30316   arg2 = (Dali::Degree *)jarg2;
30317   if (!arg2) {
30318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30319     return ;
30320   }
30321   arg3 = (Dali::Vector3 *)jarg3;
30322   if (!arg3) {
30323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30324     return ;
30325   }
30326   {
30327     try {
30328       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30329     } catch (std::out_of_range& e) {
30330       {
30331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30332       };
30333     } catch (std::exception& e) {
30334       {
30335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30336       };
30337     } catch (...) {
30338       {
30339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30340       };
30341     }
30342   }
30343 }
30344
30345
30346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30347   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30348   Dali::Radian *arg2 = 0 ;
30349   Dali::Vector3 *arg3 = 0 ;
30350
30351   arg1 = (Dali::Actor *)jarg1;
30352   arg2 = (Dali::Radian *)jarg2;
30353   if (!arg2) {
30354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30355     return ;
30356   }
30357   arg3 = (Dali::Vector3 *)jarg3;
30358   if (!arg3) {
30359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30360     return ;
30361   }
30362   {
30363     try {
30364       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30365     } catch (std::out_of_range& e) {
30366       {
30367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30368       };
30369     } catch (std::exception& e) {
30370       {
30371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30372       };
30373     } catch (...) {
30374       {
30375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30376       };
30377     }
30378   }
30379 }
30380
30381
30382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30383   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30384   Dali::Quaternion *arg2 = 0 ;
30385
30386   arg1 = (Dali::Actor *)jarg1;
30387   arg2 = (Dali::Quaternion *)jarg2;
30388   if (!arg2) {
30389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30390     return ;
30391   }
30392   {
30393     try {
30394       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30395     } catch (std::out_of_range& e) {
30396       {
30397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30398       };
30399     } catch (std::exception& e) {
30400       {
30401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30402       };
30403     } catch (...) {
30404       {
30405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30406       };
30407     }
30408   }
30409 }
30410
30411
30412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30413   void * jresult ;
30414   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30415   Dali::Quaternion result;
30416
30417   arg1 = (Dali::Actor *)jarg1;
30418   {
30419     try {
30420       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30421     } catch (std::out_of_range& e) {
30422       {
30423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30424       };
30425     } catch (std::exception& e) {
30426       {
30427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30428       };
30429     } catch (...) {
30430       {
30431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30432       };
30433     }
30434   }
30435   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30436   return jresult;
30437 }
30438
30439
30440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30441   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30442   bool arg2 ;
30443
30444   arg1 = (Dali::Actor *)jarg1;
30445   arg2 = jarg2 ? true : false;
30446   {
30447     try {
30448       (arg1)->SetInheritOrientation(arg2);
30449     } catch (std::out_of_range& e) {
30450       {
30451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30452       };
30453     } catch (std::exception& e) {
30454       {
30455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30456       };
30457     } catch (...) {
30458       {
30459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30460       };
30461     }
30462   }
30463 }
30464
30465
30466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30467   unsigned int jresult ;
30468   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30469   bool result;
30470
30471   arg1 = (Dali::Actor *)jarg1;
30472   {
30473     try {
30474       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30475     } catch (std::out_of_range& e) {
30476       {
30477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30478       };
30479     } catch (std::exception& e) {
30480       {
30481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30482       };
30483     } catch (...) {
30484       {
30485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30486       };
30487     }
30488   }
30489   jresult = result;
30490   return jresult;
30491 }
30492
30493
30494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30495   void * jresult ;
30496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30497   Dali::Quaternion result;
30498
30499   arg1 = (Dali::Actor *)jarg1;
30500   {
30501     try {
30502       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30503     } catch (std::out_of_range& e) {
30504       {
30505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30506       };
30507     } catch (std::exception& e) {
30508       {
30509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30510       };
30511     } catch (...) {
30512       {
30513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30514       };
30515     }
30516   }
30517   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30518   return jresult;
30519 }
30520
30521
30522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30523   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30524   float arg2 ;
30525
30526   arg1 = (Dali::Actor *)jarg1;
30527   arg2 = (float)jarg2;
30528   {
30529     try {
30530       (arg1)->SetScale(arg2);
30531     } catch (std::out_of_range& e) {
30532       {
30533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30534       };
30535     } catch (std::exception& e) {
30536       {
30537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30538       };
30539     } catch (...) {
30540       {
30541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30542       };
30543     }
30544   }
30545 }
30546
30547
30548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30549   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30550   float arg2 ;
30551   float arg3 ;
30552   float arg4 ;
30553
30554   arg1 = (Dali::Actor *)jarg1;
30555   arg2 = (float)jarg2;
30556   arg3 = (float)jarg3;
30557   arg4 = (float)jarg4;
30558   {
30559     try {
30560       (arg1)->SetScale(arg2,arg3,arg4);
30561     } catch (std::out_of_range& e) {
30562       {
30563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30564       };
30565     } catch (std::exception& e) {
30566       {
30567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30568       };
30569     } catch (...) {
30570       {
30571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30572       };
30573     }
30574   }
30575 }
30576
30577
30578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30580   Dali::Vector3 *arg2 = 0 ;
30581
30582   arg1 = (Dali::Actor *)jarg1;
30583   arg2 = (Dali::Vector3 *)jarg2;
30584   if (!arg2) {
30585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30586     return ;
30587   }
30588   {
30589     try {
30590       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30591     } catch (std::out_of_range& e) {
30592       {
30593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30594       };
30595     } catch (std::exception& e) {
30596       {
30597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30598       };
30599     } catch (...) {
30600       {
30601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30602       };
30603     }
30604   }
30605 }
30606
30607
30608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30609   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30610   Dali::Vector3 *arg2 = 0 ;
30611
30612   arg1 = (Dali::Actor *)jarg1;
30613   arg2 = (Dali::Vector3 *)jarg2;
30614   if (!arg2) {
30615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30616     return ;
30617   }
30618   {
30619     try {
30620       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30621     } catch (std::out_of_range& e) {
30622       {
30623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30624       };
30625     } catch (std::exception& e) {
30626       {
30627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30628       };
30629     } catch (...) {
30630       {
30631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30632       };
30633     }
30634   }
30635 }
30636
30637
30638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30639   void * jresult ;
30640   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30641   Dali::Vector3 result;
30642
30643   arg1 = (Dali::Actor *)jarg1;
30644   {
30645     try {
30646       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30647     } catch (std::out_of_range& e) {
30648       {
30649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30650       };
30651     } catch (std::exception& e) {
30652       {
30653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30654       };
30655     } catch (...) {
30656       {
30657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30658       };
30659     }
30660   }
30661   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30662   return jresult;
30663 }
30664
30665
30666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
30667   void * jresult ;
30668   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30669   Dali::Vector3 result;
30670
30671   arg1 = (Dali::Actor *)jarg1;
30672   {
30673     try {
30674       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
30675     } catch (std::out_of_range& e) {
30676       {
30677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30678       };
30679     } catch (std::exception& e) {
30680       {
30681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30682       };
30683     } catch (...) {
30684       {
30685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30686       };
30687     }
30688   }
30689   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30690   return jresult;
30691 }
30692
30693
30694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
30695   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30696   bool arg2 ;
30697
30698   arg1 = (Dali::Actor *)jarg1;
30699   arg2 = jarg2 ? true : false;
30700   {
30701     try {
30702       (arg1)->SetInheritScale(arg2);
30703     } catch (std::out_of_range& e) {
30704       {
30705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30706       };
30707     } catch (std::exception& e) {
30708       {
30709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30710       };
30711     } catch (...) {
30712       {
30713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30714       };
30715     }
30716   }
30717 }
30718
30719
30720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
30721   unsigned int jresult ;
30722   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30723   bool result;
30724
30725   arg1 = (Dali::Actor *)jarg1;
30726   {
30727     try {
30728       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
30729     } catch (std::out_of_range& e) {
30730       {
30731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30732       };
30733     } catch (std::exception& e) {
30734       {
30735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30736       };
30737     } catch (...) {
30738       {
30739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30740       };
30741     }
30742   }
30743   jresult = result;
30744   return jresult;
30745 }
30746
30747
30748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
30749   void * jresult ;
30750   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30751   Dali::Matrix result;
30752
30753   arg1 = (Dali::Actor *)jarg1;
30754   {
30755     try {
30756       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
30757     } catch (std::out_of_range& e) {
30758       {
30759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30760       };
30761     } catch (std::exception& e) {
30762       {
30763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30764       };
30765     } catch (...) {
30766       {
30767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30768       };
30769     }
30770   }
30771   jresult = new Dali::Matrix((const Dali::Matrix &)result);
30772   return jresult;
30773 }
30774
30775
30776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
30777   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30778   bool arg2 ;
30779
30780   arg1 = (Dali::Actor *)jarg1;
30781   arg2 = jarg2 ? true : false;
30782   {
30783     try {
30784       (arg1)->SetVisible(arg2);
30785     } catch (std::out_of_range& e) {
30786       {
30787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30788       };
30789     } catch (std::exception& e) {
30790       {
30791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30792       };
30793     } catch (...) {
30794       {
30795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30796       };
30797     }
30798   }
30799 }
30800
30801
30802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
30803   unsigned int jresult ;
30804   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30805   bool result;
30806
30807   arg1 = (Dali::Actor *)jarg1;
30808   {
30809     try {
30810       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
30811     } catch (std::out_of_range& e) {
30812       {
30813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30814       };
30815     } catch (std::exception& e) {
30816       {
30817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30818       };
30819     } catch (...) {
30820       {
30821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30822       };
30823     }
30824   }
30825   jresult = result;
30826   return jresult;
30827 }
30828
30829
30830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
30831   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30832   float arg2 ;
30833
30834   arg1 = (Dali::Actor *)jarg1;
30835   arg2 = (float)jarg2;
30836   {
30837     try {
30838       (arg1)->SetOpacity(arg2);
30839     } catch (std::out_of_range& e) {
30840       {
30841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30842       };
30843     } catch (std::exception& e) {
30844       {
30845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30846       };
30847     } catch (...) {
30848       {
30849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30850       };
30851     }
30852   }
30853 }
30854
30855
30856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
30857   float jresult ;
30858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30859   float result;
30860
30861   arg1 = (Dali::Actor *)jarg1;
30862   {
30863     try {
30864       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
30865     } catch (std::out_of_range& e) {
30866       {
30867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30868       };
30869     } catch (std::exception& e) {
30870       {
30871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30872       };
30873     } catch (...) {
30874       {
30875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30876       };
30877     }
30878   }
30879   jresult = result;
30880   return jresult;
30881 }
30882
30883
30884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
30885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30886   Dali::Vector4 *arg2 = 0 ;
30887
30888   arg1 = (Dali::Actor *)jarg1;
30889   arg2 = (Dali::Vector4 *)jarg2;
30890   if (!arg2) {
30891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
30892     return ;
30893   }
30894   {
30895     try {
30896       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
30897     } catch (std::out_of_range& e) {
30898       {
30899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30900       };
30901     } catch (std::exception& e) {
30902       {
30903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30904       };
30905     } catch (...) {
30906       {
30907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30908       };
30909     }
30910   }
30911 }
30912
30913
30914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
30915   void * jresult ;
30916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30917   Dali::Vector4 result;
30918
30919   arg1 = (Dali::Actor *)jarg1;
30920   {
30921     try {
30922       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
30923     } catch (std::out_of_range& e) {
30924       {
30925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30926       };
30927     } catch (std::exception& e) {
30928       {
30929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30930       };
30931     } catch (...) {
30932       {
30933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30934       };
30935     }
30936   }
30937   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
30938   return jresult;
30939 }
30940
30941
30942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
30943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30944   Dali::ColorMode arg2 ;
30945
30946   arg1 = (Dali::Actor *)jarg1;
30947   arg2 = (Dali::ColorMode)jarg2;
30948   {
30949     try {
30950       (arg1)->SetColorMode(arg2);
30951     } catch (std::out_of_range& e) {
30952       {
30953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30954       };
30955     } catch (std::exception& e) {
30956       {
30957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30958       };
30959     } catch (...) {
30960       {
30961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30962       };
30963     }
30964   }
30965 }
30966
30967
30968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
30969   int jresult ;
30970   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30971   Dali::ColorMode result;
30972
30973   arg1 = (Dali::Actor *)jarg1;
30974   {
30975     try {
30976       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
30977     } catch (std::out_of_range& e) {
30978       {
30979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30980       };
30981     } catch (std::exception& e) {
30982       {
30983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30984       };
30985     } catch (...) {
30986       {
30987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30988       };
30989     }
30990   }
30991   jresult = (int)result;
30992   return jresult;
30993 }
30994
30995
30996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
30997   void * jresult ;
30998   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30999   Dali::Vector4 result;
31000
31001   arg1 = (Dali::Actor *)jarg1;
31002   {
31003     try {
31004       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31005     } catch (std::out_of_range& e) {
31006       {
31007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31008       };
31009     } catch (std::exception& e) {
31010       {
31011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31012       };
31013     } catch (...) {
31014       {
31015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31016       };
31017     }
31018   }
31019   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31020   return jresult;
31021 }
31022
31023
31024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31025   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31026   Dali::DrawMode::Type arg2 ;
31027
31028   arg1 = (Dali::Actor *)jarg1;
31029   arg2 = (Dali::DrawMode::Type)jarg2;
31030   {
31031     try {
31032       (arg1)->SetDrawMode(arg2);
31033     } catch (std::out_of_range& e) {
31034       {
31035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31036       };
31037     } catch (std::exception& e) {
31038       {
31039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31040       };
31041     } catch (...) {
31042       {
31043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31044       };
31045     }
31046   }
31047 }
31048
31049
31050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31051   int jresult ;
31052   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31053   Dali::DrawMode::Type result;
31054
31055   arg1 = (Dali::Actor *)jarg1;
31056   {
31057     try {
31058       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31059     } catch (std::out_of_range& e) {
31060       {
31061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31062       };
31063     } catch (std::exception& e) {
31064       {
31065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31066       };
31067     } catch (...) {
31068       {
31069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31070       };
31071     }
31072   }
31073   jresult = (int)result;
31074   return jresult;
31075 }
31076
31077
31078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31080   bool arg2 ;
31081
31082   arg1 = (Dali::Actor *)jarg1;
31083   arg2 = jarg2 ? true : false;
31084   {
31085     try {
31086       (arg1)->SetSensitive(arg2);
31087     } catch (std::out_of_range& e) {
31088       {
31089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31090       };
31091     } catch (std::exception& e) {
31092       {
31093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31094       };
31095     } catch (...) {
31096       {
31097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31098       };
31099     }
31100   }
31101 }
31102
31103
31104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31105   unsigned int jresult ;
31106   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31107   bool result;
31108
31109   arg1 = (Dali::Actor *)jarg1;
31110   {
31111     try {
31112       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31113     } catch (std::out_of_range& e) {
31114       {
31115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31116       };
31117     } catch (std::exception& e) {
31118       {
31119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31120       };
31121     } catch (...) {
31122       {
31123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31124       };
31125     }
31126   }
31127   jresult = result;
31128   return jresult;
31129 }
31130
31131
31132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31133   unsigned int jresult ;
31134   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31135   float *arg2 = 0 ;
31136   float *arg3 = 0 ;
31137   float arg4 ;
31138   float arg5 ;
31139   bool result;
31140
31141   arg1 = (Dali::Actor *)jarg1;
31142   arg2 = (float *)jarg2;
31143   arg3 = (float *)jarg3;
31144   arg4 = (float)jarg4;
31145   arg5 = (float)jarg5;
31146   {
31147     try {
31148       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31149     } catch (std::out_of_range& e) {
31150       {
31151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31152       };
31153     } catch (std::exception& e) {
31154       {
31155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31156       };
31157     } catch (...) {
31158       {
31159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31160       };
31161     }
31162   }
31163   jresult = result;
31164   return jresult;
31165 }
31166
31167
31168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31169   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31170   bool arg2 ;
31171
31172   arg1 = (Dali::Actor *)jarg1;
31173   arg2 = jarg2 ? true : false;
31174   {
31175     try {
31176       (arg1)->SetLeaveRequired(arg2);
31177     } catch (std::out_of_range& e) {
31178       {
31179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31180       };
31181     } catch (std::exception& e) {
31182       {
31183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31184       };
31185     } catch (...) {
31186       {
31187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31188       };
31189     }
31190   }
31191 }
31192
31193
31194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31195   unsigned int jresult ;
31196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31197   bool result;
31198
31199   arg1 = (Dali::Actor *)jarg1;
31200   {
31201     try {
31202       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31203     } catch (std::out_of_range& e) {
31204       {
31205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31206       };
31207     } catch (std::exception& e) {
31208       {
31209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31210       };
31211     } catch (...) {
31212       {
31213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31214       };
31215     }
31216   }
31217   jresult = result;
31218   return jresult;
31219 }
31220
31221
31222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31223   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31224   bool arg2 ;
31225
31226   arg1 = (Dali::Actor *)jarg1;
31227   arg2 = jarg2 ? true : false;
31228   {
31229     try {
31230       (arg1)->SetKeyboardFocusable(arg2);
31231     } catch (std::out_of_range& e) {
31232       {
31233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31234       };
31235     } catch (std::exception& e) {
31236       {
31237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31238       };
31239     } catch (...) {
31240       {
31241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31242       };
31243     }
31244   }
31245 }
31246
31247
31248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31249   unsigned int jresult ;
31250   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31251   bool result;
31252
31253   arg1 = (Dali::Actor *)jarg1;
31254   {
31255     try {
31256       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31257     } catch (std::out_of_range& e) {
31258       {
31259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31260       };
31261     } catch (std::exception& e) {
31262       {
31263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31264       };
31265     } catch (...) {
31266       {
31267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31268       };
31269     }
31270   }
31271   jresult = result;
31272   return jresult;
31273 }
31274
31275
31276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31277   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31278   Dali::ResizePolicy::Type arg2 ;
31279   Dali::Dimension::Type arg3 ;
31280
31281   arg1 = (Dali::Actor *)jarg1;
31282   arg2 = (Dali::ResizePolicy::Type)jarg2;
31283   arg3 = (Dali::Dimension::Type)jarg3;
31284   {
31285     try {
31286       (arg1)->SetResizePolicy(arg2,arg3);
31287     } catch (std::out_of_range& e) {
31288       {
31289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31290       };
31291     } catch (std::exception& e) {
31292       {
31293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31294       };
31295     } catch (...) {
31296       {
31297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31298       };
31299     }
31300   }
31301 }
31302
31303
31304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31305   int jresult ;
31306   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31307   Dali::Dimension::Type arg2 ;
31308   Dali::ResizePolicy::Type result;
31309
31310   arg1 = (Dali::Actor *)jarg1;
31311   arg2 = (Dali::Dimension::Type)jarg2;
31312   {
31313     try {
31314       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31315     } catch (std::out_of_range& e) {
31316       {
31317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31318       };
31319     } catch (std::exception& e) {
31320       {
31321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31322       };
31323     } catch (...) {
31324       {
31325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31326       };
31327     }
31328   }
31329   jresult = (int)result;
31330   return jresult;
31331 }
31332
31333
31334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31335   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31336   Dali::SizeScalePolicy::Type arg2 ;
31337
31338   arg1 = (Dali::Actor *)jarg1;
31339   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31340   {
31341     try {
31342       (arg1)->SetSizeScalePolicy(arg2);
31343     } catch (std::out_of_range& e) {
31344       {
31345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31346       };
31347     } catch (std::exception& e) {
31348       {
31349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31350       };
31351     } catch (...) {
31352       {
31353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31354       };
31355     }
31356   }
31357 }
31358
31359
31360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31361   int jresult ;
31362   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31363   Dali::SizeScalePolicy::Type result;
31364
31365   arg1 = (Dali::Actor *)jarg1;
31366   {
31367     try {
31368       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31369     } catch (std::out_of_range& e) {
31370       {
31371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31372       };
31373     } catch (std::exception& e) {
31374       {
31375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31376       };
31377     } catch (...) {
31378       {
31379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31380       };
31381     }
31382   }
31383   jresult = (int)result;
31384   return jresult;
31385 }
31386
31387
31388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31390   Dali::Vector3 *arg2 = 0 ;
31391
31392   arg1 = (Dali::Actor *)jarg1;
31393   arg2 = (Dali::Vector3 *)jarg2;
31394   if (!arg2) {
31395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31396     return ;
31397   }
31398   {
31399     try {
31400       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31401     } catch (std::out_of_range& e) {
31402       {
31403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31404       };
31405     } catch (std::exception& e) {
31406       {
31407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31408       };
31409     } catch (...) {
31410       {
31411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31412       };
31413     }
31414   }
31415 }
31416
31417
31418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31419   void * jresult ;
31420   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31421   Dali::Vector3 result;
31422
31423   arg1 = (Dali::Actor *)jarg1;
31424   {
31425     try {
31426       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31427     } catch (std::out_of_range& e) {
31428       {
31429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31430       };
31431     } catch (std::exception& e) {
31432       {
31433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31434       };
31435     } catch (...) {
31436       {
31437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31438       };
31439     }
31440   }
31441   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31442   return jresult;
31443 }
31444
31445
31446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31447   float jresult ;
31448   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31449   float arg2 ;
31450   float result;
31451
31452   arg1 = (Dali::Actor *)jarg1;
31453   arg2 = (float)jarg2;
31454   {
31455     try {
31456       result = (float)(arg1)->GetHeightForWidth(arg2);
31457     } catch (std::out_of_range& e) {
31458       {
31459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31460       };
31461     } catch (std::exception& e) {
31462       {
31463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31464       };
31465     } catch (...) {
31466       {
31467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31468       };
31469     }
31470   }
31471   jresult = result;
31472   return jresult;
31473 }
31474
31475
31476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31477   float jresult ;
31478   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31479   float arg2 ;
31480   float result;
31481
31482   arg1 = (Dali::Actor *)jarg1;
31483   arg2 = (float)jarg2;
31484   {
31485     try {
31486       result = (float)(arg1)->GetWidthForHeight(arg2);
31487     } catch (std::out_of_range& e) {
31488       {
31489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31490       };
31491     } catch (std::exception& e) {
31492       {
31493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31494       };
31495     } catch (...) {
31496       {
31497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31498       };
31499     }
31500   }
31501   jresult = result;
31502   return jresult;
31503 }
31504
31505
31506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31507   float jresult ;
31508   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31509   Dali::Dimension::Type arg2 ;
31510   float result;
31511
31512   arg1 = (Dali::Actor *)jarg1;
31513   arg2 = (Dali::Dimension::Type)jarg2;
31514   {
31515     try {
31516       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31517     } catch (std::out_of_range& e) {
31518       {
31519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31520       };
31521     } catch (std::exception& e) {
31522       {
31523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31524       };
31525     } catch (...) {
31526       {
31527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31528       };
31529     }
31530   }
31531   jresult = result;
31532   return jresult;
31533 }
31534
31535
31536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31537   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31538   Dali::Padding *arg2 = 0 ;
31539
31540   arg1 = (Dali::Actor *)jarg1;
31541   arg2 = (Dali::Padding *)jarg2;
31542   if (!arg2) {
31543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31544     return ;
31545   }
31546   {
31547     try {
31548       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31549     } catch (std::out_of_range& e) {
31550       {
31551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31552       };
31553     } catch (std::exception& e) {
31554       {
31555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31556       };
31557     } catch (...) {
31558       {
31559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31560       };
31561     }
31562   }
31563 }
31564
31565
31566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31568   Dali::Padding *arg2 = 0 ;
31569
31570   arg1 = (Dali::Actor *)jarg1;
31571   arg2 = (Dali::Padding *)jarg2;
31572   if (!arg2) {
31573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31574     return ;
31575   }
31576   {
31577     try {
31578       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31579     } catch (std::out_of_range& e) {
31580       {
31581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31582       };
31583     } catch (std::exception& e) {
31584       {
31585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31586       };
31587     } catch (...) {
31588       {
31589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31590       };
31591     }
31592   }
31593 }
31594
31595
31596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31597   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31598   Dali::Vector2 *arg2 = 0 ;
31599
31600   arg1 = (Dali::Actor *)jarg1;
31601   arg2 = (Dali::Vector2 *)jarg2;
31602   if (!arg2) {
31603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31604     return ;
31605   }
31606   {
31607     try {
31608       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31609     } catch (std::out_of_range& e) {
31610       {
31611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31612       };
31613     } catch (std::exception& e) {
31614       {
31615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31616       };
31617     } catch (...) {
31618       {
31619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31620       };
31621     }
31622   }
31623 }
31624
31625
31626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31627   void * jresult ;
31628   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31629   Dali::Vector2 result;
31630
31631   arg1 = (Dali::Actor *)jarg1;
31632   {
31633     try {
31634       result = (arg1)->GetMinimumSize();
31635     } catch (std::out_of_range& e) {
31636       {
31637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31638       };
31639     } catch (std::exception& e) {
31640       {
31641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31642       };
31643     } catch (...) {
31644       {
31645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31646       };
31647     }
31648   }
31649   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31650   return jresult;
31651 }
31652
31653
31654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31655   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31656   Dali::Vector2 *arg2 = 0 ;
31657
31658   arg1 = (Dali::Actor *)jarg1;
31659   arg2 = (Dali::Vector2 *)jarg2;
31660   if (!arg2) {
31661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31662     return ;
31663   }
31664   {
31665     try {
31666       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
31667     } catch (std::out_of_range& e) {
31668       {
31669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31670       };
31671     } catch (std::exception& e) {
31672       {
31673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31674       };
31675     } catch (...) {
31676       {
31677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31678       };
31679     }
31680   }
31681 }
31682
31683
31684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
31685   void * jresult ;
31686   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31687   Dali::Vector2 result;
31688
31689   arg1 = (Dali::Actor *)jarg1;
31690   {
31691     try {
31692       result = (arg1)->GetMaximumSize();
31693     } catch (std::out_of_range& e) {
31694       {
31695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31696       };
31697     } catch (std::exception& e) {
31698       {
31699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31700       };
31701     } catch (...) {
31702       {
31703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31704       };
31705     }
31706   }
31707   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31708   return jresult;
31709 }
31710
31711
31712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
31713   int jresult ;
31714   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31715   int result;
31716
31717   arg1 = (Dali::Actor *)jarg1;
31718   {
31719     try {
31720       result = (int)(arg1)->GetHierarchyDepth();
31721     } catch (std::out_of_range& e) {
31722       {
31723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31724       };
31725     } catch (std::exception& e) {
31726       {
31727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31728       };
31729     } catch (...) {
31730       {
31731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31732       };
31733     }
31734   }
31735   jresult = result;
31736   return jresult;
31737 }
31738
31739
31740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
31741   unsigned int jresult ;
31742   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31743   Dali::Renderer *arg2 = 0 ;
31744   unsigned int result;
31745
31746   arg1 = (Dali::Actor *)jarg1;
31747   arg2 = (Dali::Renderer *)jarg2;
31748   if (!arg2) {
31749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31750     return 0;
31751   }
31752   {
31753     try {
31754       result = (unsigned int)(arg1)->AddRenderer(*arg2);
31755     } catch (std::out_of_range& e) {
31756       {
31757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31758       };
31759     } catch (std::exception& e) {
31760       {
31761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31762       };
31763     } catch (...) {
31764       {
31765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31766       };
31767     }
31768   }
31769   jresult = result;
31770   return jresult;
31771 }
31772
31773
31774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
31775   unsigned int jresult ;
31776   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31777   unsigned int result;
31778
31779   arg1 = (Dali::Actor *)jarg1;
31780   {
31781     try {
31782       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
31783     } catch (std::out_of_range& e) {
31784       {
31785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31786       };
31787     } catch (std::exception& e) {
31788       {
31789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31790       };
31791     } catch (...) {
31792       {
31793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31794       };
31795     }
31796   }
31797   jresult = result;
31798   return jresult;
31799 }
31800
31801
31802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
31803   void * jresult ;
31804   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31805   unsigned int arg2 ;
31806   Dali::Renderer result;
31807
31808   arg1 = (Dali::Actor *)jarg1;
31809   arg2 = (unsigned int)jarg2;
31810   {
31811     try {
31812       result = (arg1)->GetRendererAt(arg2);
31813     } catch (std::out_of_range& e) {
31814       {
31815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31816       };
31817     } catch (std::exception& e) {
31818       {
31819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31820       };
31821     } catch (...) {
31822       {
31823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31824       };
31825     }
31826   }
31827   jresult = new Dali::Renderer((const Dali::Renderer &)result);
31828   return jresult;
31829 }
31830
31831
31832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
31833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31834   Dali::Renderer *arg2 = 0 ;
31835
31836   arg1 = (Dali::Actor *)jarg1;
31837   arg2 = (Dali::Renderer *)jarg2;
31838   if (!arg2) {
31839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31840     return ;
31841   }
31842   {
31843     try {
31844       (arg1)->RemoveRenderer(*arg2);
31845     } catch (std::out_of_range& e) {
31846       {
31847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31848       };
31849     } catch (std::exception& e) {
31850       {
31851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31852       };
31853     } catch (...) {
31854       {
31855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31856       };
31857     }
31858   }
31859 }
31860
31861
31862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
31863   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31864   unsigned int arg2 ;
31865
31866   arg1 = (Dali::Actor *)jarg1;
31867   arg2 = (unsigned int)jarg2;
31868   {
31869     try {
31870       (arg1)->RemoveRenderer(arg2);
31871     } catch (std::out_of_range& e) {
31872       {
31873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31874       };
31875     } catch (std::exception& e) {
31876       {
31877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31878       };
31879     } catch (...) {
31880       {
31881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31882       };
31883     }
31884   }
31885 }
31886
31887
31888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
31889   void * jresult ;
31890   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31891   Dali::Actor::TouchSignalType *result = 0 ;
31892
31893   arg1 = (Dali::Actor *)jarg1;
31894   {
31895     try {
31896       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
31897     } catch (std::out_of_range& e) {
31898       {
31899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31900       };
31901     } catch (std::exception& e) {
31902       {
31903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31904       };
31905     } catch (...) {
31906       {
31907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31908       };
31909     }
31910   }
31911   jresult = (void *)result;
31912   return jresult;
31913 }
31914
31915
31916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
31917   void * jresult ;
31918   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31919   Dali::Actor::TouchDataSignalType *result = 0 ;
31920
31921   arg1 = (Dali::Actor *)jarg1;
31922   {
31923     try {
31924       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
31925     } catch (std::out_of_range& e) {
31926       {
31927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31928       };
31929     } catch (std::exception& e) {
31930       {
31931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31932       };
31933     } catch (...) {
31934       {
31935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31936       };
31937     }
31938   }
31939   jresult = (void *)result;
31940   return jresult;
31941 }
31942
31943
31944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
31945   void * jresult ;
31946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31947   Dali::Actor::HoverSignalType *result = 0 ;
31948
31949   arg1 = (Dali::Actor *)jarg1;
31950   {
31951     try {
31952       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
31953     } catch (std::out_of_range& e) {
31954       {
31955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31956       };
31957     } catch (std::exception& e) {
31958       {
31959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31960       };
31961     } catch (...) {
31962       {
31963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31964       };
31965     }
31966   }
31967   jresult = (void *)result;
31968   return jresult;
31969 }
31970
31971
31972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
31973   void * jresult ;
31974   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31975   Dali::Actor::WheelEventSignalType *result = 0 ;
31976
31977   arg1 = (Dali::Actor *)jarg1;
31978   {
31979     try {
31980       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
31981     } catch (std::out_of_range& e) {
31982       {
31983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31984       };
31985     } catch (std::exception& e) {
31986       {
31987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31988       };
31989     } catch (...) {
31990       {
31991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31992       };
31993     }
31994   }
31995   jresult = (void *)result;
31996   return jresult;
31997 }
31998
31999
32000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32001   void * jresult ;
32002   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32003   Dali::Actor::OnStageSignalType *result = 0 ;
32004
32005   arg1 = (Dali::Actor *)jarg1;
32006   {
32007     try {
32008       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32009     } catch (std::out_of_range& e) {
32010       {
32011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32012       };
32013     } catch (std::exception& e) {
32014       {
32015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32016       };
32017     } catch (...) {
32018       {
32019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32020       };
32021     }
32022   }
32023   jresult = (void *)result;
32024   return jresult;
32025 }
32026
32027
32028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32029   void * jresult ;
32030   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32031   Dali::Actor::OffStageSignalType *result = 0 ;
32032
32033   arg1 = (Dali::Actor *)jarg1;
32034   {
32035     try {
32036       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32037     } catch (std::out_of_range& e) {
32038       {
32039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32040       };
32041     } catch (std::exception& e) {
32042       {
32043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32044       };
32045     } catch (...) {
32046       {
32047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32048       };
32049     }
32050   }
32051   jresult = (void *)result;
32052   return jresult;
32053 }
32054
32055
32056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32057   void * jresult ;
32058   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32059   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32060
32061   arg1 = (Dali::Actor *)jarg1;
32062   {
32063     try {
32064       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32065     } catch (std::out_of_range& e) {
32066       {
32067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32068       };
32069     } catch (std::exception& e) {
32070       {
32071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32072       };
32073     } catch (...) {
32074       {
32075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32076       };
32077     }
32078   }
32079   jresult = (void *)result;
32080   return jresult;
32081 }
32082
32083
32084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32085   Dali::Actor *arg1 = 0 ;
32086
32087   arg1 = (Dali::Actor *)jarg1;
32088   if (!arg1) {
32089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32090     return ;
32091   }
32092   {
32093     try {
32094       Dali::UnparentAndReset(*arg1);
32095     } catch (std::out_of_range& e) {
32096       {
32097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32098       };
32099     } catch (std::exception& e) {
32100       {
32101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32102       };
32103     } catch (...) {
32104       {
32105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32106       };
32107     }
32108   }
32109 }
32110
32111
32112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32113   Dali::Actor arg1 ;
32114   Dali::Actor *argp1 ;
32115
32116   argp1 = (Dali::Actor *)jarg1;
32117   if (!argp1) {
32118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32119     return ;
32120   }
32121   arg1 = *argp1;
32122   {
32123     try {
32124       Dali::DevelActor::Raise(arg1);
32125     } catch (std::out_of_range& e) {
32126       {
32127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32128       };
32129     } catch (std::exception& e) {
32130       {
32131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32132       };
32133     } catch (...) {
32134       {
32135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32136       };
32137     }
32138   }
32139 }
32140
32141
32142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32143   Dali::Actor arg1 ;
32144   Dali::Actor *argp1 ;
32145
32146   argp1 = (Dali::Actor *)jarg1;
32147   if (!argp1) {
32148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32149     return ;
32150   }
32151   arg1 = *argp1;
32152   {
32153     try {
32154       Dali::DevelActor::Lower(arg1);
32155     } catch (std::out_of_range& e) {
32156       {
32157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32158       };
32159     } catch (std::exception& e) {
32160       {
32161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32162       };
32163     } catch (...) {
32164       {
32165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32166       };
32167     }
32168   }
32169 }
32170
32171
32172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32173   Dali::Actor arg1 ;
32174   Dali::Actor *argp1 ;
32175
32176   argp1 = (Dali::Actor *)jarg1;
32177   if (!argp1) {
32178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32179     return ;
32180   }
32181   arg1 = *argp1;
32182   {
32183     try {
32184       Dali::DevelActor::RaiseToTop(arg1);
32185     } catch (std::out_of_range& e) {
32186       {
32187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32188       };
32189     } catch (std::exception& e) {
32190       {
32191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32192       };
32193     } catch (...) {
32194       {
32195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32196       };
32197     }
32198   }
32199 }
32200
32201
32202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32203   Dali::Actor arg1 ;
32204   Dali::Actor *argp1 ;
32205
32206   argp1 = (Dali::Actor *)jarg1;
32207   if (!argp1) {
32208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32209     return ;
32210   }
32211   arg1 = *argp1;
32212   {
32213     try {
32214       Dali::DevelActor::LowerToBottom(arg1);
32215     } catch (std::out_of_range& e) {
32216       {
32217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32218       };
32219     } catch (std::exception& e) {
32220       {
32221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32222       };
32223     } catch (...) {
32224       {
32225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32226       };
32227     }
32228   }
32229 }
32230
32231
32232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32233   Dali::Actor arg1 ;
32234   Dali::Actor arg2 ;
32235   Dali::Actor *argp1 ;
32236   Dali::Actor *argp2 ;
32237
32238   argp1 = (Dali::Actor *)jarg1;
32239   if (!argp1) {
32240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32241     return ;
32242   }
32243   arg1 = *argp1;
32244   argp2 = (Dali::Actor *)jarg2;
32245   if (!argp2) {
32246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32247     return ;
32248   }
32249   arg2 = *argp2;
32250   {
32251     try {
32252       Dali::DevelActor::RaiseAbove(arg1,arg2);
32253     } catch (std::out_of_range& e) {
32254       {
32255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32256       };
32257     } catch (std::exception& e) {
32258       {
32259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32260       };
32261     } catch (...) {
32262       {
32263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32264       };
32265     }
32266   }
32267 }
32268
32269
32270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32271   Dali::Actor arg1 ;
32272   Dali::Actor arg2 ;
32273   Dali::Actor *argp1 ;
32274   Dali::Actor *argp2 ;
32275
32276   argp1 = (Dali::Actor *)jarg1;
32277   if (!argp1) {
32278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32279     return ;
32280   }
32281   arg1 = *argp1;
32282   argp2 = (Dali::Actor *)jarg2;
32283   if (!argp2) {
32284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32285     return ;
32286   }
32287   arg2 = *argp2;
32288   {
32289     try {
32290       Dali::DevelActor::LowerBelow(arg1,arg2);
32291     } catch (std::out_of_range& e) {
32292       {
32293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32294       };
32295     } catch (std::exception& e) {
32296       {
32297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32298       };
32299     } catch (...) {
32300       {
32301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32302       };
32303     }
32304   }
32305 }
32306
32307
32308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32309   int jresult ;
32310   int result;
32311
32312   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32313   jresult = (int)result;
32314   return jresult;
32315 }
32316
32317
32318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32319   int jresult ;
32320   int result;
32321
32322   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32323   jresult = (int)result;
32324   return jresult;
32325 }
32326
32327
32328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32329   int jresult ;
32330   int result;
32331
32332   result = (int)Dali::Layer::Property::BEHAVIOR;
32333   jresult = (int)result;
32334   return jresult;
32335 }
32336
32337
32338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32339   void * jresult ;
32340   Dali::Layer::Property *result = 0 ;
32341
32342   {
32343     try {
32344       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32345     } catch (std::out_of_range& e) {
32346       {
32347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32348       };
32349     } catch (std::exception& e) {
32350       {
32351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32352       };
32353     } catch (...) {
32354       {
32355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32356       };
32357     }
32358   }
32359   jresult = (void *)result;
32360   return jresult;
32361 }
32362
32363
32364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32365   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32366
32367   arg1 = (Dali::Layer::Property *)jarg1;
32368   {
32369     try {
32370       delete arg1;
32371     } catch (std::out_of_range& e) {
32372       {
32373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32374       };
32375     } catch (std::exception& e) {
32376       {
32377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32378       };
32379     } catch (...) {
32380       {
32381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32382       };
32383     }
32384   }
32385 }
32386
32387
32388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32389   void * jresult ;
32390   Dali::Layer *result = 0 ;
32391
32392   {
32393     try {
32394       result = (Dali::Layer *)new Dali::Layer();
32395     } catch (std::out_of_range& e) {
32396       {
32397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32398       };
32399     } catch (std::exception& e) {
32400       {
32401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32402       };
32403     } catch (...) {
32404       {
32405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32406       };
32407     }
32408   }
32409   jresult = (void *)result;
32410   return jresult;
32411 }
32412
32413
32414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32415   void * jresult ;
32416   Dali::Layer result;
32417
32418   {
32419     try {
32420       result = Dali::Layer::New();
32421     } catch (std::out_of_range& e) {
32422       {
32423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32424       };
32425     } catch (std::exception& e) {
32426       {
32427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32428       };
32429     } catch (...) {
32430       {
32431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32432       };
32433     }
32434   }
32435   jresult = new Dali::Layer((const Dali::Layer &)result);
32436   return jresult;
32437 }
32438
32439
32440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32441   void * jresult ;
32442   Dali::BaseHandle arg1 ;
32443   Dali::BaseHandle *argp1 ;
32444   Dali::Layer result;
32445
32446   argp1 = (Dali::BaseHandle *)jarg1;
32447   if (!argp1) {
32448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32449     return 0;
32450   }
32451   arg1 = *argp1;
32452   {
32453     try {
32454       result = Dali::Layer::DownCast(arg1);
32455     } catch (std::out_of_range& e) {
32456       {
32457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32458       };
32459     } catch (std::exception& e) {
32460       {
32461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32462       };
32463     } catch (...) {
32464       {
32465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32466       };
32467     }
32468   }
32469   jresult = new Dali::Layer((const Dali::Layer &)result);
32470   return jresult;
32471 }
32472
32473
32474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32475   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32476
32477   arg1 = (Dali::Layer *)jarg1;
32478   {
32479     try {
32480       delete arg1;
32481     } catch (std::out_of_range& e) {
32482       {
32483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32484       };
32485     } catch (std::exception& e) {
32486       {
32487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32488       };
32489     } catch (...) {
32490       {
32491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32492       };
32493     }
32494   }
32495 }
32496
32497
32498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32499   void * jresult ;
32500   Dali::Layer *arg1 = 0 ;
32501   Dali::Layer *result = 0 ;
32502
32503   arg1 = (Dali::Layer *)jarg1;
32504   if (!arg1) {
32505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32506     return 0;
32507   }
32508   {
32509     try {
32510       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32511     } catch (std::out_of_range& e) {
32512       {
32513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32514       };
32515     } catch (std::exception& e) {
32516       {
32517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32518       };
32519     } catch (...) {
32520       {
32521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32522       };
32523     }
32524   }
32525   jresult = (void *)result;
32526   return jresult;
32527 }
32528
32529
32530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32531   void * jresult ;
32532   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32533   Dali::Layer *arg2 = 0 ;
32534   Dali::Layer *result = 0 ;
32535
32536   arg1 = (Dali::Layer *)jarg1;
32537   arg2 = (Dali::Layer *)jarg2;
32538   if (!arg2) {
32539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32540     return 0;
32541   }
32542   {
32543     try {
32544       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32545     } catch (std::out_of_range& e) {
32546       {
32547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32548       };
32549     } catch (std::exception& e) {
32550       {
32551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32552       };
32553     } catch (...) {
32554       {
32555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32556       };
32557     }
32558   }
32559   jresult = (void *)result;
32560   return jresult;
32561 }
32562
32563
32564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32565   unsigned int jresult ;
32566   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32567   unsigned int result;
32568
32569   arg1 = (Dali::Layer *)jarg1;
32570   {
32571     try {
32572       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32573     } catch (std::out_of_range& e) {
32574       {
32575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32576       };
32577     } catch (std::exception& e) {
32578       {
32579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32580       };
32581     } catch (...) {
32582       {
32583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32584       };
32585     }
32586   }
32587   jresult = result;
32588   return jresult;
32589 }
32590
32591
32592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32593   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32594
32595   arg1 = (Dali::Layer *)jarg1;
32596   {
32597     try {
32598       (arg1)->Raise();
32599     } catch (std::out_of_range& e) {
32600       {
32601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32602       };
32603     } catch (std::exception& e) {
32604       {
32605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32606       };
32607     } catch (...) {
32608       {
32609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32610       };
32611     }
32612   }
32613 }
32614
32615
32616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32617   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32618
32619   arg1 = (Dali::Layer *)jarg1;
32620   {
32621     try {
32622       (arg1)->Lower();
32623     } catch (std::out_of_range& e) {
32624       {
32625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32626       };
32627     } catch (std::exception& e) {
32628       {
32629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32630       };
32631     } catch (...) {
32632       {
32633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32634       };
32635     }
32636   }
32637 }
32638
32639
32640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32641   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32642   Dali::Layer arg2 ;
32643   Dali::Layer *argp2 ;
32644
32645   arg1 = (Dali::Layer *)jarg1;
32646   argp2 = (Dali::Layer *)jarg2;
32647   if (!argp2) {
32648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32649     return ;
32650   }
32651   arg2 = *argp2;
32652   {
32653     try {
32654       (arg1)->RaiseAbove(arg2);
32655     } catch (std::out_of_range& e) {
32656       {
32657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32658       };
32659     } catch (std::exception& e) {
32660       {
32661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32662       };
32663     } catch (...) {
32664       {
32665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32666       };
32667     }
32668   }
32669 }
32670
32671
32672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32673   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32674   Dali::Layer arg2 ;
32675   Dali::Layer *argp2 ;
32676
32677   arg1 = (Dali::Layer *)jarg1;
32678   argp2 = (Dali::Layer *)jarg2;
32679   if (!argp2) {
32680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32681     return ;
32682   }
32683   arg2 = *argp2;
32684   {
32685     try {
32686       (arg1)->LowerBelow(arg2);
32687     } catch (std::out_of_range& e) {
32688       {
32689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32690       };
32691     } catch (std::exception& e) {
32692       {
32693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32694       };
32695     } catch (...) {
32696       {
32697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32698       };
32699     }
32700   }
32701 }
32702
32703
32704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32705   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32706
32707   arg1 = (Dali::Layer *)jarg1;
32708   {
32709     try {
32710       (arg1)->RaiseToTop();
32711     } catch (std::out_of_range& e) {
32712       {
32713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32714       };
32715     } catch (std::exception& e) {
32716       {
32717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32718       };
32719     } catch (...) {
32720       {
32721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32722       };
32723     }
32724   }
32725 }
32726
32727
32728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32729   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32730
32731   arg1 = (Dali::Layer *)jarg1;
32732   {
32733     try {
32734       (arg1)->LowerToBottom();
32735     } catch (std::out_of_range& e) {
32736       {
32737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32738       };
32739     } catch (std::exception& e) {
32740       {
32741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32742       };
32743     } catch (...) {
32744       {
32745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32746       };
32747     }
32748   }
32749 }
32750
32751
32752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32753   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32754   Dali::Layer arg2 ;
32755   Dali::Layer *argp2 ;
32756
32757   arg1 = (Dali::Layer *)jarg1;
32758   argp2 = (Dali::Layer *)jarg2;
32759   if (!argp2) {
32760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32761     return ;
32762   }
32763   arg2 = *argp2;
32764   {
32765     try {
32766       (arg1)->MoveAbove(arg2);
32767     } catch (std::out_of_range& e) {
32768       {
32769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32770       };
32771     } catch (std::exception& e) {
32772       {
32773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32774       };
32775     } catch (...) {
32776       {
32777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32778       };
32779     }
32780   }
32781 }
32782
32783
32784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32785   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32786   Dali::Layer arg2 ;
32787   Dali::Layer *argp2 ;
32788
32789   arg1 = (Dali::Layer *)jarg1;
32790   argp2 = (Dali::Layer *)jarg2;
32791   if (!argp2) {
32792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32793     return ;
32794   }
32795   arg2 = *argp2;
32796   {
32797     try {
32798       (arg1)->MoveBelow(arg2);
32799     } catch (std::out_of_range& e) {
32800       {
32801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32802       };
32803     } catch (std::exception& e) {
32804       {
32805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32806       };
32807     } catch (...) {
32808       {
32809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32810       };
32811     }
32812   }
32813 }
32814
32815
32816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32817   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32818   Dali::Layer::Behavior arg2 ;
32819
32820   arg1 = (Dali::Layer *)jarg1;
32821   arg2 = (Dali::Layer::Behavior)jarg2;
32822   {
32823     try {
32824       (arg1)->SetBehavior(arg2);
32825     } catch (std::out_of_range& e) {
32826       {
32827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32828       };
32829     } catch (std::exception& e) {
32830       {
32831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32832       };
32833     } catch (...) {
32834       {
32835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32836       };
32837     }
32838   }
32839 }
32840
32841
32842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
32843   int jresult ;
32844   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32845   Dali::Layer::Behavior result;
32846
32847   arg1 = (Dali::Layer *)jarg1;
32848   {
32849     try {
32850       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32851     } catch (std::out_of_range& e) {
32852       {
32853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32854       };
32855     } catch (std::exception& e) {
32856       {
32857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32858       };
32859     } catch (...) {
32860       {
32861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32862       };
32863     }
32864   }
32865   jresult = (int)result;
32866   return jresult;
32867 }
32868
32869
32870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
32871   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32872   bool arg2 ;
32873
32874   arg1 = (Dali::Layer *)jarg1;
32875   arg2 = jarg2 ? true : false;
32876   {
32877     try {
32878       (arg1)->SetClipping(arg2);
32879     } catch (std::out_of_range& e) {
32880       {
32881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32882       };
32883     } catch (std::exception& e) {
32884       {
32885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32886       };
32887     } catch (...) {
32888       {
32889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32890       };
32891     }
32892   }
32893 }
32894
32895
32896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
32897   unsigned int jresult ;
32898   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32899   bool result;
32900
32901   arg1 = (Dali::Layer *)jarg1;
32902   {
32903     try {
32904       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
32905     } catch (std::out_of_range& e) {
32906       {
32907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32908       };
32909     } catch (std::exception& e) {
32910       {
32911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32912       };
32913     } catch (...) {
32914       {
32915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32916       };
32917     }
32918   }
32919   jresult = result;
32920   return jresult;
32921 }
32922
32923
32924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
32925   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32926   int arg2 ;
32927   int arg3 ;
32928   int arg4 ;
32929   int arg5 ;
32930
32931   arg1 = (Dali::Layer *)jarg1;
32932   arg2 = (int)jarg2;
32933   arg3 = (int)jarg3;
32934   arg4 = (int)jarg4;
32935   arg5 = (int)jarg5;
32936   {
32937     try {
32938       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
32939     } catch (std::out_of_range& e) {
32940       {
32941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32942       };
32943     } catch (std::exception& e) {
32944       {
32945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32946       };
32947     } catch (...) {
32948       {
32949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32950       };
32951     }
32952   }
32953 }
32954
32955
32956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
32957   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32958   Dali::ClippingBox arg2 ;
32959   Dali::ClippingBox *argp2 ;
32960
32961   arg1 = (Dali::Layer *)jarg1;
32962   argp2 = (Dali::ClippingBox *)jarg2;
32963   if (!argp2) {
32964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
32965     return ;
32966   }
32967   arg2 = *argp2;
32968   {
32969     try {
32970       (arg1)->SetClippingBox(arg2);
32971     } catch (std::out_of_range& e) {
32972       {
32973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32974       };
32975     } catch (std::exception& e) {
32976       {
32977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32978       };
32979     } catch (...) {
32980       {
32981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32982       };
32983     }
32984   }
32985 }
32986
32987
32988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
32989   void * jresult ;
32990   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32991   Dali::ClippingBox result;
32992
32993   arg1 = (Dali::Layer *)jarg1;
32994   {
32995     try {
32996       result = ((Dali::Layer const *)arg1)->GetClippingBox();
32997     } catch (std::out_of_range& e) {
32998       {
32999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33000       };
33001     } catch (std::exception& e) {
33002       {
33003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33004       };
33005     } catch (...) {
33006       {
33007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33008       };
33009     }
33010   }
33011   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33012   return jresult;
33013 }
33014
33015
33016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33017   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33018   bool arg2 ;
33019
33020   arg1 = (Dali::Layer *)jarg1;
33021   arg2 = jarg2 ? true : false;
33022   {
33023     try {
33024       (arg1)->SetDepthTestDisabled(arg2);
33025     } catch (std::out_of_range& e) {
33026       {
33027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33028       };
33029     } catch (std::exception& e) {
33030       {
33031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33032       };
33033     } catch (...) {
33034       {
33035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33036       };
33037     }
33038   }
33039 }
33040
33041
33042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33043   unsigned int jresult ;
33044   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33045   bool result;
33046
33047   arg1 = (Dali::Layer *)jarg1;
33048   {
33049     try {
33050       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33051     } catch (std::out_of_range& e) {
33052       {
33053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33054       };
33055     } catch (std::exception& e) {
33056       {
33057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33058       };
33059     } catch (...) {
33060       {
33061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33062       };
33063     }
33064   }
33065   jresult = result;
33066   return jresult;
33067 }
33068
33069
33070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33071   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33072   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33073
33074   arg1 = (Dali::Layer *)jarg1;
33075   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33076   {
33077     try {
33078       (arg1)->SetSortFunction(arg2);
33079     } catch (std::out_of_range& e) {
33080       {
33081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33082       };
33083     } catch (std::exception& e) {
33084       {
33085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33086       };
33087     } catch (...) {
33088       {
33089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33090       };
33091     }
33092   }
33093 }
33094
33095
33096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33097   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33098   bool arg2 ;
33099
33100   arg1 = (Dali::Layer *)jarg1;
33101   arg2 = jarg2 ? true : false;
33102   {
33103     try {
33104       (arg1)->SetTouchConsumed(arg2);
33105     } catch (std::out_of_range& e) {
33106       {
33107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33108       };
33109     } catch (std::exception& e) {
33110       {
33111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33112       };
33113     } catch (...) {
33114       {
33115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33116       };
33117     }
33118   }
33119 }
33120
33121
33122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33123   unsigned int jresult ;
33124   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33125   bool result;
33126
33127   arg1 = (Dali::Layer *)jarg1;
33128   {
33129     try {
33130       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33131     } catch (std::out_of_range& e) {
33132       {
33133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33134       };
33135     } catch (std::exception& e) {
33136       {
33137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33138       };
33139     } catch (...) {
33140       {
33141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33142       };
33143     }
33144   }
33145   jresult = result;
33146   return jresult;
33147 }
33148
33149
33150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33151   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33152   bool arg2 ;
33153
33154   arg1 = (Dali::Layer *)jarg1;
33155   arg2 = jarg2 ? true : false;
33156   {
33157     try {
33158       (arg1)->SetHoverConsumed(arg2);
33159     } catch (std::out_of_range& e) {
33160       {
33161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33162       };
33163     } catch (std::exception& e) {
33164       {
33165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33166       };
33167     } catch (...) {
33168       {
33169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33170       };
33171     }
33172   }
33173 }
33174
33175
33176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33177   unsigned int jresult ;
33178   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33179   bool result;
33180
33181   arg1 = (Dali::Layer *)jarg1;
33182   {
33183     try {
33184       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33185     } catch (std::out_of_range& e) {
33186       {
33187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33188       };
33189     } catch (std::exception& e) {
33190       {
33191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33192       };
33193     } catch (...) {
33194       {
33195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33196       };
33197     }
33198   }
33199   jresult = result;
33200   return jresult;
33201 }
33202
33203
33204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33205   void * jresult ;
33206   Dali::Vector4 *result = 0 ;
33207
33208   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33209   jresult = (void *)result;
33210   return jresult;
33211 }
33212
33213
33214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33215   void * jresult ;
33216   Dali::Vector4 *result = 0 ;
33217
33218   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33219   jresult = (void *)result;
33220   return jresult;
33221 }
33222
33223
33224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33225   void * jresult ;
33226   Dali::Stage *result = 0 ;
33227
33228   {
33229     try {
33230       result = (Dali::Stage *)new Dali::Stage();
33231     } catch (std::out_of_range& e) {
33232       {
33233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33234       };
33235     } catch (std::exception& e) {
33236       {
33237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33238       };
33239     } catch (...) {
33240       {
33241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33242       };
33243     }
33244   }
33245   jresult = (void *)result;
33246   return jresult;
33247 }
33248
33249
33250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33251   void * jresult ;
33252   Dali::Stage result;
33253
33254   {
33255     try {
33256       result = Dali::Stage::GetCurrent();
33257     } catch (std::out_of_range& e) {
33258       {
33259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33260       };
33261     } catch (std::exception& e) {
33262       {
33263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33264       };
33265     } catch (...) {
33266       {
33267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33268       };
33269     }
33270   }
33271   jresult = new Dali::Stage((const Dali::Stage &)result);
33272   return jresult;
33273 }
33274
33275
33276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33277   unsigned int jresult ;
33278   bool result;
33279
33280   {
33281     try {
33282       result = (bool)Dali::Stage::IsInstalled();
33283     } catch (std::out_of_range& e) {
33284       {
33285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33286       };
33287     } catch (std::exception& e) {
33288       {
33289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33290       };
33291     } catch (...) {
33292       {
33293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33294       };
33295     }
33296   }
33297   jresult = result;
33298   return jresult;
33299 }
33300
33301
33302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33303   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33304
33305   arg1 = (Dali::Stage *)jarg1;
33306   {
33307     try {
33308       delete arg1;
33309     } catch (std::out_of_range& e) {
33310       {
33311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33312       };
33313     } catch (std::exception& e) {
33314       {
33315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33316       };
33317     } catch (...) {
33318       {
33319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33320       };
33321     }
33322   }
33323 }
33324
33325
33326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33327   void * jresult ;
33328   Dali::Stage *arg1 = 0 ;
33329   Dali::Stage *result = 0 ;
33330
33331   arg1 = (Dali::Stage *)jarg1;
33332   if (!arg1) {
33333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33334     return 0;
33335   }
33336   {
33337     try {
33338       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33339     } catch (std::out_of_range& e) {
33340       {
33341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33342       };
33343     } catch (std::exception& e) {
33344       {
33345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33346       };
33347     } catch (...) {
33348       {
33349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33350       };
33351     }
33352   }
33353   jresult = (void *)result;
33354   return jresult;
33355 }
33356
33357
33358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33359   void * jresult ;
33360   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33361   Dali::Stage *arg2 = 0 ;
33362   Dali::Stage *result = 0 ;
33363
33364   arg1 = (Dali::Stage *)jarg1;
33365   arg2 = (Dali::Stage *)jarg2;
33366   if (!arg2) {
33367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33368     return 0;
33369   }
33370   {
33371     try {
33372       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33373     } catch (std::out_of_range& e) {
33374       {
33375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33376       };
33377     } catch (std::exception& e) {
33378       {
33379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33380       };
33381     } catch (...) {
33382       {
33383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33384       };
33385     }
33386   }
33387   jresult = (void *)result;
33388   return jresult;
33389 }
33390
33391
33392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33393   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33394   Dali::Actor *arg2 = 0 ;
33395
33396   arg1 = (Dali::Stage *)jarg1;
33397   arg2 = (Dali::Actor *)jarg2;
33398   if (!arg2) {
33399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33400     return ;
33401   }
33402   {
33403     try {
33404       (arg1)->Add(*arg2);
33405     } catch (std::out_of_range& e) {
33406       {
33407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33408       };
33409     } catch (std::exception& e) {
33410       {
33411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33412       };
33413     } catch (...) {
33414       {
33415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33416       };
33417     }
33418   }
33419 }
33420
33421
33422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33423   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33424   Dali::Actor *arg2 = 0 ;
33425
33426   arg1 = (Dali::Stage *)jarg1;
33427   arg2 = (Dali::Actor *)jarg2;
33428   if (!arg2) {
33429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33430     return ;
33431   }
33432   {
33433     try {
33434       (arg1)->Remove(*arg2);
33435     } catch (std::out_of_range& e) {
33436       {
33437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33438       };
33439     } catch (std::exception& e) {
33440       {
33441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33442       };
33443     } catch (...) {
33444       {
33445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33446       };
33447     }
33448   }
33449 }
33450
33451
33452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33453   void * jresult ;
33454   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33455   Dali::Vector2 result;
33456
33457   arg1 = (Dali::Stage *)jarg1;
33458   {
33459     try {
33460       result = ((Dali::Stage const *)arg1)->GetSize();
33461     } catch (std::out_of_range& e) {
33462       {
33463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33464       };
33465     } catch (std::exception& e) {
33466       {
33467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33468       };
33469     } catch (...) {
33470       {
33471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33472       };
33473     }
33474   }
33475   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33476   return jresult;
33477 }
33478
33479
33480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33481   void * jresult ;
33482   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33483   Dali::RenderTaskList result;
33484
33485   arg1 = (Dali::Stage *)jarg1;
33486   {
33487     try {
33488       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33489     } catch (std::out_of_range& e) {
33490       {
33491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33492       };
33493     } catch (std::exception& e) {
33494       {
33495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33496       };
33497     } catch (...) {
33498       {
33499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33500       };
33501     }
33502   }
33503   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33504   return jresult;
33505 }
33506
33507
33508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33509   unsigned int jresult ;
33510   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33511   unsigned int result;
33512
33513   arg1 = (Dali::Stage *)jarg1;
33514   {
33515     try {
33516       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33517     } catch (std::out_of_range& e) {
33518       {
33519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33520       };
33521     } catch (std::exception& e) {
33522       {
33523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33524       };
33525     } catch (...) {
33526       {
33527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33528       };
33529     }
33530   }
33531   jresult = result;
33532   return jresult;
33533 }
33534
33535
33536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33537   void * jresult ;
33538   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33539   unsigned int arg2 ;
33540   Dali::Layer result;
33541
33542   arg1 = (Dali::Stage *)jarg1;
33543   arg2 = (unsigned int)jarg2;
33544   {
33545     try {
33546       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33547     } catch (std::out_of_range& e) {
33548       {
33549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33550       };
33551     } catch (std::exception& e) {
33552       {
33553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33554       };
33555     } catch (...) {
33556       {
33557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33558       };
33559     }
33560   }
33561   jresult = new Dali::Layer((const Dali::Layer &)result);
33562   return jresult;
33563 }
33564
33565
33566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33567   void * jresult ;
33568   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33569   Dali::Layer result;
33570
33571   arg1 = (Dali::Stage *)jarg1;
33572   {
33573     try {
33574       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33575     } catch (std::out_of_range& e) {
33576       {
33577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33578       };
33579     } catch (std::exception& e) {
33580       {
33581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33582       };
33583     } catch (...) {
33584       {
33585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33586       };
33587     }
33588   }
33589   jresult = new Dali::Layer((const Dali::Layer &)result);
33590   return jresult;
33591 }
33592
33593
33594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33595   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33596   Dali::Vector4 arg2 ;
33597   Dali::Vector4 *argp2 ;
33598
33599   arg1 = (Dali::Stage *)jarg1;
33600   argp2 = (Dali::Vector4 *)jarg2;
33601   if (!argp2) {
33602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33603     return ;
33604   }
33605   arg2 = *argp2;
33606   {
33607     try {
33608       (arg1)->SetBackgroundColor(arg2);
33609     } catch (std::out_of_range& e) {
33610       {
33611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33612       };
33613     } catch (std::exception& e) {
33614       {
33615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33616       };
33617     } catch (...) {
33618       {
33619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33620       };
33621     }
33622   }
33623 }
33624
33625
33626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33627   void * jresult ;
33628   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33629   Dali::Vector4 result;
33630
33631   arg1 = (Dali::Stage *)jarg1;
33632   {
33633     try {
33634       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33635     } catch (std::out_of_range& e) {
33636       {
33637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33638       };
33639     } catch (std::exception& e) {
33640       {
33641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33642       };
33643     } catch (...) {
33644       {
33645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33646       };
33647     }
33648   }
33649   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33650   return jresult;
33651 }
33652
33653
33654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33655   void * jresult ;
33656   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33657   Dali::Vector2 result;
33658
33659   arg1 = (Dali::Stage *)jarg1;
33660   {
33661     try {
33662       result = ((Dali::Stage const *)arg1)->GetDpi();
33663     } catch (std::out_of_range& e) {
33664       {
33665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33666       };
33667     } catch (std::exception& e) {
33668       {
33669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33670       };
33671     } catch (...) {
33672       {
33673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33674       };
33675     }
33676   }
33677   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33678   return jresult;
33679 }
33680
33681
33682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33683   void * jresult ;
33684   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33685   Dali::ObjectRegistry result;
33686
33687   arg1 = (Dali::Stage *)jarg1;
33688   {
33689     try {
33690       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33691     } catch (std::out_of_range& e) {
33692       {
33693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33694       };
33695     } catch (std::exception& e) {
33696       {
33697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33698       };
33699     } catch (...) {
33700       {
33701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33702       };
33703     }
33704   }
33705   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33706   return jresult;
33707 }
33708
33709
33710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33711   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33712   float arg2 ;
33713
33714   arg1 = (Dali::Stage *)jarg1;
33715   arg2 = (float)jarg2;
33716   {
33717     try {
33718       (arg1)->KeepRendering(arg2);
33719     } catch (std::out_of_range& e) {
33720       {
33721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33722       };
33723     } catch (std::exception& e) {
33724       {
33725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33726       };
33727     } catch (...) {
33728       {
33729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33730       };
33731     }
33732   }
33733 }
33734
33735
33736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33737   void * jresult ;
33738   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33739   Dali::Stage::KeyEventSignalType *result = 0 ;
33740
33741   arg1 = (Dali::Stage *)jarg1;
33742   {
33743     try {
33744       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33745     } catch (std::out_of_range& e) {
33746       {
33747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33748       };
33749     } catch (std::exception& e) {
33750       {
33751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33752       };
33753     } catch (...) {
33754       {
33755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33756       };
33757     }
33758   }
33759   jresult = (void *)result;
33760   return jresult;
33761 }
33762
33763
33764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33765   void * jresult ;
33766   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33767   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33768
33769   arg1 = (Dali::Stage *)jarg1;
33770   {
33771     try {
33772       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33773     } catch (std::out_of_range& e) {
33774       {
33775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33776       };
33777     } catch (std::exception& e) {
33778       {
33779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33780       };
33781     } catch (...) {
33782       {
33783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33784       };
33785     }
33786   }
33787   jresult = (void *)result;
33788   return jresult;
33789 }
33790
33791
33792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33793   void * jresult ;
33794   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33795   Dali::Stage::TouchSignalType *result = 0 ;
33796
33797   arg1 = (Dali::Stage *)jarg1;
33798   {
33799     try {
33800       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33801     } catch (std::out_of_range& e) {
33802       {
33803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33804       };
33805     } catch (std::exception& e) {
33806       {
33807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33808       };
33809     } catch (...) {
33810       {
33811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33812       };
33813     }
33814   }
33815   jresult = (void *)result;
33816   return jresult;
33817 }
33818
33819
33820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33821   void * jresult ;
33822   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33823   Dali::Stage::WheelEventSignalType *result = 0 ;
33824
33825   arg1 = (Dali::Stage *)jarg1;
33826   {
33827     try {
33828       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33829     } catch (std::out_of_range& e) {
33830       {
33831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33832       };
33833     } catch (std::exception& e) {
33834       {
33835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33836       };
33837     } catch (...) {
33838       {
33839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33840       };
33841     }
33842   }
33843   jresult = (void *)result;
33844   return jresult;
33845 }
33846
33847
33848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
33849   void * jresult ;
33850   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33851   Dali::Stage::ContextStatusSignal *result = 0 ;
33852
33853   arg1 = (Dali::Stage *)jarg1;
33854   {
33855     try {
33856       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33857     } catch (std::out_of_range& e) {
33858       {
33859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33860       };
33861     } catch (std::exception& e) {
33862       {
33863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33864       };
33865     } catch (...) {
33866       {
33867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33868       };
33869     }
33870   }
33871   jresult = (void *)result;
33872   return jresult;
33873 }
33874
33875
33876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
33877   void * jresult ;
33878   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33879   Dali::Stage::ContextStatusSignal *result = 0 ;
33880
33881   arg1 = (Dali::Stage *)jarg1;
33882   {
33883     try {
33884       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
33885     } catch (std::out_of_range& e) {
33886       {
33887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33888       };
33889     } catch (std::exception& e) {
33890       {
33891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33892       };
33893     } catch (...) {
33894       {
33895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33896       };
33897     }
33898   }
33899   jresult = (void *)result;
33900   return jresult;
33901 }
33902
33903
33904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
33905   void * jresult ;
33906   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33907   Dali::Stage::SceneCreatedSignalType *result = 0 ;
33908
33909   arg1 = (Dali::Stage *)jarg1;
33910   {
33911     try {
33912       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
33913     } catch (std::out_of_range& e) {
33914       {
33915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33916       };
33917     } catch (std::exception& e) {
33918       {
33919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33920       };
33921     } catch (...) {
33922       {
33923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33924       };
33925     }
33926   }
33927   jresult = (void *)result;
33928   return jresult;
33929 }
33930
33931
33932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
33933   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33934
33935   arg1 = (Dali::RelayoutContainer *)jarg1;
33936   {
33937     try {
33938       delete arg1;
33939     } catch (std::out_of_range& e) {
33940       {
33941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33942       };
33943     } catch (std::exception& e) {
33944       {
33945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33946       };
33947     } catch (...) {
33948       {
33949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33950       };
33951     }
33952   }
33953 }
33954
33955
33956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
33957   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33958   Dali::Actor *arg2 = 0 ;
33959   Dali::Vector2 *arg3 = 0 ;
33960
33961   arg1 = (Dali::RelayoutContainer *)jarg1;
33962   arg2 = (Dali::Actor *)jarg2;
33963   if (!arg2) {
33964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33965     return ;
33966   }
33967   arg3 = (Dali::Vector2 *)jarg3;
33968   if (!arg3) {
33969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
33970     return ;
33971   }
33972   {
33973     try {
33974       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
33975     } catch (std::out_of_range& e) {
33976       {
33977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33978       };
33979     } catch (std::exception& e) {
33980       {
33981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33982       };
33983     } catch (...) {
33984       {
33985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33986       };
33987     }
33988   }
33989 }
33990
33991
33992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
33993   void * jresult ;
33994   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33995   Dali::CustomActor result;
33996
33997   arg1 = (Dali::CustomActorImpl *)jarg1;
33998   {
33999     try {
34000       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34001     } catch (std::out_of_range& e) {
34002       {
34003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34004       };
34005     } catch (std::exception& e) {
34006       {
34007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34008       };
34009     } catch (...) {
34010       {
34011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34012       };
34013     }
34014   }
34015   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34016   return jresult;
34017 }
34018
34019
34020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34021   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34022   int arg2 ;
34023
34024   arg1 = (Dali::CustomActorImpl *)jarg1;
34025   arg2 = (int)jarg2;
34026   {
34027     try {
34028       (arg1)->OnStageConnection(arg2);
34029     } catch (std::out_of_range& e) {
34030       {
34031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34032       };
34033     } catch (std::exception& e) {
34034       {
34035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34036       };
34037     } catch (...) {
34038       {
34039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34040       };
34041     }
34042   }
34043 }
34044
34045
34046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34047   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34048
34049   arg1 = (Dali::CustomActorImpl *)jarg1;
34050   {
34051     try {
34052       (arg1)->OnStageDisconnection();
34053     } catch (std::out_of_range& e) {
34054       {
34055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34056       };
34057     } catch (std::exception& e) {
34058       {
34059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34060       };
34061     } catch (...) {
34062       {
34063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34064       };
34065     }
34066   }
34067 }
34068
34069
34070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34071   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34072   Dali::Actor *arg2 = 0 ;
34073
34074   arg1 = (Dali::CustomActorImpl *)jarg1;
34075   arg2 = (Dali::Actor *)jarg2;
34076   if (!arg2) {
34077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34078     return ;
34079   }
34080   {
34081     try {
34082       (arg1)->OnChildAdd(*arg2);
34083     } catch (std::out_of_range& e) {
34084       {
34085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34086       };
34087     } catch (std::exception& e) {
34088       {
34089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34090       };
34091     } catch (...) {
34092       {
34093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34094       };
34095     }
34096   }
34097 }
34098
34099
34100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34101   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34102   Dali::Actor *arg2 = 0 ;
34103
34104   arg1 = (Dali::CustomActorImpl *)jarg1;
34105   arg2 = (Dali::Actor *)jarg2;
34106   if (!arg2) {
34107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34108     return ;
34109   }
34110   {
34111     try {
34112       (arg1)->OnChildRemove(*arg2);
34113     } catch (std::out_of_range& e) {
34114       {
34115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34116       };
34117     } catch (std::exception& e) {
34118       {
34119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34120       };
34121     } catch (...) {
34122       {
34123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34124       };
34125     }
34126   }
34127 }
34128
34129
34130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34131   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34132   Dali::Property::Index arg2 ;
34133   Dali::Property::Value arg3 ;
34134   Dali::Property::Value *argp3 ;
34135
34136   arg1 = (Dali::CustomActorImpl *)jarg1;
34137   arg2 = (Dali::Property::Index)jarg2;
34138   argp3 = (Dali::Property::Value *)jarg3;
34139   if (!argp3) {
34140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34141     return ;
34142   }
34143   arg3 = *argp3;
34144   {
34145     try {
34146       (arg1)->OnPropertySet(arg2,arg3);
34147     } catch (std::out_of_range& e) {
34148       {
34149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34150       };
34151     } catch (std::exception& e) {
34152       {
34153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34154       };
34155     } catch (...) {
34156       {
34157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34158       };
34159     }
34160   }
34161 }
34162
34163
34164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34165   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34166   Dali::Vector3 *arg2 = 0 ;
34167
34168   arg1 = (Dali::CustomActorImpl *)jarg1;
34169   arg2 = (Dali::Vector3 *)jarg2;
34170   if (!arg2) {
34171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34172     return ;
34173   }
34174   {
34175     try {
34176       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34177     } catch (std::out_of_range& e) {
34178       {
34179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34180       };
34181     } catch (std::exception& e) {
34182       {
34183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34184       };
34185     } catch (...) {
34186       {
34187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34188       };
34189     }
34190   }
34191 }
34192
34193
34194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34195   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34196   Dali::Animation *arg2 = 0 ;
34197   Dali::Vector3 *arg3 = 0 ;
34198
34199   arg1 = (Dali::CustomActorImpl *)jarg1;
34200   arg2 = (Dali::Animation *)jarg2;
34201   if (!arg2) {
34202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34203     return ;
34204   }
34205   arg3 = (Dali::Vector3 *)jarg3;
34206   if (!arg3) {
34207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34208     return ;
34209   }
34210   {
34211     try {
34212       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34213     } catch (std::out_of_range& e) {
34214       {
34215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34216       };
34217     } catch (std::exception& e) {
34218       {
34219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34220       };
34221     } catch (...) {
34222       {
34223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34224       };
34225     }
34226   }
34227 }
34228
34229
34230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34231   unsigned int jresult ;
34232   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34233   Dali::TouchEvent *arg2 = 0 ;
34234   bool result;
34235
34236   arg1 = (Dali::CustomActorImpl *)jarg1;
34237   arg2 = (Dali::TouchEvent *)jarg2;
34238   if (!arg2) {
34239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34240     return 0;
34241   }
34242   {
34243     try {
34244       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34245     } catch (std::out_of_range& e) {
34246       {
34247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34248       };
34249     } catch (std::exception& e) {
34250       {
34251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34252       };
34253     } catch (...) {
34254       {
34255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34256       };
34257     }
34258   }
34259   jresult = result;
34260   return jresult;
34261 }
34262
34263
34264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34265   unsigned int jresult ;
34266   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34267   Dali::HoverEvent *arg2 = 0 ;
34268   bool result;
34269
34270   arg1 = (Dali::CustomActorImpl *)jarg1;
34271   arg2 = (Dali::HoverEvent *)jarg2;
34272   if (!arg2) {
34273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34274     return 0;
34275   }
34276   {
34277     try {
34278       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34279     } catch (std::out_of_range& e) {
34280       {
34281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34282       };
34283     } catch (std::exception& e) {
34284       {
34285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34286       };
34287     } catch (...) {
34288       {
34289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34290       };
34291     }
34292   }
34293   jresult = result;
34294   return jresult;
34295 }
34296
34297
34298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34299   unsigned int jresult ;
34300   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34301   Dali::KeyEvent *arg2 = 0 ;
34302   bool result;
34303
34304   arg1 = (Dali::CustomActorImpl *)jarg1;
34305   arg2 = (Dali::KeyEvent *)jarg2;
34306   if (!arg2) {
34307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34308     return 0;
34309   }
34310   {
34311     try {
34312       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34313     } catch (std::out_of_range& e) {
34314       {
34315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34316       };
34317     } catch (std::exception& e) {
34318       {
34319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34320       };
34321     } catch (...) {
34322       {
34323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34324       };
34325     }
34326   }
34327   jresult = result;
34328   return jresult;
34329 }
34330
34331
34332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34333   unsigned int jresult ;
34334   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34335   Dali::WheelEvent *arg2 = 0 ;
34336   bool result;
34337
34338   arg1 = (Dali::CustomActorImpl *)jarg1;
34339   arg2 = (Dali::WheelEvent *)jarg2;
34340   if (!arg2) {
34341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34342     return 0;
34343   }
34344   {
34345     try {
34346       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34347     } catch (std::out_of_range& e) {
34348       {
34349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34350       };
34351     } catch (std::exception& e) {
34352       {
34353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34354       };
34355     } catch (...) {
34356       {
34357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34358       };
34359     }
34360   }
34361   jresult = result;
34362   return jresult;
34363 }
34364
34365
34366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34367   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34368   Dali::Vector2 *arg2 = 0 ;
34369   Dali::RelayoutContainer *arg3 = 0 ;
34370
34371   arg1 = (Dali::CustomActorImpl *)jarg1;
34372   arg2 = (Dali::Vector2 *)jarg2;
34373   if (!arg2) {
34374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34375     return ;
34376   }
34377   arg3 = (Dali::RelayoutContainer *)jarg3;
34378   if (!arg3) {
34379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34380     return ;
34381   }
34382   {
34383     try {
34384       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34385     } catch (std::out_of_range& e) {
34386       {
34387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34388       };
34389     } catch (std::exception& e) {
34390       {
34391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34392       };
34393     } catch (...) {
34394       {
34395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34396       };
34397     }
34398   }
34399 }
34400
34401
34402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34403   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34404   Dali::ResizePolicy::Type arg2 ;
34405   Dali::Dimension::Type arg3 ;
34406
34407   arg1 = (Dali::CustomActorImpl *)jarg1;
34408   arg2 = (Dali::ResizePolicy::Type)jarg2;
34409   arg3 = (Dali::Dimension::Type)jarg3;
34410   {
34411     try {
34412       (arg1)->OnSetResizePolicy(arg2,arg3);
34413     } catch (std::out_of_range& e) {
34414       {
34415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34416       };
34417     } catch (std::exception& e) {
34418       {
34419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34420       };
34421     } catch (...) {
34422       {
34423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34424       };
34425     }
34426   }
34427 }
34428
34429
34430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34431   void * jresult ;
34432   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34433   Dali::Vector3 result;
34434
34435   arg1 = (Dali::CustomActorImpl *)jarg1;
34436   {
34437     try {
34438       result = (arg1)->GetNaturalSize();
34439     } catch (std::out_of_range& e) {
34440       {
34441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34442       };
34443     } catch (std::exception& e) {
34444       {
34445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34446       };
34447     } catch (...) {
34448       {
34449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34450       };
34451     }
34452   }
34453   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34454   return jresult;
34455 }
34456
34457
34458 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34459   float jresult ;
34460   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34461   Dali::Actor *arg2 = 0 ;
34462   Dali::Dimension::Type arg3 ;
34463   float result;
34464
34465   arg1 = (Dali::CustomActorImpl *)jarg1;
34466   arg2 = (Dali::Actor *)jarg2;
34467   if (!arg2) {
34468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34469     return 0;
34470   }
34471   arg3 = (Dali::Dimension::Type)jarg3;
34472   {
34473     try {
34474       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34475     } catch (std::out_of_range& e) {
34476       {
34477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34478       };
34479     } catch (std::exception& e) {
34480       {
34481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34482       };
34483     } catch (...) {
34484       {
34485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34486       };
34487     }
34488   }
34489   jresult = result;
34490   return jresult;
34491 }
34492
34493
34494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34495   float jresult ;
34496   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34497   float arg2 ;
34498   float result;
34499
34500   arg1 = (Dali::CustomActorImpl *)jarg1;
34501   arg2 = (float)jarg2;
34502   {
34503     try {
34504       result = (float)(arg1)->GetHeightForWidth(arg2);
34505     } catch (std::out_of_range& e) {
34506       {
34507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34508       };
34509     } catch (std::exception& e) {
34510       {
34511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34512       };
34513     } catch (...) {
34514       {
34515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34516       };
34517     }
34518   }
34519   jresult = result;
34520   return jresult;
34521 }
34522
34523
34524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34525   float jresult ;
34526   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34527   float arg2 ;
34528   float result;
34529
34530   arg1 = (Dali::CustomActorImpl *)jarg1;
34531   arg2 = (float)jarg2;
34532   {
34533     try {
34534       result = (float)(arg1)->GetWidthForHeight(arg2);
34535     } catch (std::out_of_range& e) {
34536       {
34537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34538       };
34539     } catch (std::exception& e) {
34540       {
34541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34542       };
34543     } catch (...) {
34544       {
34545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34546       };
34547     }
34548   }
34549   jresult = result;
34550   return jresult;
34551 }
34552
34553
34554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34555   unsigned int jresult ;
34556   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34557   Dali::Dimension::Type arg2 ;
34558   bool result;
34559
34560   arg1 = (Dali::CustomActorImpl *)jarg1;
34561   arg2 = (Dali::Dimension::Type)jarg2;
34562   {
34563     try {
34564       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34565     } catch (std::out_of_range& e) {
34566       {
34567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34568       };
34569     } catch (std::exception& e) {
34570       {
34571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34572       };
34573     } catch (...) {
34574       {
34575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34576       };
34577     }
34578   }
34579   jresult = result;
34580   return jresult;
34581 }
34582
34583
34584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34585   unsigned int jresult ;
34586   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34587   bool result;
34588
34589   arg1 = (Dali::CustomActorImpl *)jarg1;
34590   {
34591     try {
34592       result = (bool)(arg1)->RelayoutDependentOnChildren();
34593     } catch (std::out_of_range& e) {
34594       {
34595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34596       };
34597     } catch (std::exception& e) {
34598       {
34599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34600       };
34601     } catch (...) {
34602       {
34603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34604       };
34605     }
34606   }
34607   jresult = result;
34608   return jresult;
34609 }
34610
34611
34612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34613   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34614   Dali::Dimension::Type arg2 ;
34615
34616   arg1 = (Dali::CustomActorImpl *)jarg1;
34617   arg2 = (Dali::Dimension::Type)jarg2;
34618   {
34619     try {
34620       (arg1)->OnCalculateRelayoutSize(arg2);
34621     } catch (std::out_of_range& e) {
34622       {
34623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34624       };
34625     } catch (std::exception& e) {
34626       {
34627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34628       };
34629     } catch (...) {
34630       {
34631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34632       };
34633     }
34634   }
34635 }
34636
34637
34638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34639   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34640   float arg2 ;
34641   Dali::Dimension::Type arg3 ;
34642
34643   arg1 = (Dali::CustomActorImpl *)jarg1;
34644   arg2 = (float)jarg2;
34645   arg3 = (Dali::Dimension::Type)jarg3;
34646   {
34647     try {
34648       (arg1)->OnLayoutNegotiated(arg2,arg3);
34649     } catch (std::out_of_range& e) {
34650       {
34651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34652       };
34653     } catch (std::exception& e) {
34654       {
34655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34656       };
34657     } catch (...) {
34658       {
34659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34660       };
34661     }
34662   }
34663 }
34664
34665
34666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34667   unsigned int jresult ;
34668   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34669   bool result;
34670
34671   arg1 = (Dali::CustomActorImpl *)jarg1;
34672   {
34673     try {
34674       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34675     } catch (std::out_of_range& e) {
34676       {
34677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34678       };
34679     } catch (std::exception& e) {
34680       {
34681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34682       };
34683     } catch (...) {
34684       {
34685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34686       };
34687     }
34688   }
34689   jresult = result;
34690   return jresult;
34691 }
34692
34693
34694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34695   unsigned int jresult ;
34696   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34697   bool result;
34698
34699   arg1 = (Dali::CustomActorImpl *)jarg1;
34700   {
34701     try {
34702       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34703     } catch (std::out_of_range& e) {
34704       {
34705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34706       };
34707     } catch (std::exception& e) {
34708       {
34709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34710       };
34711     } catch (...) {
34712       {
34713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34714       };
34715     }
34716   }
34717   jresult = result;
34718   return jresult;
34719 }
34720
34721
34722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34723   unsigned int jresult ;
34724   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34725   bool result;
34726
34727   arg1 = (Dali::CustomActorImpl *)jarg1;
34728   {
34729     try {
34730       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34731     } catch (std::out_of_range& e) {
34732       {
34733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34734       };
34735     } catch (std::exception& e) {
34736       {
34737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34738       };
34739     } catch (...) {
34740       {
34741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34742       };
34743     }
34744   }
34745   jresult = result;
34746   return jresult;
34747 }
34748
34749
34750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34751   unsigned int jresult ;
34752   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34753   bool result;
34754
34755   arg1 = (Dali::CustomActorImpl *)jarg1;
34756   {
34757     try {
34758       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34759     } catch (std::out_of_range& e) {
34760       {
34761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34762       };
34763     } catch (std::exception& e) {
34764       {
34765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34766       };
34767     } catch (...) {
34768       {
34769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34770       };
34771     }
34772   }
34773   jresult = result;
34774   return jresult;
34775 }
34776
34777
34778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34779   void * jresult ;
34780   Dali::CustomActor *result = 0 ;
34781
34782   {
34783     try {
34784       result = (Dali::CustomActor *)new Dali::CustomActor();
34785     } catch (std::out_of_range& e) {
34786       {
34787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34788       };
34789     } catch (std::exception& e) {
34790       {
34791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34792       };
34793     } catch (...) {
34794       {
34795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34796       };
34797     }
34798   }
34799   jresult = (void *)result;
34800   return jresult;
34801 }
34802
34803
34804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34805   void * jresult ;
34806   Dali::BaseHandle arg1 ;
34807   Dali::BaseHandle *argp1 ;
34808   Dali::CustomActor result;
34809
34810   argp1 = (Dali::BaseHandle *)jarg1;
34811   if (!argp1) {
34812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34813     return 0;
34814   }
34815   arg1 = *argp1;
34816   {
34817     try {
34818       result = Dali::CustomActor::DownCast(arg1);
34819     } catch (std::out_of_range& e) {
34820       {
34821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34822       };
34823     } catch (std::exception& e) {
34824       {
34825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34826       };
34827     } catch (...) {
34828       {
34829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34830       };
34831     }
34832   }
34833   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34834   return jresult;
34835 }
34836
34837
34838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34839   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34840
34841   arg1 = (Dali::CustomActor *)jarg1;
34842   {
34843     try {
34844       delete arg1;
34845     } catch (std::out_of_range& e) {
34846       {
34847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34848       };
34849     } catch (std::exception& e) {
34850       {
34851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34852       };
34853     } catch (...) {
34854       {
34855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34856       };
34857     }
34858   }
34859 }
34860
34861
34862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
34863   void * jresult ;
34864   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34865   Dali::CustomActorImpl *result = 0 ;
34866
34867   arg1 = (Dali::CustomActor *)jarg1;
34868   {
34869     try {
34870       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
34871     } catch (std::out_of_range& e) {
34872       {
34873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34874       };
34875     } catch (std::exception& e) {
34876       {
34877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34878       };
34879     } catch (...) {
34880       {
34881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34882       };
34883     }
34884   }
34885   jresult = (void *)result;
34886   return jresult;
34887 }
34888
34889
34890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
34891   void * jresult ;
34892   Dali::CustomActorImpl *arg1 = 0 ;
34893   Dali::CustomActor *result = 0 ;
34894
34895   arg1 = (Dali::CustomActorImpl *)jarg1;
34896   if (!arg1) {
34897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
34898     return 0;
34899   }
34900   {
34901     try {
34902       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
34903     } catch (std::out_of_range& e) {
34904       {
34905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34906       };
34907     } catch (std::exception& e) {
34908       {
34909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34910       };
34911     } catch (...) {
34912       {
34913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34914       };
34915     }
34916   }
34917   jresult = (void *)result;
34918   return jresult;
34919 }
34920
34921
34922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
34923   void * jresult ;
34924   Dali::CustomActor *arg1 = 0 ;
34925   Dali::CustomActor *result = 0 ;
34926
34927   arg1 = (Dali::CustomActor *)jarg1;
34928   if (!arg1) {
34929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34930     return 0;
34931   }
34932   {
34933     try {
34934       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
34935     } catch (std::out_of_range& e) {
34936       {
34937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34938       };
34939     } catch (std::exception& e) {
34940       {
34941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34942       };
34943     } catch (...) {
34944       {
34945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34946       };
34947     }
34948   }
34949   jresult = (void *)result;
34950   return jresult;
34951 }
34952
34953
34954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
34955   void * jresult ;
34956   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34957   Dali::CustomActor *arg2 = 0 ;
34958   Dali::CustomActor *result = 0 ;
34959
34960   arg1 = (Dali::CustomActor *)jarg1;
34961   arg2 = (Dali::CustomActor *)jarg2;
34962   if (!arg2) {
34963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34964     return 0;
34965   }
34966   {
34967     try {
34968       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
34969     } catch (std::out_of_range& e) {
34970       {
34971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34972       };
34973     } catch (std::exception& e) {
34974       {
34975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34976       };
34977     } catch (...) {
34978       {
34979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34980       };
34981     }
34982   }
34983   jresult = (void *)result;
34984   return jresult;
34985 }
34986
34987
34988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
34989   int jresult ;
34990   int result;
34991
34992   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
34993   jresult = (int)result;
34994   return jresult;
34995 }
34996
34997
34998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
34999   int jresult ;
35000   int result;
35001
35002   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35003   jresult = (int)result;
35004   return jresult;
35005 }
35006
35007
35008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35009   int jresult ;
35010   int result;
35011
35012   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35013   jresult = (int)result;
35014   return jresult;
35015 }
35016
35017
35018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35019   int jresult ;
35020   int result;
35021
35022   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35023   jresult = (int)result;
35024   return jresult;
35025 }
35026
35027
35028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35029   int jresult ;
35030   int result;
35031
35032   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35033   jresult = (int)result;
35034   return jresult;
35035 }
35036
35037
35038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35039   int jresult ;
35040   int result;
35041
35042   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35043   jresult = (int)result;
35044   return jresult;
35045 }
35046
35047
35048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35049   int jresult ;
35050   int result;
35051
35052   result = (int)Dali::PanGestureDetector::Property::PANNING;
35053   jresult = (int)result;
35054   return jresult;
35055 }
35056
35057
35058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35059   void * jresult ;
35060   Dali::PanGestureDetector::Property *result = 0 ;
35061
35062   {
35063     try {
35064       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35065     } catch (std::out_of_range& e) {
35066       {
35067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35068       };
35069     } catch (std::exception& e) {
35070       {
35071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35072       };
35073     } catch (...) {
35074       {
35075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35076       };
35077     }
35078   }
35079   jresult = (void *)result;
35080   return jresult;
35081 }
35082
35083
35084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35085   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35086
35087   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35088   {
35089     try {
35090       delete arg1;
35091     } catch (std::out_of_range& e) {
35092       {
35093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35094       };
35095     } catch (std::exception& e) {
35096       {
35097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35098       };
35099     } catch (...) {
35100       {
35101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35102       };
35103     }
35104   }
35105 }
35106
35107
35108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35109   void * jresult ;
35110   Dali::Radian *result = 0 ;
35111
35112   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35113   jresult = (void *)result;
35114   return jresult;
35115 }
35116
35117
35118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35119   void * jresult ;
35120   Dali::Radian *result = 0 ;
35121
35122   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35123   jresult = (void *)result;
35124   return jresult;
35125 }
35126
35127
35128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35129   void * jresult ;
35130   Dali::Radian *result = 0 ;
35131
35132   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35133   jresult = (void *)result;
35134   return jresult;
35135 }
35136
35137
35138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35139   void * jresult ;
35140   Dali::Radian *result = 0 ;
35141
35142   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35143   jresult = (void *)result;
35144   return jresult;
35145 }
35146
35147
35148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35149   void * jresult ;
35150   Dali::Radian *result = 0 ;
35151
35152   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35153   jresult = (void *)result;
35154   return jresult;
35155 }
35156
35157
35158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35159   void * jresult ;
35160   Dali::Radian *result = 0 ;
35161
35162   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35163   jresult = (void *)result;
35164   return jresult;
35165 }
35166
35167
35168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35169   void * jresult ;
35170   Dali::Radian *result = 0 ;
35171
35172   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35173   jresult = (void *)result;
35174   return jresult;
35175 }
35176
35177
35178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35179   void * jresult ;
35180   Dali::PanGestureDetector *result = 0 ;
35181
35182   {
35183     try {
35184       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35185     } catch (std::out_of_range& e) {
35186       {
35187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35188       };
35189     } catch (std::exception& e) {
35190       {
35191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35192       };
35193     } catch (...) {
35194       {
35195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35196       };
35197     }
35198   }
35199   jresult = (void *)result;
35200   return jresult;
35201 }
35202
35203
35204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35205   void * jresult ;
35206   Dali::PanGestureDetector result;
35207
35208   {
35209     try {
35210       result = Dali::PanGestureDetector::New();
35211     } catch (std::out_of_range& e) {
35212       {
35213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35214       };
35215     } catch (std::exception& e) {
35216       {
35217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35218       };
35219     } catch (...) {
35220       {
35221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35222       };
35223     }
35224   }
35225   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35226   return jresult;
35227 }
35228
35229
35230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35231   void * jresult ;
35232   Dali::BaseHandle arg1 ;
35233   Dali::BaseHandle *argp1 ;
35234   Dali::PanGestureDetector result;
35235
35236   argp1 = (Dali::BaseHandle *)jarg1;
35237   if (!argp1) {
35238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35239     return 0;
35240   }
35241   arg1 = *argp1;
35242   {
35243     try {
35244       result = Dali::PanGestureDetector::DownCast(arg1);
35245     } catch (std::out_of_range& e) {
35246       {
35247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35248       };
35249     } catch (std::exception& e) {
35250       {
35251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35252       };
35253     } catch (...) {
35254       {
35255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35256       };
35257     }
35258   }
35259   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35260   return jresult;
35261 }
35262
35263
35264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35265   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35266
35267   arg1 = (Dali::PanGestureDetector *)jarg1;
35268   {
35269     try {
35270       delete arg1;
35271     } catch (std::out_of_range& e) {
35272       {
35273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35274       };
35275     } catch (std::exception& e) {
35276       {
35277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35278       };
35279     } catch (...) {
35280       {
35281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35282       };
35283     }
35284   }
35285 }
35286
35287
35288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35289   void * jresult ;
35290   Dali::PanGestureDetector *arg1 = 0 ;
35291   Dali::PanGestureDetector *result = 0 ;
35292
35293   arg1 = (Dali::PanGestureDetector *)jarg1;
35294   if (!arg1) {
35295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35296     return 0;
35297   }
35298   {
35299     try {
35300       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35301     } catch (std::out_of_range& e) {
35302       {
35303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35304       };
35305     } catch (std::exception& e) {
35306       {
35307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35308       };
35309     } catch (...) {
35310       {
35311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35312       };
35313     }
35314   }
35315   jresult = (void *)result;
35316   return jresult;
35317 }
35318
35319
35320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35321   void * jresult ;
35322   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35323   Dali::PanGestureDetector *arg2 = 0 ;
35324   Dali::PanGestureDetector *result = 0 ;
35325
35326   arg1 = (Dali::PanGestureDetector *)jarg1;
35327   arg2 = (Dali::PanGestureDetector *)jarg2;
35328   if (!arg2) {
35329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35330     return 0;
35331   }
35332   {
35333     try {
35334       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35335     } catch (std::out_of_range& e) {
35336       {
35337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35338       };
35339     } catch (std::exception& e) {
35340       {
35341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35342       };
35343     } catch (...) {
35344       {
35345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35346       };
35347     }
35348   }
35349   jresult = (void *)result;
35350   return jresult;
35351 }
35352
35353
35354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35355   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35356   unsigned int arg2 ;
35357
35358   arg1 = (Dali::PanGestureDetector *)jarg1;
35359   arg2 = (unsigned int)jarg2;
35360   {
35361     try {
35362       (arg1)->SetMinimumTouchesRequired(arg2);
35363     } catch (std::out_of_range& e) {
35364       {
35365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35366       };
35367     } catch (std::exception& e) {
35368       {
35369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35370       };
35371     } catch (...) {
35372       {
35373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35374       };
35375     }
35376   }
35377 }
35378
35379
35380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35381   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35382   unsigned int arg2 ;
35383
35384   arg1 = (Dali::PanGestureDetector *)jarg1;
35385   arg2 = (unsigned int)jarg2;
35386   {
35387     try {
35388       (arg1)->SetMaximumTouchesRequired(arg2);
35389     } catch (std::out_of_range& e) {
35390       {
35391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35392       };
35393     } catch (std::exception& e) {
35394       {
35395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35396       };
35397     } catch (...) {
35398       {
35399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35400       };
35401     }
35402   }
35403 }
35404
35405
35406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35407   unsigned int jresult ;
35408   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35409   unsigned int result;
35410
35411   arg1 = (Dali::PanGestureDetector *)jarg1;
35412   {
35413     try {
35414       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35415     } catch (std::out_of_range& e) {
35416       {
35417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35418       };
35419     } catch (std::exception& e) {
35420       {
35421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35422       };
35423     } catch (...) {
35424       {
35425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35426       };
35427     }
35428   }
35429   jresult = result;
35430   return jresult;
35431 }
35432
35433
35434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35435   unsigned int jresult ;
35436   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35437   unsigned int result;
35438
35439   arg1 = (Dali::PanGestureDetector *)jarg1;
35440   {
35441     try {
35442       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35443     } catch (std::out_of_range& e) {
35444       {
35445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35446       };
35447     } catch (std::exception& e) {
35448       {
35449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35450       };
35451     } catch (...) {
35452       {
35453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35454       };
35455     }
35456   }
35457   jresult = result;
35458   return jresult;
35459 }
35460
35461
35462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35463   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35464   Dali::Radian arg2 ;
35465   Dali::Radian arg3 ;
35466   Dali::Radian *argp2 ;
35467   Dali::Radian *argp3 ;
35468
35469   arg1 = (Dali::PanGestureDetector *)jarg1;
35470   argp2 = (Dali::Radian *)jarg2;
35471   if (!argp2) {
35472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35473     return ;
35474   }
35475   arg2 = *argp2;
35476   argp3 = (Dali::Radian *)jarg3;
35477   if (!argp3) {
35478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35479     return ;
35480   }
35481   arg3 = *argp3;
35482   {
35483     try {
35484       (arg1)->AddAngle(arg2,arg3);
35485     } catch (std::out_of_range& e) {
35486       {
35487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35488       };
35489     } catch (std::exception& e) {
35490       {
35491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35492       };
35493     } catch (...) {
35494       {
35495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35496       };
35497     }
35498   }
35499 }
35500
35501
35502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35503   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35504   Dali::Radian arg2 ;
35505   Dali::Radian *argp2 ;
35506
35507   arg1 = (Dali::PanGestureDetector *)jarg1;
35508   argp2 = (Dali::Radian *)jarg2;
35509   if (!argp2) {
35510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35511     return ;
35512   }
35513   arg2 = *argp2;
35514   {
35515     try {
35516       (arg1)->AddAngle(arg2);
35517     } catch (std::out_of_range& e) {
35518       {
35519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35520       };
35521     } catch (std::exception& e) {
35522       {
35523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35524       };
35525     } catch (...) {
35526       {
35527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35528       };
35529     }
35530   }
35531 }
35532
35533
35534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35535   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35536   Dali::Radian arg2 ;
35537   Dali::Radian arg3 ;
35538   Dali::Radian *argp2 ;
35539   Dali::Radian *argp3 ;
35540
35541   arg1 = (Dali::PanGestureDetector *)jarg1;
35542   argp2 = (Dali::Radian *)jarg2;
35543   if (!argp2) {
35544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35545     return ;
35546   }
35547   arg2 = *argp2;
35548   argp3 = (Dali::Radian *)jarg3;
35549   if (!argp3) {
35550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35551     return ;
35552   }
35553   arg3 = *argp3;
35554   {
35555     try {
35556       (arg1)->AddDirection(arg2,arg3);
35557     } catch (std::out_of_range& e) {
35558       {
35559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35560       };
35561     } catch (std::exception& e) {
35562       {
35563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35564       };
35565     } catch (...) {
35566       {
35567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35568       };
35569     }
35570   }
35571 }
35572
35573
35574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35575   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35576   Dali::Radian arg2 ;
35577   Dali::Radian *argp2 ;
35578
35579   arg1 = (Dali::PanGestureDetector *)jarg1;
35580   argp2 = (Dali::Radian *)jarg2;
35581   if (!argp2) {
35582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35583     return ;
35584   }
35585   arg2 = *argp2;
35586   {
35587     try {
35588       (arg1)->AddDirection(arg2);
35589     } catch (std::out_of_range& e) {
35590       {
35591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35592       };
35593     } catch (std::exception& e) {
35594       {
35595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35596       };
35597     } catch (...) {
35598       {
35599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35600       };
35601     }
35602   }
35603 }
35604
35605
35606 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35607   unsigned long jresult ;
35608   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35609   size_t result;
35610
35611   arg1 = (Dali::PanGestureDetector *)jarg1;
35612   {
35613     try {
35614       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35615     } catch (std::out_of_range& e) {
35616       {
35617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35618       };
35619     } catch (std::exception& e) {
35620       {
35621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35622       };
35623     } catch (...) {
35624       {
35625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35626       };
35627     }
35628   }
35629   jresult = (unsigned long)result;
35630   return jresult;
35631 }
35632
35633
35634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35635   void * jresult ;
35636   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35637   size_t arg2 ;
35638   Dali::PanGestureDetector::AngleThresholdPair result;
35639
35640   arg1 = (Dali::PanGestureDetector *)jarg1;
35641   arg2 = (size_t)jarg2;
35642   {
35643     try {
35644       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35645     } catch (std::out_of_range& e) {
35646       {
35647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35648       };
35649     } catch (std::exception& e) {
35650       {
35651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35652       };
35653     } catch (...) {
35654       {
35655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35656       };
35657     }
35658   }
35659   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35660   return jresult;
35661 }
35662
35663
35664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35665   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35666
35667   arg1 = (Dali::PanGestureDetector *)jarg1;
35668   {
35669     try {
35670       (arg1)->ClearAngles();
35671     } catch (std::out_of_range& e) {
35672       {
35673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35674       };
35675     } catch (std::exception& e) {
35676       {
35677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35678       };
35679     } catch (...) {
35680       {
35681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35682       };
35683     }
35684   }
35685 }
35686
35687
35688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35689   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35690   Dali::Radian arg2 ;
35691   Dali::Radian *argp2 ;
35692
35693   arg1 = (Dali::PanGestureDetector *)jarg1;
35694   argp2 = (Dali::Radian *)jarg2;
35695   if (!argp2) {
35696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35697     return ;
35698   }
35699   arg2 = *argp2;
35700   {
35701     try {
35702       (arg1)->RemoveAngle(arg2);
35703     } catch (std::out_of_range& e) {
35704       {
35705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35706       };
35707     } catch (std::exception& e) {
35708       {
35709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35710       };
35711     } catch (...) {
35712       {
35713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35714       };
35715     }
35716   }
35717 }
35718
35719
35720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35721   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35722   Dali::Radian arg2 ;
35723   Dali::Radian *argp2 ;
35724
35725   arg1 = (Dali::PanGestureDetector *)jarg1;
35726   argp2 = (Dali::Radian *)jarg2;
35727   if (!argp2) {
35728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35729     return ;
35730   }
35731   arg2 = *argp2;
35732   {
35733     try {
35734       (arg1)->RemoveDirection(arg2);
35735     } catch (std::out_of_range& e) {
35736       {
35737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35738       };
35739     } catch (std::exception& e) {
35740       {
35741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35742       };
35743     } catch (...) {
35744       {
35745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35746       };
35747     }
35748   }
35749 }
35750
35751
35752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35753   void * jresult ;
35754   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35755   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35756
35757   arg1 = (Dali::PanGestureDetector *)jarg1;
35758   {
35759     try {
35760       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35761     } catch (std::out_of_range& e) {
35762       {
35763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35764       };
35765     } catch (std::exception& e) {
35766       {
35767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35768       };
35769     } catch (...) {
35770       {
35771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35772       };
35773     }
35774   }
35775   jresult = (void *)result;
35776   return jresult;
35777 }
35778
35779
35780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35781   Dali::PanGesture *arg1 = 0 ;
35782
35783   arg1 = (Dali::PanGesture *)jarg1;
35784   if (!arg1) {
35785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35786     return ;
35787   }
35788   {
35789     try {
35790       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35791     } catch (std::out_of_range& e) {
35792       {
35793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35794       };
35795     } catch (std::exception& e) {
35796       {
35797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35798       };
35799     } catch (...) {
35800       {
35801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35802       };
35803     }
35804   }
35805 }
35806
35807
35808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35809   void * jresult ;
35810   Dali::PanGesture *result = 0 ;
35811
35812   {
35813     try {
35814       result = (Dali::PanGesture *)new Dali::PanGesture();
35815     } catch (std::out_of_range& e) {
35816       {
35817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35818       };
35819     } catch (std::exception& e) {
35820       {
35821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35822       };
35823     } catch (...) {
35824       {
35825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35826       };
35827     }
35828   }
35829   jresult = (void *)result;
35830   return jresult;
35831 }
35832
35833
35834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35835   void * jresult ;
35836   Dali::Gesture::State arg1 ;
35837   Dali::PanGesture *result = 0 ;
35838
35839   arg1 = (Dali::Gesture::State)jarg1;
35840   {
35841     try {
35842       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35843     } catch (std::out_of_range& e) {
35844       {
35845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35846       };
35847     } catch (std::exception& e) {
35848       {
35849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35850       };
35851     } catch (...) {
35852       {
35853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35854       };
35855     }
35856   }
35857   jresult = (void *)result;
35858   return jresult;
35859 }
35860
35861
35862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
35863   void * jresult ;
35864   Dali::PanGesture *arg1 = 0 ;
35865   Dali::PanGesture *result = 0 ;
35866
35867   arg1 = (Dali::PanGesture *)jarg1;
35868   if (!arg1) {
35869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35870     return 0;
35871   }
35872   {
35873     try {
35874       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
35875     } catch (std::out_of_range& e) {
35876       {
35877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35878       };
35879     } catch (std::exception& e) {
35880       {
35881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35882       };
35883     } catch (...) {
35884       {
35885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35886       };
35887     }
35888   }
35889   jresult = (void *)result;
35890   return jresult;
35891 }
35892
35893
35894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
35895   void * jresult ;
35896   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35897   Dali::PanGesture *arg2 = 0 ;
35898   Dali::PanGesture *result = 0 ;
35899
35900   arg1 = (Dali::PanGesture *)jarg1;
35901   arg2 = (Dali::PanGesture *)jarg2;
35902   if (!arg2) {
35903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35904     return 0;
35905   }
35906   {
35907     try {
35908       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
35909     } catch (std::out_of_range& e) {
35910       {
35911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35912       };
35913     } catch (std::exception& e) {
35914       {
35915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35916       };
35917     } catch (...) {
35918       {
35919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35920       };
35921     }
35922   }
35923   jresult = (void *)result;
35924   return jresult;
35925 }
35926
35927
35928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
35929   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35930
35931   arg1 = (Dali::PanGesture *)jarg1;
35932   {
35933     try {
35934       delete arg1;
35935     } catch (std::out_of_range& e) {
35936       {
35937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35938       };
35939     } catch (std::exception& e) {
35940       {
35941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35942       };
35943     } catch (...) {
35944       {
35945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35946       };
35947     }
35948   }
35949 }
35950
35951
35952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
35953   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35954   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35955
35956   arg1 = (Dali::PanGesture *)jarg1;
35957   arg2 = (Dali::Vector2 *)jarg2;
35958   if (arg1) (arg1)->velocity = *arg2;
35959 }
35960
35961
35962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
35963   void * jresult ;
35964   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35965   Dali::Vector2 *result = 0 ;
35966
35967   arg1 = (Dali::PanGesture *)jarg1;
35968   result = (Dali::Vector2 *)& ((arg1)->velocity);
35969   jresult = (void *)result;
35970   return jresult;
35971 }
35972
35973
35974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
35975   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35976   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35977
35978   arg1 = (Dali::PanGesture *)jarg1;
35979   arg2 = (Dali::Vector2 *)jarg2;
35980   if (arg1) (arg1)->displacement = *arg2;
35981 }
35982
35983
35984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
35985   void * jresult ;
35986   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35987   Dali::Vector2 *result = 0 ;
35988
35989   arg1 = (Dali::PanGesture *)jarg1;
35990   result = (Dali::Vector2 *)& ((arg1)->displacement);
35991   jresult = (void *)result;
35992   return jresult;
35993 }
35994
35995
35996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
35997   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35998   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35999
36000   arg1 = (Dali::PanGesture *)jarg1;
36001   arg2 = (Dali::Vector2 *)jarg2;
36002   if (arg1) (arg1)->position = *arg2;
36003 }
36004
36005
36006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36007   void * jresult ;
36008   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36009   Dali::Vector2 *result = 0 ;
36010
36011   arg1 = (Dali::PanGesture *)jarg1;
36012   result = (Dali::Vector2 *)& ((arg1)->position);
36013   jresult = (void *)result;
36014   return jresult;
36015 }
36016
36017
36018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36019   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36020   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36021
36022   arg1 = (Dali::PanGesture *)jarg1;
36023   arg2 = (Dali::Vector2 *)jarg2;
36024   if (arg1) (arg1)->screenVelocity = *arg2;
36025 }
36026
36027
36028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36029   void * jresult ;
36030   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36031   Dali::Vector2 *result = 0 ;
36032
36033   arg1 = (Dali::PanGesture *)jarg1;
36034   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36035   jresult = (void *)result;
36036   return jresult;
36037 }
36038
36039
36040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36041   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36042   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36043
36044   arg1 = (Dali::PanGesture *)jarg1;
36045   arg2 = (Dali::Vector2 *)jarg2;
36046   if (arg1) (arg1)->screenDisplacement = *arg2;
36047 }
36048
36049
36050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36051   void * jresult ;
36052   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36053   Dali::Vector2 *result = 0 ;
36054
36055   arg1 = (Dali::PanGesture *)jarg1;
36056   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36057   jresult = (void *)result;
36058   return jresult;
36059 }
36060
36061
36062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36063   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36064   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36065
36066   arg1 = (Dali::PanGesture *)jarg1;
36067   arg2 = (Dali::Vector2 *)jarg2;
36068   if (arg1) (arg1)->screenPosition = *arg2;
36069 }
36070
36071
36072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36073   void * jresult ;
36074   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36075   Dali::Vector2 *result = 0 ;
36076
36077   arg1 = (Dali::PanGesture *)jarg1;
36078   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36079   jresult = (void *)result;
36080   return jresult;
36081 }
36082
36083
36084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36085   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36086   unsigned int arg2 ;
36087
36088   arg1 = (Dali::PanGesture *)jarg1;
36089   arg2 = (unsigned int)jarg2;
36090   if (arg1) (arg1)->numberOfTouches = arg2;
36091 }
36092
36093
36094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36095   unsigned int jresult ;
36096   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36097   unsigned int result;
36098
36099   arg1 = (Dali::PanGesture *)jarg1;
36100   result = (unsigned int) ((arg1)->numberOfTouches);
36101   jresult = result;
36102   return jresult;
36103 }
36104
36105
36106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36107   float jresult ;
36108   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36109   float result;
36110
36111   arg1 = (Dali::PanGesture *)jarg1;
36112   {
36113     try {
36114       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36115     } catch (std::out_of_range& e) {
36116       {
36117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36118       };
36119     } catch (std::exception& e) {
36120       {
36121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36122       };
36123     } catch (...) {
36124       {
36125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36126       };
36127     }
36128   }
36129   jresult = result;
36130   return jresult;
36131 }
36132
36133
36134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36135   float jresult ;
36136   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36137   float result;
36138
36139   arg1 = (Dali::PanGesture *)jarg1;
36140   {
36141     try {
36142       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36143     } catch (std::out_of_range& e) {
36144       {
36145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36146       };
36147     } catch (std::exception& e) {
36148       {
36149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36150       };
36151     } catch (...) {
36152       {
36153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36154       };
36155     }
36156   }
36157   jresult = result;
36158   return jresult;
36159 }
36160
36161
36162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36163   float jresult ;
36164   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36165   float result;
36166
36167   arg1 = (Dali::PanGesture *)jarg1;
36168   {
36169     try {
36170       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36171     } catch (std::out_of_range& e) {
36172       {
36173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36174       };
36175     } catch (std::exception& e) {
36176       {
36177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36178       };
36179     } catch (...) {
36180       {
36181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36182       };
36183     }
36184   }
36185   jresult = result;
36186   return jresult;
36187 }
36188
36189
36190 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36191   float jresult ;
36192   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36193   float result;
36194
36195   arg1 = (Dali::PanGesture *)jarg1;
36196   {
36197     try {
36198       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36199     } catch (std::out_of_range& e) {
36200       {
36201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36202       };
36203     } catch (std::exception& e) {
36204       {
36205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36206       };
36207     } catch (...) {
36208       {
36209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36210       };
36211     }
36212   }
36213   jresult = result;
36214   return jresult;
36215 }
36216
36217
36218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36219   void * jresult ;
36220   Dali::PinchGestureDetector *result = 0 ;
36221
36222   {
36223     try {
36224       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36225     } catch (std::out_of_range& e) {
36226       {
36227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36228       };
36229     } catch (std::exception& e) {
36230       {
36231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36232       };
36233     } catch (...) {
36234       {
36235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36236       };
36237     }
36238   }
36239   jresult = (void *)result;
36240   return jresult;
36241 }
36242
36243
36244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36245   void * jresult ;
36246   Dali::PinchGestureDetector result;
36247
36248   {
36249     try {
36250       result = Dali::PinchGestureDetector::New();
36251     } catch (std::out_of_range& e) {
36252       {
36253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36254       };
36255     } catch (std::exception& e) {
36256       {
36257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36258       };
36259     } catch (...) {
36260       {
36261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36262       };
36263     }
36264   }
36265   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36266   return jresult;
36267 }
36268
36269
36270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36271   void * jresult ;
36272   Dali::BaseHandle arg1 ;
36273   Dali::BaseHandle *argp1 ;
36274   Dali::PinchGestureDetector result;
36275
36276   argp1 = (Dali::BaseHandle *)jarg1;
36277   if (!argp1) {
36278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36279     return 0;
36280   }
36281   arg1 = *argp1;
36282   {
36283     try {
36284       result = Dali::PinchGestureDetector::DownCast(arg1);
36285     } catch (std::out_of_range& e) {
36286       {
36287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36288       };
36289     } catch (std::exception& e) {
36290       {
36291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36292       };
36293     } catch (...) {
36294       {
36295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36296       };
36297     }
36298   }
36299   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36300   return jresult;
36301 }
36302
36303
36304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36305   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36306
36307   arg1 = (Dali::PinchGestureDetector *)jarg1;
36308   {
36309     try {
36310       delete arg1;
36311     } catch (std::out_of_range& e) {
36312       {
36313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36314       };
36315     } catch (std::exception& e) {
36316       {
36317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36318       };
36319     } catch (...) {
36320       {
36321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36322       };
36323     }
36324   }
36325 }
36326
36327
36328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36329   void * jresult ;
36330   Dali::PinchGestureDetector *arg1 = 0 ;
36331   Dali::PinchGestureDetector *result = 0 ;
36332
36333   arg1 = (Dali::PinchGestureDetector *)jarg1;
36334   if (!arg1) {
36335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36336     return 0;
36337   }
36338   {
36339     try {
36340       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36341     } catch (std::out_of_range& e) {
36342       {
36343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36344       };
36345     } catch (std::exception& e) {
36346       {
36347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36348       };
36349     } catch (...) {
36350       {
36351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36352       };
36353     }
36354   }
36355   jresult = (void *)result;
36356   return jresult;
36357 }
36358
36359
36360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36361   void * jresult ;
36362   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36363   Dali::PinchGestureDetector *arg2 = 0 ;
36364   Dali::PinchGestureDetector *result = 0 ;
36365
36366   arg1 = (Dali::PinchGestureDetector *)jarg1;
36367   arg2 = (Dali::PinchGestureDetector *)jarg2;
36368   if (!arg2) {
36369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36370     return 0;
36371   }
36372   {
36373     try {
36374       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36375     } catch (std::out_of_range& e) {
36376       {
36377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36378       };
36379     } catch (std::exception& e) {
36380       {
36381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36382       };
36383     } catch (...) {
36384       {
36385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36386       };
36387     }
36388   }
36389   jresult = (void *)result;
36390   return jresult;
36391 }
36392
36393
36394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36395   void * jresult ;
36396   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36397   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36398
36399   arg1 = (Dali::PinchGestureDetector *)jarg1;
36400   {
36401     try {
36402       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36403     } catch (std::out_of_range& e) {
36404       {
36405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36406       };
36407     } catch (std::exception& e) {
36408       {
36409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36410       };
36411     } catch (...) {
36412       {
36413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36414       };
36415     }
36416   }
36417   jresult = (void *)result;
36418   return jresult;
36419 }
36420
36421
36422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36423   void * jresult ;
36424   Dali::Gesture::State arg1 ;
36425   Dali::PinchGesture *result = 0 ;
36426
36427   arg1 = (Dali::Gesture::State)jarg1;
36428   {
36429     try {
36430       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36431     } catch (std::out_of_range& e) {
36432       {
36433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36434       };
36435     } catch (std::exception& e) {
36436       {
36437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36438       };
36439     } catch (...) {
36440       {
36441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36442       };
36443     }
36444   }
36445   jresult = (void *)result;
36446   return jresult;
36447 }
36448
36449
36450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36451   void * jresult ;
36452   Dali::PinchGesture *arg1 = 0 ;
36453   Dali::PinchGesture *result = 0 ;
36454
36455   arg1 = (Dali::PinchGesture *)jarg1;
36456   if (!arg1) {
36457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36458     return 0;
36459   }
36460   {
36461     try {
36462       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36463     } catch (std::out_of_range& e) {
36464       {
36465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36466       };
36467     } catch (std::exception& e) {
36468       {
36469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36470       };
36471     } catch (...) {
36472       {
36473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36474       };
36475     }
36476   }
36477   jresult = (void *)result;
36478   return jresult;
36479 }
36480
36481
36482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36483   void * jresult ;
36484   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36485   Dali::PinchGesture *arg2 = 0 ;
36486   Dali::PinchGesture *result = 0 ;
36487
36488   arg1 = (Dali::PinchGesture *)jarg1;
36489   arg2 = (Dali::PinchGesture *)jarg2;
36490   if (!arg2) {
36491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36492     return 0;
36493   }
36494   {
36495     try {
36496       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36497     } catch (std::out_of_range& e) {
36498       {
36499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36500       };
36501     } catch (std::exception& e) {
36502       {
36503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36504       };
36505     } catch (...) {
36506       {
36507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36508       };
36509     }
36510   }
36511   jresult = (void *)result;
36512   return jresult;
36513 }
36514
36515
36516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36517   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36518
36519   arg1 = (Dali::PinchGesture *)jarg1;
36520   {
36521     try {
36522       delete arg1;
36523     } catch (std::out_of_range& e) {
36524       {
36525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36526       };
36527     } catch (std::exception& e) {
36528       {
36529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36530       };
36531     } catch (...) {
36532       {
36533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36534       };
36535     }
36536   }
36537 }
36538
36539
36540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36541   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36542   float arg2 ;
36543
36544   arg1 = (Dali::PinchGesture *)jarg1;
36545   arg2 = (float)jarg2;
36546   if (arg1) (arg1)->scale = arg2;
36547 }
36548
36549
36550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36551   float jresult ;
36552   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36553   float result;
36554
36555   arg1 = (Dali::PinchGesture *)jarg1;
36556   result = (float) ((arg1)->scale);
36557   jresult = result;
36558   return jresult;
36559 }
36560
36561
36562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36563   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36564   float arg2 ;
36565
36566   arg1 = (Dali::PinchGesture *)jarg1;
36567   arg2 = (float)jarg2;
36568   if (arg1) (arg1)->speed = arg2;
36569 }
36570
36571
36572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36573   float jresult ;
36574   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36575   float result;
36576
36577   arg1 = (Dali::PinchGesture *)jarg1;
36578   result = (float) ((arg1)->speed);
36579   jresult = result;
36580   return jresult;
36581 }
36582
36583
36584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36585   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36586   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36587
36588   arg1 = (Dali::PinchGesture *)jarg1;
36589   arg2 = (Dali::Vector2 *)jarg2;
36590   if (arg1) (arg1)->screenCenterPoint = *arg2;
36591 }
36592
36593
36594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36595   void * jresult ;
36596   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36597   Dali::Vector2 *result = 0 ;
36598
36599   arg1 = (Dali::PinchGesture *)jarg1;
36600   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36601   jresult = (void *)result;
36602   return jresult;
36603 }
36604
36605
36606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36607   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36608   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36609
36610   arg1 = (Dali::PinchGesture *)jarg1;
36611   arg2 = (Dali::Vector2 *)jarg2;
36612   if (arg1) (arg1)->localCenterPoint = *arg2;
36613 }
36614
36615
36616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36617   void * jresult ;
36618   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36619   Dali::Vector2 *result = 0 ;
36620
36621   arg1 = (Dali::PinchGesture *)jarg1;
36622   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36623   jresult = (void *)result;
36624   return jresult;
36625 }
36626
36627
36628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36629   void * jresult ;
36630   Dali::TapGestureDetector *result = 0 ;
36631
36632   {
36633     try {
36634       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36635     } catch (std::out_of_range& e) {
36636       {
36637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36638       };
36639     } catch (std::exception& e) {
36640       {
36641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36642       };
36643     } catch (...) {
36644       {
36645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36646       };
36647     }
36648   }
36649   jresult = (void *)result;
36650   return jresult;
36651 }
36652
36653
36654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36655   void * jresult ;
36656   Dali::TapGestureDetector result;
36657
36658   {
36659     try {
36660       result = Dali::TapGestureDetector::New();
36661     } catch (std::out_of_range& e) {
36662       {
36663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36664       };
36665     } catch (std::exception& e) {
36666       {
36667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36668       };
36669     } catch (...) {
36670       {
36671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36672       };
36673     }
36674   }
36675   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36676   return jresult;
36677 }
36678
36679
36680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36681   void * jresult ;
36682   unsigned int arg1 ;
36683   Dali::TapGestureDetector result;
36684
36685   arg1 = (unsigned int)jarg1;
36686   {
36687     try {
36688       result = Dali::TapGestureDetector::New(arg1);
36689     } catch (std::out_of_range& e) {
36690       {
36691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36692       };
36693     } catch (std::exception& e) {
36694       {
36695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36696       };
36697     } catch (...) {
36698       {
36699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36700       };
36701     }
36702   }
36703   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36704   return jresult;
36705 }
36706
36707
36708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36709   void * jresult ;
36710   Dali::BaseHandle arg1 ;
36711   Dali::BaseHandle *argp1 ;
36712   Dali::TapGestureDetector result;
36713
36714   argp1 = (Dali::BaseHandle *)jarg1;
36715   if (!argp1) {
36716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36717     return 0;
36718   }
36719   arg1 = *argp1;
36720   {
36721     try {
36722       result = Dali::TapGestureDetector::DownCast(arg1);
36723     } catch (std::out_of_range& e) {
36724       {
36725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36726       };
36727     } catch (std::exception& e) {
36728       {
36729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36730       };
36731     } catch (...) {
36732       {
36733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36734       };
36735     }
36736   }
36737   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36738   return jresult;
36739 }
36740
36741
36742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36743   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36744
36745   arg1 = (Dali::TapGestureDetector *)jarg1;
36746   {
36747     try {
36748       delete arg1;
36749     } catch (std::out_of_range& e) {
36750       {
36751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36752       };
36753     } catch (std::exception& e) {
36754       {
36755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36756       };
36757     } catch (...) {
36758       {
36759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36760       };
36761     }
36762   }
36763 }
36764
36765
36766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36767   void * jresult ;
36768   Dali::TapGestureDetector *arg1 = 0 ;
36769   Dali::TapGestureDetector *result = 0 ;
36770
36771   arg1 = (Dali::TapGestureDetector *)jarg1;
36772   if (!arg1) {
36773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36774     return 0;
36775   }
36776   {
36777     try {
36778       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36779     } catch (std::out_of_range& e) {
36780       {
36781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36782       };
36783     } catch (std::exception& e) {
36784       {
36785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36786       };
36787     } catch (...) {
36788       {
36789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36790       };
36791     }
36792   }
36793   jresult = (void *)result;
36794   return jresult;
36795 }
36796
36797
36798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36799   void * jresult ;
36800   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36801   Dali::TapGestureDetector *arg2 = 0 ;
36802   Dali::TapGestureDetector *result = 0 ;
36803
36804   arg1 = (Dali::TapGestureDetector *)jarg1;
36805   arg2 = (Dali::TapGestureDetector *)jarg2;
36806   if (!arg2) {
36807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36808     return 0;
36809   }
36810   {
36811     try {
36812       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36813     } catch (std::out_of_range& e) {
36814       {
36815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36816       };
36817     } catch (std::exception& e) {
36818       {
36819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36820       };
36821     } catch (...) {
36822       {
36823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36824       };
36825     }
36826   }
36827   jresult = (void *)result;
36828   return jresult;
36829 }
36830
36831
36832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36833   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36834   unsigned int arg2 ;
36835
36836   arg1 = (Dali::TapGestureDetector *)jarg1;
36837   arg2 = (unsigned int)jarg2;
36838   {
36839     try {
36840       (arg1)->SetMinimumTapsRequired(arg2);
36841     } catch (std::out_of_range& e) {
36842       {
36843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36844       };
36845     } catch (std::exception& e) {
36846       {
36847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36848       };
36849     } catch (...) {
36850       {
36851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36852       };
36853     }
36854   }
36855 }
36856
36857
36858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
36859   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36860   unsigned int arg2 ;
36861
36862   arg1 = (Dali::TapGestureDetector *)jarg1;
36863   arg2 = (unsigned int)jarg2;
36864   {
36865     try {
36866       (arg1)->SetMaximumTapsRequired(arg2);
36867     } catch (std::out_of_range& e) {
36868       {
36869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36870       };
36871     } catch (std::exception& e) {
36872       {
36873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36874       };
36875     } catch (...) {
36876       {
36877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36878       };
36879     }
36880   }
36881 }
36882
36883
36884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
36885   unsigned int jresult ;
36886   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36887   unsigned int result;
36888
36889   arg1 = (Dali::TapGestureDetector *)jarg1;
36890   {
36891     try {
36892       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
36893     } catch (std::out_of_range& e) {
36894       {
36895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36896       };
36897     } catch (std::exception& e) {
36898       {
36899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36900       };
36901     } catch (...) {
36902       {
36903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36904       };
36905     }
36906   }
36907   jresult = result;
36908   return jresult;
36909 }
36910
36911
36912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
36913   unsigned int jresult ;
36914   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36915   unsigned int result;
36916
36917   arg1 = (Dali::TapGestureDetector *)jarg1;
36918   {
36919     try {
36920       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
36921     } catch (std::out_of_range& e) {
36922       {
36923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36924       };
36925     } catch (std::exception& e) {
36926       {
36927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36928       };
36929     } catch (...) {
36930       {
36931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36932       };
36933     }
36934   }
36935   jresult = result;
36936   return jresult;
36937 }
36938
36939
36940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
36941   void * jresult ;
36942   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36943   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
36944
36945   arg1 = (Dali::TapGestureDetector *)jarg1;
36946   {
36947     try {
36948       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36949     } catch (std::out_of_range& e) {
36950       {
36951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36952       };
36953     } catch (std::exception& e) {
36954       {
36955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36956       };
36957     } catch (...) {
36958       {
36959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36960       };
36961     }
36962   }
36963   jresult = (void *)result;
36964   return jresult;
36965 }
36966
36967
36968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
36969   void * jresult ;
36970   Dali::TapGesture *result = 0 ;
36971
36972   {
36973     try {
36974       result = (Dali::TapGesture *)new Dali::TapGesture();
36975     } catch (std::out_of_range& e) {
36976       {
36977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36978       };
36979     } catch (std::exception& e) {
36980       {
36981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36982       };
36983     } catch (...) {
36984       {
36985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36986       };
36987     }
36988   }
36989   jresult = (void *)result;
36990   return jresult;
36991 }
36992
36993
36994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
36995   void * jresult ;
36996   Dali::TapGesture *arg1 = 0 ;
36997   Dali::TapGesture *result = 0 ;
36998
36999   arg1 = (Dali::TapGesture *)jarg1;
37000   if (!arg1) {
37001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37002     return 0;
37003   }
37004   {
37005     try {
37006       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37007     } catch (std::out_of_range& e) {
37008       {
37009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37010       };
37011     } catch (std::exception& e) {
37012       {
37013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37014       };
37015     } catch (...) {
37016       {
37017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37018       };
37019     }
37020   }
37021   jresult = (void *)result;
37022   return jresult;
37023 }
37024
37025
37026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37027   void * jresult ;
37028   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37029   Dali::TapGesture *arg2 = 0 ;
37030   Dali::TapGesture *result = 0 ;
37031
37032   arg1 = (Dali::TapGesture *)jarg1;
37033   arg2 = (Dali::TapGesture *)jarg2;
37034   if (!arg2) {
37035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37036     return 0;
37037   }
37038   {
37039     try {
37040       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37041     } catch (std::out_of_range& e) {
37042       {
37043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37044       };
37045     } catch (std::exception& e) {
37046       {
37047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37048       };
37049     } catch (...) {
37050       {
37051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37052       };
37053     }
37054   }
37055   jresult = (void *)result;
37056   return jresult;
37057 }
37058
37059
37060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37061   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37062
37063   arg1 = (Dali::TapGesture *)jarg1;
37064   {
37065     try {
37066       delete arg1;
37067     } catch (std::out_of_range& e) {
37068       {
37069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37070       };
37071     } catch (std::exception& e) {
37072       {
37073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37074       };
37075     } catch (...) {
37076       {
37077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37078       };
37079     }
37080   }
37081 }
37082
37083
37084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37085   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37086   unsigned int arg2 ;
37087
37088   arg1 = (Dali::TapGesture *)jarg1;
37089   arg2 = (unsigned int)jarg2;
37090   if (arg1) (arg1)->numberOfTaps = arg2;
37091 }
37092
37093
37094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37095   unsigned int jresult ;
37096   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37097   unsigned int result;
37098
37099   arg1 = (Dali::TapGesture *)jarg1;
37100   result = (unsigned int) ((arg1)->numberOfTaps);
37101   jresult = result;
37102   return jresult;
37103 }
37104
37105
37106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37107   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37108   unsigned int arg2 ;
37109
37110   arg1 = (Dali::TapGesture *)jarg1;
37111   arg2 = (unsigned int)jarg2;
37112   if (arg1) (arg1)->numberOfTouches = arg2;
37113 }
37114
37115
37116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37117   unsigned int jresult ;
37118   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37119   unsigned int result;
37120
37121   arg1 = (Dali::TapGesture *)jarg1;
37122   result = (unsigned int) ((arg1)->numberOfTouches);
37123   jresult = result;
37124   return jresult;
37125 }
37126
37127
37128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37129   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37130   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37131
37132   arg1 = (Dali::TapGesture *)jarg1;
37133   arg2 = (Dali::Vector2 *)jarg2;
37134   if (arg1) (arg1)->screenPoint = *arg2;
37135 }
37136
37137
37138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37139   void * jresult ;
37140   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37141   Dali::Vector2 *result = 0 ;
37142
37143   arg1 = (Dali::TapGesture *)jarg1;
37144   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37145   jresult = (void *)result;
37146   return jresult;
37147 }
37148
37149
37150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37151   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37152   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37153
37154   arg1 = (Dali::TapGesture *)jarg1;
37155   arg2 = (Dali::Vector2 *)jarg2;
37156   if (arg1) (arg1)->localPoint = *arg2;
37157 }
37158
37159
37160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37161   void * jresult ;
37162   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37163   Dali::Vector2 *result = 0 ;
37164
37165   arg1 = (Dali::TapGesture *)jarg1;
37166   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37167   jresult = (void *)result;
37168   return jresult;
37169 }
37170
37171
37172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37173   void * jresult ;
37174   Dali::AlphaFunction *result = 0 ;
37175
37176   {
37177     try {
37178       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37179     } catch (std::out_of_range& e) {
37180       {
37181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37182       };
37183     } catch (std::exception& e) {
37184       {
37185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37186       };
37187     } catch (...) {
37188       {
37189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37190       };
37191     }
37192   }
37193   jresult = (void *)result;
37194   return jresult;
37195 }
37196
37197
37198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37199   void * jresult ;
37200   Dali::AlphaFunction::BuiltinFunction arg1 ;
37201   Dali::AlphaFunction *result = 0 ;
37202
37203   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37204   {
37205     try {
37206       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37207     } catch (std::out_of_range& e) {
37208       {
37209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37210       };
37211     } catch (std::exception& e) {
37212       {
37213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37214       };
37215     } catch (...) {
37216       {
37217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37218       };
37219     }
37220   }
37221   jresult = (void *)result;
37222   return jresult;
37223 }
37224
37225
37226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37227   void * jresult ;
37228   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37229   Dali::AlphaFunction *result = 0 ;
37230
37231   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37232   {
37233     try {
37234       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37235     } catch (std::out_of_range& e) {
37236       {
37237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37238       };
37239     } catch (std::exception& e) {
37240       {
37241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37242       };
37243     } catch (...) {
37244       {
37245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37246       };
37247     }
37248   }
37249   jresult = (void *)result;
37250   return jresult;
37251 }
37252
37253
37254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37255   void * jresult ;
37256   Dali::Vector2 *arg1 = 0 ;
37257   Dali::Vector2 *arg2 = 0 ;
37258   Dali::AlphaFunction *result = 0 ;
37259
37260   arg1 = (Dali::Vector2 *)jarg1;
37261   if (!arg1) {
37262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37263     return 0;
37264   }
37265   arg2 = (Dali::Vector2 *)jarg2;
37266   if (!arg2) {
37267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37268     return 0;
37269   }
37270   {
37271     try {
37272       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37273     } catch (std::out_of_range& e) {
37274       {
37275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37276       };
37277     } catch (std::exception& e) {
37278       {
37279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37280       };
37281     } catch (...) {
37282       {
37283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37284       };
37285     }
37286   }
37287   jresult = (void *)result;
37288   return jresult;
37289 }
37290
37291
37292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37293   void * jresult ;
37294   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37295   Dali::Vector4 result;
37296
37297   arg1 = (Dali::AlphaFunction *)jarg1;
37298   {
37299     try {
37300       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37301     } catch (std::out_of_range& e) {
37302       {
37303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37304       };
37305     } catch (std::exception& e) {
37306       {
37307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37308       };
37309     } catch (...) {
37310       {
37311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37312       };
37313     }
37314   }
37315   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37316   return jresult;
37317 }
37318
37319
37320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37321   void * jresult ;
37322   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37323   Dali::AlphaFunctionPrototype result;
37324
37325   arg1 = (Dali::AlphaFunction *)jarg1;
37326   {
37327     try {
37328       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37329     } catch (std::out_of_range& e) {
37330       {
37331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37332       };
37333     } catch (std::exception& e) {
37334       {
37335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37336       };
37337     } catch (...) {
37338       {
37339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37340       };
37341     }
37342   }
37343   jresult = (void *)result;
37344   return jresult;
37345 }
37346
37347
37348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37349   int jresult ;
37350   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37351   Dali::AlphaFunction::BuiltinFunction result;
37352
37353   arg1 = (Dali::AlphaFunction *)jarg1;
37354   {
37355     try {
37356       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37357     } catch (std::out_of_range& e) {
37358       {
37359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37360       };
37361     } catch (std::exception& e) {
37362       {
37363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37364       };
37365     } catch (...) {
37366       {
37367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37368       };
37369     }
37370   }
37371   jresult = (int)result;
37372   return jresult;
37373 }
37374
37375
37376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37377   int jresult ;
37378   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37379   Dali::AlphaFunction::Mode result;
37380
37381   arg1 = (Dali::AlphaFunction *)jarg1;
37382   {
37383     try {
37384       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37385     } catch (std::out_of_range& e) {
37386       {
37387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37388       };
37389     } catch (std::exception& e) {
37390       {
37391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37392       };
37393     } catch (...) {
37394       {
37395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37396       };
37397     }
37398   }
37399   jresult = (int)result;
37400   return jresult;
37401 }
37402
37403
37404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37405   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37406
37407   arg1 = (Dali::AlphaFunction *)jarg1;
37408   {
37409     try {
37410       delete arg1;
37411     } catch (std::out_of_range& e) {
37412       {
37413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37414       };
37415     } catch (std::exception& e) {
37416       {
37417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37418       };
37419     } catch (...) {
37420       {
37421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37422       };
37423     }
37424   }
37425 }
37426
37427
37428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37429   void * jresult ;
37430   Dali::KeyFrames result;
37431
37432   {
37433     try {
37434       result = Dali::KeyFrames::New();
37435     } catch (std::out_of_range& e) {
37436       {
37437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37438       };
37439     } catch (std::exception& e) {
37440       {
37441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37442       };
37443     } catch (...) {
37444       {
37445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37446       };
37447     }
37448   }
37449   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37450   return jresult;
37451 }
37452
37453
37454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37455   void * jresult ;
37456   Dali::BaseHandle arg1 ;
37457   Dali::BaseHandle *argp1 ;
37458   Dali::KeyFrames result;
37459
37460   argp1 = (Dali::BaseHandle *)jarg1;
37461   if (!argp1) {
37462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37463     return 0;
37464   }
37465   arg1 = *argp1;
37466   {
37467     try {
37468       result = Dali::KeyFrames::DownCast(arg1);
37469     } catch (std::out_of_range& e) {
37470       {
37471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37472       };
37473     } catch (std::exception& e) {
37474       {
37475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37476       };
37477     } catch (...) {
37478       {
37479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37480       };
37481     }
37482   }
37483   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37484   return jresult;
37485 }
37486
37487
37488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37489   void * jresult ;
37490   Dali::KeyFrames *result = 0 ;
37491
37492   {
37493     try {
37494       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37495     } catch (std::out_of_range& e) {
37496       {
37497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37498       };
37499     } catch (std::exception& e) {
37500       {
37501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37502       };
37503     } catch (...) {
37504       {
37505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37506       };
37507     }
37508   }
37509   jresult = (void *)result;
37510   return jresult;
37511 }
37512
37513
37514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37515   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37516
37517   arg1 = (Dali::KeyFrames *)jarg1;
37518   {
37519     try {
37520       delete arg1;
37521     } catch (std::out_of_range& e) {
37522       {
37523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37524       };
37525     } catch (std::exception& e) {
37526       {
37527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37528       };
37529     } catch (...) {
37530       {
37531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37532       };
37533     }
37534   }
37535 }
37536
37537
37538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37539   void * jresult ;
37540   Dali::KeyFrames *arg1 = 0 ;
37541   Dali::KeyFrames *result = 0 ;
37542
37543   arg1 = (Dali::KeyFrames *)jarg1;
37544   if (!arg1) {
37545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37546     return 0;
37547   }
37548   {
37549     try {
37550       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37551     } catch (std::out_of_range& e) {
37552       {
37553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37554       };
37555     } catch (std::exception& e) {
37556       {
37557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37558       };
37559     } catch (...) {
37560       {
37561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37562       };
37563     }
37564   }
37565   jresult = (void *)result;
37566   return jresult;
37567 }
37568
37569
37570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37571   void * jresult ;
37572   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37573   Dali::KeyFrames *arg2 = 0 ;
37574   Dali::KeyFrames *result = 0 ;
37575
37576   arg1 = (Dali::KeyFrames *)jarg1;
37577   arg2 = (Dali::KeyFrames *)jarg2;
37578   if (!arg2) {
37579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37580     return 0;
37581   }
37582   {
37583     try {
37584       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37585     } catch (std::out_of_range& e) {
37586       {
37587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37588       };
37589     } catch (std::exception& e) {
37590       {
37591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37592       };
37593     } catch (...) {
37594       {
37595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37596       };
37597     }
37598   }
37599   jresult = (void *)result;
37600   return jresult;
37601 }
37602
37603
37604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37605   int jresult ;
37606   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37607   Dali::Property::Type result;
37608
37609   arg1 = (Dali::KeyFrames *)jarg1;
37610   {
37611     try {
37612       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37613     } catch (std::out_of_range& e) {
37614       {
37615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37616       };
37617     } catch (std::exception& e) {
37618       {
37619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37620       };
37621     } catch (...) {
37622       {
37623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37624       };
37625     }
37626   }
37627   jresult = (int)result;
37628   return jresult;
37629 }
37630
37631
37632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37633   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37634   float arg2 ;
37635   Dali::Property::Value arg3 ;
37636   Dali::Property::Value *argp3 ;
37637
37638   arg1 = (Dali::KeyFrames *)jarg1;
37639   arg2 = (float)jarg2;
37640   argp3 = (Dali::Property::Value *)jarg3;
37641   if (!argp3) {
37642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37643     return ;
37644   }
37645   arg3 = *argp3;
37646   {
37647     try {
37648       (arg1)->Add(arg2,arg3);
37649     } catch (std::out_of_range& e) {
37650       {
37651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37652       };
37653     } catch (std::exception& e) {
37654       {
37655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37656       };
37657     } catch (...) {
37658       {
37659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37660       };
37661     }
37662   }
37663 }
37664
37665
37666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37667   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37668   float arg2 ;
37669   Dali::Property::Value arg3 ;
37670   Dali::AlphaFunction arg4 ;
37671   Dali::Property::Value *argp3 ;
37672   Dali::AlphaFunction *argp4 ;
37673
37674   arg1 = (Dali::KeyFrames *)jarg1;
37675   arg2 = (float)jarg2;
37676   argp3 = (Dali::Property::Value *)jarg3;
37677   if (!argp3) {
37678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37679     return ;
37680   }
37681   arg3 = *argp3;
37682   argp4 = (Dali::AlphaFunction *)jarg4;
37683   if (!argp4) {
37684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37685     return ;
37686   }
37687   arg4 = *argp4;
37688   {
37689     try {
37690       (arg1)->Add(arg2,arg3,arg4);
37691     } catch (std::out_of_range& e) {
37692       {
37693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37694       };
37695     } catch (std::exception& e) {
37696       {
37697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37698       };
37699     } catch (...) {
37700       {
37701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37702       };
37703     }
37704   }
37705 }
37706
37707
37708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37709   int jresult ;
37710   int result;
37711
37712   result = (int)Dali::Path::Property::POINTS;
37713   jresult = (int)result;
37714   return jresult;
37715 }
37716
37717
37718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37719   int jresult ;
37720   int result;
37721
37722   result = (int)Dali::Path::Property::CONTROL_POINTS;
37723   jresult = (int)result;
37724   return jresult;
37725 }
37726
37727
37728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37729   void * jresult ;
37730   Dali::Path::Property *result = 0 ;
37731
37732   {
37733     try {
37734       result = (Dali::Path::Property *)new Dali::Path::Property();
37735     } catch (std::out_of_range& e) {
37736       {
37737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37738       };
37739     } catch (std::exception& e) {
37740       {
37741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37742       };
37743     } catch (...) {
37744       {
37745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37746       };
37747     }
37748   }
37749   jresult = (void *)result;
37750   return jresult;
37751 }
37752
37753
37754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37755   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37756
37757   arg1 = (Dali::Path::Property *)jarg1;
37758   {
37759     try {
37760       delete arg1;
37761     } catch (std::out_of_range& e) {
37762       {
37763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37764       };
37765     } catch (std::exception& e) {
37766       {
37767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37768       };
37769     } catch (...) {
37770       {
37771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37772       };
37773     }
37774   }
37775 }
37776
37777
37778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37779   void * jresult ;
37780   Dali::Path result;
37781
37782   {
37783     try {
37784       result = Dali::Path::New();
37785     } catch (std::out_of_range& e) {
37786       {
37787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37788       };
37789     } catch (std::exception& e) {
37790       {
37791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37792       };
37793     } catch (...) {
37794       {
37795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37796       };
37797     }
37798   }
37799   jresult = new Dali::Path((const Dali::Path &)result);
37800   return jresult;
37801 }
37802
37803
37804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37805   void * jresult ;
37806   Dali::BaseHandle arg1 ;
37807   Dali::BaseHandle *argp1 ;
37808   Dali::Path result;
37809
37810   argp1 = (Dali::BaseHandle *)jarg1;
37811   if (!argp1) {
37812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37813     return 0;
37814   }
37815   arg1 = *argp1;
37816   {
37817     try {
37818       result = Dali::Path::DownCast(arg1);
37819     } catch (std::out_of_range& e) {
37820       {
37821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37822       };
37823     } catch (std::exception& e) {
37824       {
37825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37826       };
37827     } catch (...) {
37828       {
37829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37830       };
37831     }
37832   }
37833   jresult = new Dali::Path((const Dali::Path &)result);
37834   return jresult;
37835 }
37836
37837
37838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37839   void * jresult ;
37840   Dali::Path *result = 0 ;
37841
37842   {
37843     try {
37844       result = (Dali::Path *)new Dali::Path();
37845     } catch (std::out_of_range& e) {
37846       {
37847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37848       };
37849     } catch (std::exception& e) {
37850       {
37851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37852       };
37853     } catch (...) {
37854       {
37855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37856       };
37857     }
37858   }
37859   jresult = (void *)result;
37860   return jresult;
37861 }
37862
37863
37864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
37865   Dali::Path *arg1 = (Dali::Path *) 0 ;
37866
37867   arg1 = (Dali::Path *)jarg1;
37868   {
37869     try {
37870       delete arg1;
37871     } catch (std::out_of_range& e) {
37872       {
37873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37874       };
37875     } catch (std::exception& e) {
37876       {
37877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37878       };
37879     } catch (...) {
37880       {
37881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37882       };
37883     }
37884   }
37885 }
37886
37887
37888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
37889   void * jresult ;
37890   Dali::Path *arg1 = 0 ;
37891   Dali::Path *result = 0 ;
37892
37893   arg1 = (Dali::Path *)jarg1;
37894   if (!arg1) {
37895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37896     return 0;
37897   }
37898   {
37899     try {
37900       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
37901     } catch (std::out_of_range& e) {
37902       {
37903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37904       };
37905     } catch (std::exception& e) {
37906       {
37907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37908       };
37909     } catch (...) {
37910       {
37911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37912       };
37913     }
37914   }
37915   jresult = (void *)result;
37916   return jresult;
37917 }
37918
37919
37920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
37921   void * jresult ;
37922   Dali::Path *arg1 = (Dali::Path *) 0 ;
37923   Dali::Path *arg2 = 0 ;
37924   Dali::Path *result = 0 ;
37925
37926   arg1 = (Dali::Path *)jarg1;
37927   arg2 = (Dali::Path *)jarg2;
37928   if (!arg2) {
37929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37930     return 0;
37931   }
37932   {
37933     try {
37934       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
37935     } catch (std::out_of_range& e) {
37936       {
37937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37938       };
37939     } catch (std::exception& e) {
37940       {
37941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37942       };
37943     } catch (...) {
37944       {
37945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37946       };
37947     }
37948   }
37949   jresult = (void *)result;
37950   return jresult;
37951 }
37952
37953
37954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
37955   Dali::Path *arg1 = (Dali::Path *) 0 ;
37956   Dali::Vector3 *arg2 = 0 ;
37957
37958   arg1 = (Dali::Path *)jarg1;
37959   arg2 = (Dali::Vector3 *)jarg2;
37960   if (!arg2) {
37961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37962     return ;
37963   }
37964   {
37965     try {
37966       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
37967     } catch (std::out_of_range& e) {
37968       {
37969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37970       };
37971     } catch (std::exception& e) {
37972       {
37973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37974       };
37975     } catch (...) {
37976       {
37977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37978       };
37979     }
37980   }
37981 }
37982
37983
37984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
37985   Dali::Path *arg1 = (Dali::Path *) 0 ;
37986   Dali::Vector3 *arg2 = 0 ;
37987
37988   arg1 = (Dali::Path *)jarg1;
37989   arg2 = (Dali::Vector3 *)jarg2;
37990   if (!arg2) {
37991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37992     return ;
37993   }
37994   {
37995     try {
37996       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
37997     } catch (std::out_of_range& e) {
37998       {
37999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38000       };
38001     } catch (std::exception& e) {
38002       {
38003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38004       };
38005     } catch (...) {
38006       {
38007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38008       };
38009     }
38010   }
38011 }
38012
38013
38014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38015   Dali::Path *arg1 = (Dali::Path *) 0 ;
38016   float arg2 ;
38017
38018   arg1 = (Dali::Path *)jarg1;
38019   arg2 = (float)jarg2;
38020   {
38021     try {
38022       (arg1)->GenerateControlPoints(arg2);
38023     } catch (std::out_of_range& e) {
38024       {
38025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38026       };
38027     } catch (std::exception& e) {
38028       {
38029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38030       };
38031     } catch (...) {
38032       {
38033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38034       };
38035     }
38036   }
38037 }
38038
38039
38040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38041   Dali::Path *arg1 = (Dali::Path *) 0 ;
38042   float arg2 ;
38043   Dali::Vector3 *arg3 = 0 ;
38044   Dali::Vector3 *arg4 = 0 ;
38045
38046   arg1 = (Dali::Path *)jarg1;
38047   arg2 = (float)jarg2;
38048   arg3 = (Dali::Vector3 *)jarg3;
38049   if (!arg3) {
38050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38051     return ;
38052   }
38053   arg4 = (Dali::Vector3 *)jarg4;
38054   if (!arg4) {
38055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38056     return ;
38057   }
38058   {
38059     try {
38060       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38061     } catch (std::out_of_range& e) {
38062       {
38063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38064       };
38065     } catch (std::exception& e) {
38066       {
38067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38068       };
38069     } catch (...) {
38070       {
38071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38072       };
38073     }
38074   }
38075 }
38076
38077
38078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38079   void * jresult ;
38080   Dali::Path *arg1 = (Dali::Path *) 0 ;
38081   size_t arg2 ;
38082   Dali::Vector3 *result = 0 ;
38083
38084   arg1 = (Dali::Path *)jarg1;
38085   arg2 = (size_t)jarg2;
38086   {
38087     try {
38088       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38089     } catch (std::out_of_range& e) {
38090       {
38091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38092       };
38093     } catch (std::exception& e) {
38094       {
38095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38096       };
38097     } catch (...) {
38098       {
38099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38100       };
38101     }
38102   }
38103   jresult = (void *)result;
38104   return jresult;
38105 }
38106
38107
38108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38109   void * jresult ;
38110   Dali::Path *arg1 = (Dali::Path *) 0 ;
38111   size_t arg2 ;
38112   Dali::Vector3 *result = 0 ;
38113
38114   arg1 = (Dali::Path *)jarg1;
38115   arg2 = (size_t)jarg2;
38116   {
38117     try {
38118       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38119     } catch (std::out_of_range& e) {
38120       {
38121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38122       };
38123     } catch (std::exception& e) {
38124       {
38125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38126       };
38127     } catch (...) {
38128       {
38129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38130       };
38131     }
38132   }
38133   jresult = (void *)result;
38134   return jresult;
38135 }
38136
38137
38138 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38139   unsigned long jresult ;
38140   Dali::Path *arg1 = (Dali::Path *) 0 ;
38141   size_t result;
38142
38143   arg1 = (Dali::Path *)jarg1;
38144   {
38145     try {
38146       result = ((Dali::Path const *)arg1)->GetPointCount();
38147     } catch (std::out_of_range& e) {
38148       {
38149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38150       };
38151     } catch (std::exception& e) {
38152       {
38153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38154       };
38155     } catch (...) {
38156       {
38157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38158       };
38159     }
38160   }
38161   jresult = (unsigned long)result;
38162   return jresult;
38163 }
38164
38165
38166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38167   void * jresult ;
38168   float arg1 ;
38169   Dali::TimePeriod *result = 0 ;
38170
38171   arg1 = (float)jarg1;
38172   {
38173     try {
38174       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38175     } catch (std::out_of_range& e) {
38176       {
38177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38178       };
38179     } catch (std::exception& e) {
38180       {
38181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38182       };
38183     } catch (...) {
38184       {
38185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38186       };
38187     }
38188   }
38189   jresult = (void *)result;
38190   return jresult;
38191 }
38192
38193
38194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38195   void * jresult ;
38196   float arg1 ;
38197   float arg2 ;
38198   Dali::TimePeriod *result = 0 ;
38199
38200   arg1 = (float)jarg1;
38201   arg2 = (float)jarg2;
38202   {
38203     try {
38204       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38205     } catch (std::out_of_range& e) {
38206       {
38207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38208       };
38209     } catch (std::exception& e) {
38210       {
38211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38212       };
38213     } catch (...) {
38214       {
38215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38216       };
38217     }
38218   }
38219   jresult = (void *)result;
38220   return jresult;
38221 }
38222
38223
38224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38225   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38226
38227   arg1 = (Dali::TimePeriod *)jarg1;
38228   {
38229     try {
38230       delete arg1;
38231     } catch (std::out_of_range& e) {
38232       {
38233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38234       };
38235     } catch (std::exception& e) {
38236       {
38237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38238       };
38239     } catch (...) {
38240       {
38241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38242       };
38243     }
38244   }
38245 }
38246
38247
38248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38249   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38250   float arg2 ;
38251
38252   arg1 = (Dali::TimePeriod *)jarg1;
38253   arg2 = (float)jarg2;
38254   if (arg1) (arg1)->delaySeconds = arg2;
38255 }
38256
38257
38258 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38259   float jresult ;
38260   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38261   float result;
38262
38263   arg1 = (Dali::TimePeriod *)jarg1;
38264   result = (float) ((arg1)->delaySeconds);
38265   jresult = result;
38266   return jresult;
38267 }
38268
38269
38270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38271   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38272   float arg2 ;
38273
38274   arg1 = (Dali::TimePeriod *)jarg1;
38275   arg2 = (float)jarg2;
38276   if (arg1) (arg1)->durationSeconds = arg2;
38277 }
38278
38279
38280 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38281   float jresult ;
38282   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38283   float result;
38284
38285   arg1 = (Dali::TimePeriod *)jarg1;
38286   result = (float) ((arg1)->durationSeconds);
38287   jresult = result;
38288   return jresult;
38289 }
38290
38291
38292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38293   void * jresult ;
38294   Dali::Animation *result = 0 ;
38295
38296   {
38297     try {
38298       result = (Dali::Animation *)new Dali::Animation();
38299     } catch (std::out_of_range& e) {
38300       {
38301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38302       };
38303     } catch (std::exception& e) {
38304       {
38305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38306       };
38307     } catch (...) {
38308       {
38309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38310       };
38311     }
38312   }
38313   jresult = (void *)result;
38314   return jresult;
38315 }
38316
38317
38318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38319   void * jresult ;
38320   float arg1 ;
38321   Dali::Animation result;
38322
38323   arg1 = (float)jarg1;
38324   {
38325     try {
38326       result = Dali::Animation::New(arg1);
38327     } catch (std::out_of_range& e) {
38328       {
38329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38330       };
38331     } catch (std::exception& e) {
38332       {
38333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38334       };
38335     } catch (...) {
38336       {
38337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38338       };
38339     }
38340   }
38341   jresult = new Dali::Animation((const Dali::Animation &)result);
38342   return jresult;
38343 }
38344
38345
38346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38347   void * jresult ;
38348   Dali::BaseHandle arg1 ;
38349   Dali::BaseHandle *argp1 ;
38350   Dali::Animation result;
38351
38352   argp1 = (Dali::BaseHandle *)jarg1;
38353   if (!argp1) {
38354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38355     return 0;
38356   }
38357   arg1 = *argp1;
38358   {
38359     try {
38360       result = Dali::Animation::DownCast(arg1);
38361     } catch (std::out_of_range& e) {
38362       {
38363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38364       };
38365     } catch (std::exception& e) {
38366       {
38367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38368       };
38369     } catch (...) {
38370       {
38371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38372       };
38373     }
38374   }
38375   jresult = new Dali::Animation((const Dali::Animation &)result);
38376   return jresult;
38377 }
38378
38379
38380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38381   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38382
38383   arg1 = (Dali::Animation *)jarg1;
38384   {
38385     try {
38386       delete arg1;
38387     } catch (std::out_of_range& e) {
38388       {
38389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38390       };
38391     } catch (std::exception& e) {
38392       {
38393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38394       };
38395     } catch (...) {
38396       {
38397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38398       };
38399     }
38400   }
38401 }
38402
38403
38404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38405   void * jresult ;
38406   Dali::Animation *arg1 = 0 ;
38407   Dali::Animation *result = 0 ;
38408
38409   arg1 = (Dali::Animation *)jarg1;
38410   if (!arg1) {
38411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38412     return 0;
38413   }
38414   {
38415     try {
38416       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38417     } catch (std::out_of_range& e) {
38418       {
38419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38420       };
38421     } catch (std::exception& e) {
38422       {
38423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38424       };
38425     } catch (...) {
38426       {
38427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38428       };
38429     }
38430   }
38431   jresult = (void *)result;
38432   return jresult;
38433 }
38434
38435
38436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38437   void * jresult ;
38438   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38439   Dali::Animation *arg2 = 0 ;
38440   Dali::Animation *result = 0 ;
38441
38442   arg1 = (Dali::Animation *)jarg1;
38443   arg2 = (Dali::Animation *)jarg2;
38444   if (!arg2) {
38445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38446     return 0;
38447   }
38448   {
38449     try {
38450       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38451     } catch (std::out_of_range& e) {
38452       {
38453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38454       };
38455     } catch (std::exception& e) {
38456       {
38457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38458       };
38459     } catch (...) {
38460       {
38461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38462       };
38463     }
38464   }
38465   jresult = (void *)result;
38466   return jresult;
38467 }
38468
38469
38470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38471   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38472   float arg2 ;
38473
38474   arg1 = (Dali::Animation *)jarg1;
38475   arg2 = (float)jarg2;
38476   {
38477     try {
38478       (arg1)->SetDuration(arg2);
38479     } catch (std::out_of_range& e) {
38480       {
38481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38482       };
38483     } catch (std::exception& e) {
38484       {
38485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38486       };
38487     } catch (...) {
38488       {
38489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38490       };
38491     }
38492   }
38493 }
38494
38495
38496 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38497   float jresult ;
38498   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38499   float result;
38500
38501   arg1 = (Dali::Animation *)jarg1;
38502   {
38503     try {
38504       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38505     } catch (std::out_of_range& e) {
38506       {
38507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38508       };
38509     } catch (std::exception& e) {
38510       {
38511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38512       };
38513     } catch (...) {
38514       {
38515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38516       };
38517     }
38518   }
38519   jresult = result;
38520   return jresult;
38521 }
38522
38523
38524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38525   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38526   bool arg2 ;
38527
38528   arg1 = (Dali::Animation *)jarg1;
38529   arg2 = jarg2 ? true : false;
38530   {
38531     try {
38532       (arg1)->SetLooping(arg2);
38533     } catch (std::out_of_range& e) {
38534       {
38535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38536       };
38537     } catch (std::exception& e) {
38538       {
38539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38540       };
38541     } catch (...) {
38542       {
38543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38544       };
38545     }
38546   }
38547 }
38548
38549
38550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38551   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38552   int arg2 ;
38553
38554   arg1 = (Dali::Animation *)jarg1;
38555   arg2 = (int)jarg2;
38556   {
38557     try {
38558       (arg1)->SetLoopCount(arg2);
38559     } catch (std::out_of_range& e) {
38560       {
38561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38562       };
38563     } catch (std::exception& e) {
38564       {
38565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38566       };
38567     } catch (...) {
38568       {
38569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38570       };
38571     }
38572   }
38573 }
38574
38575
38576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38577   int jresult ;
38578   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38579   int result;
38580
38581   arg1 = (Dali::Animation *)jarg1;
38582   {
38583     try {
38584       result = (int)(arg1)->GetLoopCount();
38585     } catch (std::out_of_range& e) {
38586       {
38587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38588       };
38589     } catch (std::exception& e) {
38590       {
38591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38592       };
38593     } catch (...) {
38594       {
38595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38596       };
38597     }
38598   }
38599   jresult = result;
38600   return jresult;
38601 }
38602
38603
38604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38605   int jresult ;
38606   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38607   int result;
38608
38609   arg1 = (Dali::Animation *)jarg1;
38610   {
38611     try {
38612       result = (int)(arg1)->GetCurrentLoop();
38613     } catch (std::out_of_range& e) {
38614       {
38615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38616       };
38617     } catch (std::exception& e) {
38618       {
38619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38620       };
38621     } catch (...) {
38622       {
38623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38624       };
38625     }
38626   }
38627   jresult = result;
38628   return jresult;
38629 }
38630
38631
38632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38633   unsigned int jresult ;
38634   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38635   bool result;
38636
38637   arg1 = (Dali::Animation *)jarg1;
38638   {
38639     try {
38640       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38641     } catch (std::out_of_range& e) {
38642       {
38643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38644       };
38645     } catch (std::exception& e) {
38646       {
38647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38648       };
38649     } catch (...) {
38650       {
38651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38652       };
38653     }
38654   }
38655   jresult = result;
38656   return jresult;
38657 }
38658
38659
38660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38661   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38662   Dali::Animation::EndAction arg2 ;
38663
38664   arg1 = (Dali::Animation *)jarg1;
38665   arg2 = (Dali::Animation::EndAction)jarg2;
38666   {
38667     try {
38668       (arg1)->SetEndAction(arg2);
38669     } catch (std::out_of_range& e) {
38670       {
38671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38672       };
38673     } catch (std::exception& e) {
38674       {
38675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38676       };
38677     } catch (...) {
38678       {
38679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38680       };
38681     }
38682   }
38683 }
38684
38685
38686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38687   int jresult ;
38688   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38689   Dali::Animation::EndAction result;
38690
38691   arg1 = (Dali::Animation *)jarg1;
38692   {
38693     try {
38694       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38695     } catch (std::out_of_range& e) {
38696       {
38697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38698       };
38699     } catch (std::exception& e) {
38700       {
38701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38702       };
38703     } catch (...) {
38704       {
38705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38706       };
38707     }
38708   }
38709   jresult = (int)result;
38710   return jresult;
38711 }
38712
38713
38714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38715   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38716   Dali::Animation::EndAction arg2 ;
38717
38718   arg1 = (Dali::Animation *)jarg1;
38719   arg2 = (Dali::Animation::EndAction)jarg2;
38720   {
38721     try {
38722       (arg1)->SetDisconnectAction(arg2);
38723     } catch (std::out_of_range& e) {
38724       {
38725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38726       };
38727     } catch (std::exception& e) {
38728       {
38729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38730       };
38731     } catch (...) {
38732       {
38733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38734       };
38735     }
38736   }
38737 }
38738
38739
38740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38741   int jresult ;
38742   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38743   Dali::Animation::EndAction result;
38744
38745   arg1 = (Dali::Animation *)jarg1;
38746   {
38747     try {
38748       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38749     } catch (std::out_of_range& e) {
38750       {
38751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38752       };
38753     } catch (std::exception& e) {
38754       {
38755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38756       };
38757     } catch (...) {
38758       {
38759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38760       };
38761     }
38762   }
38763   jresult = (int)result;
38764   return jresult;
38765 }
38766
38767
38768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38769   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38770   Dali::AlphaFunction arg2 ;
38771   Dali::AlphaFunction *argp2 ;
38772
38773   arg1 = (Dali::Animation *)jarg1;
38774   argp2 = (Dali::AlphaFunction *)jarg2;
38775   if (!argp2) {
38776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38777     return ;
38778   }
38779   arg2 = *argp2;
38780   {
38781     try {
38782       (arg1)->SetDefaultAlphaFunction(arg2);
38783     } catch (std::out_of_range& e) {
38784       {
38785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38786       };
38787     } catch (std::exception& e) {
38788       {
38789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38790       };
38791     } catch (...) {
38792       {
38793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38794       };
38795     }
38796   }
38797 }
38798
38799
38800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
38801   void * jresult ;
38802   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38803   Dali::AlphaFunction result;
38804
38805   arg1 = (Dali::Animation *)jarg1;
38806   {
38807     try {
38808       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
38809     } catch (std::out_of_range& e) {
38810       {
38811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38812       };
38813     } catch (std::exception& e) {
38814       {
38815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38816       };
38817     } catch (...) {
38818       {
38819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38820       };
38821     }
38822   }
38823   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
38824   return jresult;
38825 }
38826
38827
38828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
38829   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38830   float arg2 ;
38831
38832   arg1 = (Dali::Animation *)jarg1;
38833   arg2 = (float)jarg2;
38834   {
38835     try {
38836       (arg1)->SetCurrentProgress(arg2);
38837     } catch (std::out_of_range& e) {
38838       {
38839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38840       };
38841     } catch (std::exception& e) {
38842       {
38843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38844       };
38845     } catch (...) {
38846       {
38847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38848       };
38849     }
38850   }
38851 }
38852
38853
38854 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
38855   float jresult ;
38856   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38857   float result;
38858
38859   arg1 = (Dali::Animation *)jarg1;
38860   {
38861     try {
38862       result = (float)(arg1)->GetCurrentProgress();
38863     } catch (std::out_of_range& e) {
38864       {
38865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38866       };
38867     } catch (std::exception& e) {
38868       {
38869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38870       };
38871     } catch (...) {
38872       {
38873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38874       };
38875     }
38876   }
38877   jresult = result;
38878   return jresult;
38879 }
38880
38881
38882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
38883   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38884   float arg2 ;
38885
38886   arg1 = (Dali::Animation *)jarg1;
38887   arg2 = (float)jarg2;
38888   {
38889     try {
38890       (arg1)->SetSpeedFactor(arg2);
38891     } catch (std::out_of_range& e) {
38892       {
38893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38894       };
38895     } catch (std::exception& e) {
38896       {
38897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38898       };
38899     } catch (...) {
38900       {
38901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38902       };
38903     }
38904   }
38905 }
38906
38907
38908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
38909   float jresult ;
38910   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38911   float result;
38912
38913   arg1 = (Dali::Animation *)jarg1;
38914   {
38915     try {
38916       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
38917     } catch (std::out_of_range& e) {
38918       {
38919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38920       };
38921     } catch (std::exception& e) {
38922       {
38923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38924       };
38925     } catch (...) {
38926       {
38927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38928       };
38929     }
38930   }
38931   jresult = result;
38932   return jresult;
38933 }
38934
38935
38936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
38937   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38938   Dali::Vector2 *arg2 = 0 ;
38939
38940   arg1 = (Dali::Animation *)jarg1;
38941   arg2 = (Dali::Vector2 *)jarg2;
38942   if (!arg2) {
38943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38944     return ;
38945   }
38946   {
38947     try {
38948       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
38949     } catch (std::out_of_range& e) {
38950       {
38951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38952       };
38953     } catch (std::exception& e) {
38954       {
38955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38956       };
38957     } catch (...) {
38958       {
38959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38960       };
38961     }
38962   }
38963 }
38964
38965
38966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
38967   void * jresult ;
38968   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38969   Dali::Vector2 result;
38970
38971   arg1 = (Dali::Animation *)jarg1;
38972   {
38973     try {
38974       result = ((Dali::Animation const *)arg1)->GetPlayRange();
38975     } catch (std::out_of_range& e) {
38976       {
38977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38978       };
38979     } catch (std::exception& e) {
38980       {
38981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38982       };
38983     } catch (...) {
38984       {
38985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38986       };
38987     }
38988   }
38989   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38990   return jresult;
38991 }
38992
38993
38994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
38995   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38996
38997   arg1 = (Dali::Animation *)jarg1;
38998   {
38999     try {
39000       (arg1)->Play();
39001     } catch (std::out_of_range& e) {
39002       {
39003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39004       };
39005     } catch (std::exception& e) {
39006       {
39007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39008       };
39009     } catch (...) {
39010       {
39011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39012       };
39013     }
39014   }
39015 }
39016
39017
39018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39019   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39020   float arg2 ;
39021
39022   arg1 = (Dali::Animation *)jarg1;
39023   arg2 = (float)jarg2;
39024   {
39025     try {
39026       (arg1)->PlayFrom(arg2);
39027     } catch (std::out_of_range& e) {
39028       {
39029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39030       };
39031     } catch (std::exception& e) {
39032       {
39033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39034       };
39035     } catch (...) {
39036       {
39037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39038       };
39039     }
39040   }
39041 }
39042
39043
39044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39045   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39046
39047   arg1 = (Dali::Animation *)jarg1;
39048   {
39049     try {
39050       (arg1)->Pause();
39051     } catch (std::out_of_range& e) {
39052       {
39053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39054       };
39055     } catch (std::exception& e) {
39056       {
39057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39058       };
39059     } catch (...) {
39060       {
39061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39062       };
39063     }
39064   }
39065 }
39066
39067
39068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39069   int jresult ;
39070   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39071   Dali::Animation::State result;
39072
39073   arg1 = (Dali::Animation *)jarg1;
39074   {
39075     try {
39076       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39077     } catch (std::out_of_range& e) {
39078       {
39079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39080       };
39081     } catch (std::exception& e) {
39082       {
39083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39084       };
39085     } catch (...) {
39086       {
39087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39088       };
39089     }
39090   }
39091   jresult = (int)result;
39092   return jresult;
39093 }
39094
39095
39096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39097   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39098
39099   arg1 = (Dali::Animation *)jarg1;
39100   {
39101     try {
39102       (arg1)->Stop();
39103     } catch (std::out_of_range& e) {
39104       {
39105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39106       };
39107     } catch (std::exception& e) {
39108       {
39109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39110       };
39111     } catch (...) {
39112       {
39113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39114       };
39115     }
39116   }
39117 }
39118
39119
39120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39121   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39122
39123   arg1 = (Dali::Animation *)jarg1;
39124   {
39125     try {
39126       (arg1)->Clear();
39127     } catch (std::out_of_range& e) {
39128       {
39129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39130       };
39131     } catch (std::exception& e) {
39132       {
39133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39134       };
39135     } catch (...) {
39136       {
39137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39138       };
39139     }
39140   }
39141 }
39142
39143
39144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39145   void * jresult ;
39146   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39147   Dali::Animation::AnimationSignalType *result = 0 ;
39148
39149   arg1 = (Dali::Animation *)jarg1;
39150   {
39151     try {
39152       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39153     } catch (std::out_of_range& e) {
39154       {
39155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39156       };
39157     } catch (std::exception& e) {
39158       {
39159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39160       };
39161     } catch (...) {
39162       {
39163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39164       };
39165     }
39166   }
39167   jresult = (void *)result;
39168   return jresult;
39169 }
39170
39171
39172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39173   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39174   SwigValueWrapper< Dali::Property > arg2 ;
39175   Dali::Property::Value arg3 ;
39176   Dali::Property *argp2 ;
39177   Dali::Property::Value *argp3 ;
39178
39179   arg1 = (Dali::Animation *)jarg1;
39180   argp2 = (Dali::Property *)jarg2;
39181   if (!argp2) {
39182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39183     return ;
39184   }
39185   arg2 = *argp2;
39186   argp3 = (Dali::Property::Value *)jarg3;
39187   if (!argp3) {
39188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39189     return ;
39190   }
39191   arg3 = *argp3;
39192   {
39193     try {
39194       (arg1)->AnimateBy(arg2,arg3);
39195     } catch (std::out_of_range& e) {
39196       {
39197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39198       };
39199     } catch (std::exception& e) {
39200       {
39201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39202       };
39203     } catch (...) {
39204       {
39205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39206       };
39207     }
39208   }
39209 }
39210
39211
39212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39213   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39214   SwigValueWrapper< Dali::Property > arg2 ;
39215   Dali::Property::Value arg3 ;
39216   Dali::AlphaFunction arg4 ;
39217   Dali::Property *argp2 ;
39218   Dali::Property::Value *argp3 ;
39219   Dali::AlphaFunction *argp4 ;
39220
39221   arg1 = (Dali::Animation *)jarg1;
39222   argp2 = (Dali::Property *)jarg2;
39223   if (!argp2) {
39224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39225     return ;
39226   }
39227   arg2 = *argp2;
39228   argp3 = (Dali::Property::Value *)jarg3;
39229   if (!argp3) {
39230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39231     return ;
39232   }
39233   arg3 = *argp3;
39234   argp4 = (Dali::AlphaFunction *)jarg4;
39235   if (!argp4) {
39236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39237     return ;
39238   }
39239   arg4 = *argp4;
39240   {
39241     try {
39242       (arg1)->AnimateBy(arg2,arg3,arg4);
39243     } catch (std::out_of_range& e) {
39244       {
39245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39246       };
39247     } catch (std::exception& e) {
39248       {
39249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39250       };
39251     } catch (...) {
39252       {
39253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39254       };
39255     }
39256   }
39257 }
39258
39259
39260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39261   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39262   SwigValueWrapper< Dali::Property > arg2 ;
39263   Dali::Property::Value arg3 ;
39264   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39265   Dali::Property *argp2 ;
39266   Dali::Property::Value *argp3 ;
39267   Dali::TimePeriod *argp4 ;
39268
39269   arg1 = (Dali::Animation *)jarg1;
39270   argp2 = (Dali::Property *)jarg2;
39271   if (!argp2) {
39272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39273     return ;
39274   }
39275   arg2 = *argp2;
39276   argp3 = (Dali::Property::Value *)jarg3;
39277   if (!argp3) {
39278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39279     return ;
39280   }
39281   arg3 = *argp3;
39282   argp4 = (Dali::TimePeriod *)jarg4;
39283   if (!argp4) {
39284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39285     return ;
39286   }
39287   arg4 = *argp4;
39288   {
39289     try {
39290       (arg1)->AnimateBy(arg2,arg3,arg4);
39291     } catch (std::out_of_range& e) {
39292       {
39293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39294       };
39295     } catch (std::exception& e) {
39296       {
39297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39298       };
39299     } catch (...) {
39300       {
39301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39302       };
39303     }
39304   }
39305 }
39306
39307
39308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39309   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39310   SwigValueWrapper< Dali::Property > arg2 ;
39311   Dali::Property::Value arg3 ;
39312   Dali::AlphaFunction arg4 ;
39313   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39314   Dali::Property *argp2 ;
39315   Dali::Property::Value *argp3 ;
39316   Dali::AlphaFunction *argp4 ;
39317   Dali::TimePeriod *argp5 ;
39318
39319   arg1 = (Dali::Animation *)jarg1;
39320   argp2 = (Dali::Property *)jarg2;
39321   if (!argp2) {
39322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39323     return ;
39324   }
39325   arg2 = *argp2;
39326   argp3 = (Dali::Property::Value *)jarg3;
39327   if (!argp3) {
39328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39329     return ;
39330   }
39331   arg3 = *argp3;
39332   argp4 = (Dali::AlphaFunction *)jarg4;
39333   if (!argp4) {
39334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39335     return ;
39336   }
39337   arg4 = *argp4;
39338   argp5 = (Dali::TimePeriod *)jarg5;
39339   if (!argp5) {
39340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39341     return ;
39342   }
39343   arg5 = *argp5;
39344   {
39345     try {
39346       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39347     } catch (std::out_of_range& e) {
39348       {
39349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39350       };
39351     } catch (std::exception& e) {
39352       {
39353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39354       };
39355     } catch (...) {
39356       {
39357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39358       };
39359     }
39360   }
39361 }
39362
39363
39364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39365   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39366   SwigValueWrapper< Dali::Property > arg2 ;
39367   Dali::Property::Value arg3 ;
39368   Dali::Property *argp2 ;
39369   Dali::Property::Value *argp3 ;
39370
39371   arg1 = (Dali::Animation *)jarg1;
39372   argp2 = (Dali::Property *)jarg2;
39373   if (!argp2) {
39374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39375     return ;
39376   }
39377   arg2 = *argp2;
39378   argp3 = (Dali::Property::Value *)jarg3;
39379   if (!argp3) {
39380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39381     return ;
39382   }
39383   arg3 = *argp3;
39384   {
39385     try {
39386       (arg1)->AnimateTo(arg2,arg3);
39387     } catch (std::out_of_range& e) {
39388       {
39389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39390       };
39391     } catch (std::exception& e) {
39392       {
39393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39394       };
39395     } catch (...) {
39396       {
39397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39398       };
39399     }
39400   }
39401 }
39402
39403
39404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39405   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39406   SwigValueWrapper< Dali::Property > arg2 ;
39407   Dali::Property::Value arg3 ;
39408   Dali::AlphaFunction arg4 ;
39409   Dali::Property *argp2 ;
39410   Dali::Property::Value *argp3 ;
39411   Dali::AlphaFunction *argp4 ;
39412
39413   arg1 = (Dali::Animation *)jarg1;
39414   argp2 = (Dali::Property *)jarg2;
39415   if (!argp2) {
39416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39417     return ;
39418   }
39419   arg2 = *argp2;
39420   argp3 = (Dali::Property::Value *)jarg3;
39421   if (!argp3) {
39422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39423     return ;
39424   }
39425   arg3 = *argp3;
39426   argp4 = (Dali::AlphaFunction *)jarg4;
39427   if (!argp4) {
39428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39429     return ;
39430   }
39431   arg4 = *argp4;
39432   {
39433     try {
39434       (arg1)->AnimateTo(arg2,arg3,arg4);
39435     } catch (std::out_of_range& e) {
39436       {
39437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39438       };
39439     } catch (std::exception& e) {
39440       {
39441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39442       };
39443     } catch (...) {
39444       {
39445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39446       };
39447     }
39448   }
39449 }
39450
39451
39452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39453   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39454   SwigValueWrapper< Dali::Property > arg2 ;
39455   Dali::Property::Value arg3 ;
39456   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39457   Dali::Property *argp2 ;
39458   Dali::Property::Value *argp3 ;
39459   Dali::TimePeriod *argp4 ;
39460
39461   arg1 = (Dali::Animation *)jarg1;
39462   argp2 = (Dali::Property *)jarg2;
39463   if (!argp2) {
39464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39465     return ;
39466   }
39467   arg2 = *argp2;
39468   argp3 = (Dali::Property::Value *)jarg3;
39469   if (!argp3) {
39470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39471     return ;
39472   }
39473   arg3 = *argp3;
39474   argp4 = (Dali::TimePeriod *)jarg4;
39475   if (!argp4) {
39476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39477     return ;
39478   }
39479   arg4 = *argp4;
39480   {
39481     try {
39482       (arg1)->AnimateTo(arg2,arg3,arg4);
39483     } catch (std::out_of_range& e) {
39484       {
39485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39486       };
39487     } catch (std::exception& e) {
39488       {
39489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39490       };
39491     } catch (...) {
39492       {
39493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39494       };
39495     }
39496   }
39497 }
39498
39499
39500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39501   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39502   SwigValueWrapper< Dali::Property > arg2 ;
39503   Dali::Property::Value arg3 ;
39504   Dali::AlphaFunction arg4 ;
39505   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39506   Dali::Property *argp2 ;
39507   Dali::Property::Value *argp3 ;
39508   Dali::AlphaFunction *argp4 ;
39509   Dali::TimePeriod *argp5 ;
39510
39511   arg1 = (Dali::Animation *)jarg1;
39512   argp2 = (Dali::Property *)jarg2;
39513   if (!argp2) {
39514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39515     return ;
39516   }
39517   arg2 = *argp2;
39518   argp3 = (Dali::Property::Value *)jarg3;
39519   if (!argp3) {
39520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39521     return ;
39522   }
39523   arg3 = *argp3;
39524   argp4 = (Dali::AlphaFunction *)jarg4;
39525   if (!argp4) {
39526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39527     return ;
39528   }
39529   arg4 = *argp4;
39530   argp5 = (Dali::TimePeriod *)jarg5;
39531   if (!argp5) {
39532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39533     return ;
39534   }
39535   arg5 = *argp5;
39536   {
39537     try {
39538       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39539     } catch (std::out_of_range& e) {
39540       {
39541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39542       };
39543     } catch (std::exception& e) {
39544       {
39545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39546       };
39547     } catch (...) {
39548       {
39549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39550       };
39551     }
39552   }
39553 }
39554
39555
39556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39557   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39558   SwigValueWrapper< Dali::Property > arg2 ;
39559   Dali::KeyFrames *arg3 = 0 ;
39560   Dali::Property *argp2 ;
39561
39562   arg1 = (Dali::Animation *)jarg1;
39563   argp2 = (Dali::Property *)jarg2;
39564   if (!argp2) {
39565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39566     return ;
39567   }
39568   arg2 = *argp2;
39569   arg3 = (Dali::KeyFrames *)jarg3;
39570   if (!arg3) {
39571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39572     return ;
39573   }
39574   {
39575     try {
39576       (arg1)->AnimateBetween(arg2,*arg3);
39577     } catch (std::out_of_range& e) {
39578       {
39579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39580       };
39581     } catch (std::exception& e) {
39582       {
39583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39584       };
39585     } catch (...) {
39586       {
39587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39588       };
39589     }
39590   }
39591 }
39592
39593
39594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39595   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39596   SwigValueWrapper< Dali::Property > arg2 ;
39597   Dali::KeyFrames *arg3 = 0 ;
39598   Dali::Animation::Interpolation arg4 ;
39599   Dali::Property *argp2 ;
39600
39601   arg1 = (Dali::Animation *)jarg1;
39602   argp2 = (Dali::Property *)jarg2;
39603   if (!argp2) {
39604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39605     return ;
39606   }
39607   arg2 = *argp2;
39608   arg3 = (Dali::KeyFrames *)jarg3;
39609   if (!arg3) {
39610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39611     return ;
39612   }
39613   arg4 = (Dali::Animation::Interpolation)jarg4;
39614   {
39615     try {
39616       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39617     } catch (std::out_of_range& e) {
39618       {
39619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39620       };
39621     } catch (std::exception& e) {
39622       {
39623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39624       };
39625     } catch (...) {
39626       {
39627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39628       };
39629     }
39630   }
39631 }
39632
39633
39634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39635   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39636   SwigValueWrapper< Dali::Property > arg2 ;
39637   Dali::KeyFrames *arg3 = 0 ;
39638   Dali::AlphaFunction arg4 ;
39639   Dali::Property *argp2 ;
39640   Dali::AlphaFunction *argp4 ;
39641
39642   arg1 = (Dali::Animation *)jarg1;
39643   argp2 = (Dali::Property *)jarg2;
39644   if (!argp2) {
39645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39646     return ;
39647   }
39648   arg2 = *argp2;
39649   arg3 = (Dali::KeyFrames *)jarg3;
39650   if (!arg3) {
39651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39652     return ;
39653   }
39654   argp4 = (Dali::AlphaFunction *)jarg4;
39655   if (!argp4) {
39656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39657     return ;
39658   }
39659   arg4 = *argp4;
39660   {
39661     try {
39662       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39663     } catch (std::out_of_range& e) {
39664       {
39665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39666       };
39667     } catch (std::exception& e) {
39668       {
39669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39670       };
39671     } catch (...) {
39672       {
39673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39674       };
39675     }
39676   }
39677 }
39678
39679
39680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39681   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39682   SwigValueWrapper< Dali::Property > arg2 ;
39683   Dali::KeyFrames *arg3 = 0 ;
39684   Dali::AlphaFunction arg4 ;
39685   Dali::Animation::Interpolation arg5 ;
39686   Dali::Property *argp2 ;
39687   Dali::AlphaFunction *argp4 ;
39688
39689   arg1 = (Dali::Animation *)jarg1;
39690   argp2 = (Dali::Property *)jarg2;
39691   if (!argp2) {
39692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39693     return ;
39694   }
39695   arg2 = *argp2;
39696   arg3 = (Dali::KeyFrames *)jarg3;
39697   if (!arg3) {
39698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39699     return ;
39700   }
39701   argp4 = (Dali::AlphaFunction *)jarg4;
39702   if (!argp4) {
39703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39704     return ;
39705   }
39706   arg4 = *argp4;
39707   arg5 = (Dali::Animation::Interpolation)jarg5;
39708   {
39709     try {
39710       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39711     } catch (std::out_of_range& e) {
39712       {
39713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39714       };
39715     } catch (std::exception& e) {
39716       {
39717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39718       };
39719     } catch (...) {
39720       {
39721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39722       };
39723     }
39724   }
39725 }
39726
39727
39728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39729   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39730   SwigValueWrapper< Dali::Property > arg2 ;
39731   Dali::KeyFrames *arg3 = 0 ;
39732   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39733   Dali::Property *argp2 ;
39734   Dali::TimePeriod *argp4 ;
39735
39736   arg1 = (Dali::Animation *)jarg1;
39737   argp2 = (Dali::Property *)jarg2;
39738   if (!argp2) {
39739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39740     return ;
39741   }
39742   arg2 = *argp2;
39743   arg3 = (Dali::KeyFrames *)jarg3;
39744   if (!arg3) {
39745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39746     return ;
39747   }
39748   argp4 = (Dali::TimePeriod *)jarg4;
39749   if (!argp4) {
39750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39751     return ;
39752   }
39753   arg4 = *argp4;
39754   {
39755     try {
39756       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39757     } catch (std::out_of_range& e) {
39758       {
39759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39760       };
39761     } catch (std::exception& e) {
39762       {
39763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39764       };
39765     } catch (...) {
39766       {
39767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39768       };
39769     }
39770   }
39771 }
39772
39773
39774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39775   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39776   SwigValueWrapper< Dali::Property > arg2 ;
39777   Dali::KeyFrames *arg3 = 0 ;
39778   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39779   Dali::Animation::Interpolation arg5 ;
39780   Dali::Property *argp2 ;
39781   Dali::TimePeriod *argp4 ;
39782
39783   arg1 = (Dali::Animation *)jarg1;
39784   argp2 = (Dali::Property *)jarg2;
39785   if (!argp2) {
39786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39787     return ;
39788   }
39789   arg2 = *argp2;
39790   arg3 = (Dali::KeyFrames *)jarg3;
39791   if (!arg3) {
39792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39793     return ;
39794   }
39795   argp4 = (Dali::TimePeriod *)jarg4;
39796   if (!argp4) {
39797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39798     return ;
39799   }
39800   arg4 = *argp4;
39801   arg5 = (Dali::Animation::Interpolation)jarg5;
39802   {
39803     try {
39804       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39805     } catch (std::out_of_range& e) {
39806       {
39807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39808       };
39809     } catch (std::exception& e) {
39810       {
39811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39812       };
39813     } catch (...) {
39814       {
39815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39816       };
39817     }
39818   }
39819 }
39820
39821
39822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39823   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39824   SwigValueWrapper< Dali::Property > arg2 ;
39825   Dali::KeyFrames *arg3 = 0 ;
39826   Dali::AlphaFunction arg4 ;
39827   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39828   Dali::Property *argp2 ;
39829   Dali::AlphaFunction *argp4 ;
39830   Dali::TimePeriod *argp5 ;
39831
39832   arg1 = (Dali::Animation *)jarg1;
39833   argp2 = (Dali::Property *)jarg2;
39834   if (!argp2) {
39835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39836     return ;
39837   }
39838   arg2 = *argp2;
39839   arg3 = (Dali::KeyFrames *)jarg3;
39840   if (!arg3) {
39841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39842     return ;
39843   }
39844   argp4 = (Dali::AlphaFunction *)jarg4;
39845   if (!argp4) {
39846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39847     return ;
39848   }
39849   arg4 = *argp4;
39850   argp5 = (Dali::TimePeriod *)jarg5;
39851   if (!argp5) {
39852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39853     return ;
39854   }
39855   arg5 = *argp5;
39856   {
39857     try {
39858       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39859     } catch (std::out_of_range& e) {
39860       {
39861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39862       };
39863     } catch (std::exception& e) {
39864       {
39865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39866       };
39867     } catch (...) {
39868       {
39869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39870       };
39871     }
39872   }
39873 }
39874
39875
39876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
39877   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39878   SwigValueWrapper< Dali::Property > arg2 ;
39879   Dali::KeyFrames *arg3 = 0 ;
39880   Dali::AlphaFunction arg4 ;
39881   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39882   Dali::Animation::Interpolation arg6 ;
39883   Dali::Property *argp2 ;
39884   Dali::AlphaFunction *argp4 ;
39885   Dali::TimePeriod *argp5 ;
39886
39887   arg1 = (Dali::Animation *)jarg1;
39888   argp2 = (Dali::Property *)jarg2;
39889   if (!argp2) {
39890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39891     return ;
39892   }
39893   arg2 = *argp2;
39894   arg3 = (Dali::KeyFrames *)jarg3;
39895   if (!arg3) {
39896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39897     return ;
39898   }
39899   argp4 = (Dali::AlphaFunction *)jarg4;
39900   if (!argp4) {
39901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39902     return ;
39903   }
39904   arg4 = *argp4;
39905   argp5 = (Dali::TimePeriod *)jarg5;
39906   if (!argp5) {
39907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39908     return ;
39909   }
39910   arg5 = *argp5;
39911   arg6 = (Dali::Animation::Interpolation)jarg6;
39912   {
39913     try {
39914       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
39915     } catch (std::out_of_range& e) {
39916       {
39917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39918       };
39919     } catch (std::exception& e) {
39920       {
39921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39922       };
39923     } catch (...) {
39924       {
39925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39926       };
39927     }
39928   }
39929 }
39930
39931
39932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39933   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39934   Dali::Actor arg2 ;
39935   Dali::Path arg3 ;
39936   Dali::Vector3 *arg4 = 0 ;
39937   Dali::Actor *argp2 ;
39938   Dali::Path *argp3 ;
39939
39940   arg1 = (Dali::Animation *)jarg1;
39941   argp2 = (Dali::Actor *)jarg2;
39942   if (!argp2) {
39943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39944     return ;
39945   }
39946   arg2 = *argp2;
39947   argp3 = (Dali::Path *)jarg3;
39948   if (!argp3) {
39949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39950     return ;
39951   }
39952   arg3 = *argp3;
39953   arg4 = (Dali::Vector3 *)jarg4;
39954   if (!arg4) {
39955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39956     return ;
39957   }
39958   {
39959     try {
39960       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
39961     } catch (std::out_of_range& e) {
39962       {
39963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39964       };
39965     } catch (std::exception& e) {
39966       {
39967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39968       };
39969     } catch (...) {
39970       {
39971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39972       };
39973     }
39974   }
39975 }
39976
39977
39978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39979   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39980   Dali::Actor arg2 ;
39981   Dali::Path arg3 ;
39982   Dali::Vector3 *arg4 = 0 ;
39983   Dali::AlphaFunction arg5 ;
39984   Dali::Actor *argp2 ;
39985   Dali::Path *argp3 ;
39986   Dali::AlphaFunction *argp5 ;
39987
39988   arg1 = (Dali::Animation *)jarg1;
39989   argp2 = (Dali::Actor *)jarg2;
39990   if (!argp2) {
39991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39992     return ;
39993   }
39994   arg2 = *argp2;
39995   argp3 = (Dali::Path *)jarg3;
39996   if (!argp3) {
39997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39998     return ;
39999   }
40000   arg3 = *argp3;
40001   arg4 = (Dali::Vector3 *)jarg4;
40002   if (!arg4) {
40003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40004     return ;
40005   }
40006   argp5 = (Dali::AlphaFunction *)jarg5;
40007   if (!argp5) {
40008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40009     return ;
40010   }
40011   arg5 = *argp5;
40012   {
40013     try {
40014       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40015     } catch (std::out_of_range& e) {
40016       {
40017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40018       };
40019     } catch (std::exception& e) {
40020       {
40021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40022       };
40023     } catch (...) {
40024       {
40025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40026       };
40027     }
40028   }
40029 }
40030
40031
40032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40033   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40034   Dali::Actor arg2 ;
40035   Dali::Path arg3 ;
40036   Dali::Vector3 *arg4 = 0 ;
40037   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40038   Dali::Actor *argp2 ;
40039   Dali::Path *argp3 ;
40040   Dali::TimePeriod *argp5 ;
40041
40042   arg1 = (Dali::Animation *)jarg1;
40043   argp2 = (Dali::Actor *)jarg2;
40044   if (!argp2) {
40045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40046     return ;
40047   }
40048   arg2 = *argp2;
40049   argp3 = (Dali::Path *)jarg3;
40050   if (!argp3) {
40051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40052     return ;
40053   }
40054   arg3 = *argp3;
40055   arg4 = (Dali::Vector3 *)jarg4;
40056   if (!arg4) {
40057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40058     return ;
40059   }
40060   argp5 = (Dali::TimePeriod *)jarg5;
40061   if (!argp5) {
40062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40063     return ;
40064   }
40065   arg5 = *argp5;
40066   {
40067     try {
40068       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40069     } catch (std::out_of_range& e) {
40070       {
40071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40072       };
40073     } catch (std::exception& e) {
40074       {
40075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40076       };
40077     } catch (...) {
40078       {
40079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40080       };
40081     }
40082   }
40083 }
40084
40085
40086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40087   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40088   Dali::Actor arg2 ;
40089   Dali::Path arg3 ;
40090   Dali::Vector3 *arg4 = 0 ;
40091   Dali::AlphaFunction arg5 ;
40092   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40093   Dali::Actor *argp2 ;
40094   Dali::Path *argp3 ;
40095   Dali::AlphaFunction *argp5 ;
40096   Dali::TimePeriod *argp6 ;
40097
40098   arg1 = (Dali::Animation *)jarg1;
40099   argp2 = (Dali::Actor *)jarg2;
40100   if (!argp2) {
40101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40102     return ;
40103   }
40104   arg2 = *argp2;
40105   argp3 = (Dali::Path *)jarg3;
40106   if (!argp3) {
40107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40108     return ;
40109   }
40110   arg3 = *argp3;
40111   arg4 = (Dali::Vector3 *)jarg4;
40112   if (!arg4) {
40113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40114     return ;
40115   }
40116   argp5 = (Dali::AlphaFunction *)jarg5;
40117   if (!argp5) {
40118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40119     return ;
40120   }
40121   arg5 = *argp5;
40122   argp6 = (Dali::TimePeriod *)jarg6;
40123   if (!argp6) {
40124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40125     return ;
40126   }
40127   arg6 = *argp6;
40128   {
40129     try {
40130       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40131     } catch (std::out_of_range& e) {
40132       {
40133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40134       };
40135     } catch (std::exception& e) {
40136       {
40137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40138       };
40139     } catch (...) {
40140       {
40141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40142       };
40143     }
40144   }
40145 }
40146
40147
40148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40149   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40150   Dali::Actor arg2 ;
40151   float arg3 ;
40152   Dali::Actor *argp2 ;
40153
40154   arg1 = (Dali::Animation *)jarg1;
40155   argp2 = (Dali::Actor *)jarg2;
40156   if (!argp2) {
40157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40158     return ;
40159   }
40160   arg2 = *argp2;
40161   arg3 = (float)jarg3;
40162   {
40163     try {
40164       (arg1)->Show(arg2,arg3);
40165     } catch (std::out_of_range& e) {
40166       {
40167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40168       };
40169     } catch (std::exception& e) {
40170       {
40171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40172       };
40173     } catch (...) {
40174       {
40175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40176       };
40177     }
40178   }
40179 }
40180
40181
40182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40183   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40184   Dali::Actor arg2 ;
40185   float arg3 ;
40186   Dali::Actor *argp2 ;
40187
40188   arg1 = (Dali::Animation *)jarg1;
40189   argp2 = (Dali::Actor *)jarg2;
40190   if (!argp2) {
40191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40192     return ;
40193   }
40194   arg2 = *argp2;
40195   arg3 = (float)jarg3;
40196   {
40197     try {
40198       (arg1)->Hide(arg2,arg3);
40199     } catch (std::out_of_range& e) {
40200       {
40201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40202       };
40203     } catch (std::exception& e) {
40204       {
40205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40206       };
40207     } catch (...) {
40208       {
40209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40210       };
40211     }
40212   }
40213 }
40214
40215
40216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40217   int jresult ;
40218   int result;
40219
40220   result = (int)Dali::LinearConstrainer::Property::VALUE;
40221   jresult = (int)result;
40222   return jresult;
40223 }
40224
40225
40226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40227   int jresult ;
40228   int result;
40229
40230   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40231   jresult = (int)result;
40232   return jresult;
40233 }
40234
40235
40236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40237   void * jresult ;
40238   Dali::LinearConstrainer::Property *result = 0 ;
40239
40240   {
40241     try {
40242       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40243     } catch (std::out_of_range& e) {
40244       {
40245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40246       };
40247     } catch (std::exception& e) {
40248       {
40249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40250       };
40251     } catch (...) {
40252       {
40253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40254       };
40255     }
40256   }
40257   jresult = (void *)result;
40258   return jresult;
40259 }
40260
40261
40262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40263   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40264
40265   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40266   {
40267     try {
40268       delete arg1;
40269     } catch (std::out_of_range& e) {
40270       {
40271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40272       };
40273     } catch (std::exception& e) {
40274       {
40275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40276       };
40277     } catch (...) {
40278       {
40279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40280       };
40281     }
40282   }
40283 }
40284
40285
40286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40287   void * jresult ;
40288   Dali::LinearConstrainer result;
40289
40290   {
40291     try {
40292       result = Dali::LinearConstrainer::New();
40293     } catch (std::out_of_range& e) {
40294       {
40295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40296       };
40297     } catch (std::exception& e) {
40298       {
40299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40300       };
40301     } catch (...) {
40302       {
40303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40304       };
40305     }
40306   }
40307   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40308   return jresult;
40309 }
40310
40311
40312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40313   void * jresult ;
40314   Dali::BaseHandle arg1 ;
40315   Dali::BaseHandle *argp1 ;
40316   Dali::LinearConstrainer result;
40317
40318   argp1 = (Dali::BaseHandle *)jarg1;
40319   if (!argp1) {
40320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40321     return 0;
40322   }
40323   arg1 = *argp1;
40324   {
40325     try {
40326       result = Dali::LinearConstrainer::DownCast(arg1);
40327     } catch (std::out_of_range& e) {
40328       {
40329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40330       };
40331     } catch (std::exception& e) {
40332       {
40333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40334       };
40335     } catch (...) {
40336       {
40337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40338       };
40339     }
40340   }
40341   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40342   return jresult;
40343 }
40344
40345
40346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40347   void * jresult ;
40348   Dali::LinearConstrainer *result = 0 ;
40349
40350   {
40351     try {
40352       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40353     } catch (std::out_of_range& e) {
40354       {
40355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40356       };
40357     } catch (std::exception& e) {
40358       {
40359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40360       };
40361     } catch (...) {
40362       {
40363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40364       };
40365     }
40366   }
40367   jresult = (void *)result;
40368   return jresult;
40369 }
40370
40371
40372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40373   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40374
40375   arg1 = (Dali::LinearConstrainer *)jarg1;
40376   {
40377     try {
40378       delete arg1;
40379     } catch (std::out_of_range& e) {
40380       {
40381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40382       };
40383     } catch (std::exception& e) {
40384       {
40385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40386       };
40387     } catch (...) {
40388       {
40389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40390       };
40391     }
40392   }
40393 }
40394
40395
40396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40397   void * jresult ;
40398   Dali::LinearConstrainer *arg1 = 0 ;
40399   Dali::LinearConstrainer *result = 0 ;
40400
40401   arg1 = (Dali::LinearConstrainer *)jarg1;
40402   if (!arg1) {
40403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40404     return 0;
40405   }
40406   {
40407     try {
40408       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40409     } catch (std::out_of_range& e) {
40410       {
40411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40412       };
40413     } catch (std::exception& e) {
40414       {
40415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40416       };
40417     } catch (...) {
40418       {
40419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40420       };
40421     }
40422   }
40423   jresult = (void *)result;
40424   return jresult;
40425 }
40426
40427
40428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40429   void * jresult ;
40430   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40431   Dali::LinearConstrainer *arg2 = 0 ;
40432   Dali::LinearConstrainer *result = 0 ;
40433
40434   arg1 = (Dali::LinearConstrainer *)jarg1;
40435   arg2 = (Dali::LinearConstrainer *)jarg2;
40436   if (!arg2) {
40437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40438     return 0;
40439   }
40440   {
40441     try {
40442       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40443     } catch (std::out_of_range& e) {
40444       {
40445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40446       };
40447     } catch (std::exception& e) {
40448       {
40449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40450       };
40451     } catch (...) {
40452       {
40453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40454       };
40455     }
40456   }
40457   jresult = (void *)result;
40458   return jresult;
40459 }
40460
40461
40462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40463   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40464   SwigValueWrapper< Dali::Property > arg2 ;
40465   SwigValueWrapper< Dali::Property > arg3 ;
40466   Dali::Vector2 *arg4 = 0 ;
40467   Dali::Vector2 *arg5 = 0 ;
40468   Dali::Property *argp2 ;
40469   Dali::Property *argp3 ;
40470
40471   arg1 = (Dali::LinearConstrainer *)jarg1;
40472   argp2 = (Dali::Property *)jarg2;
40473   if (!argp2) {
40474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40475     return ;
40476   }
40477   arg2 = *argp2;
40478   argp3 = (Dali::Property *)jarg3;
40479   if (!argp3) {
40480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40481     return ;
40482   }
40483   arg3 = *argp3;
40484   arg4 = (Dali::Vector2 *)jarg4;
40485   if (!arg4) {
40486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40487     return ;
40488   }
40489   arg5 = (Dali::Vector2 *)jarg5;
40490   if (!arg5) {
40491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40492     return ;
40493   }
40494   {
40495     try {
40496       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40497     } catch (std::out_of_range& e) {
40498       {
40499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40500       };
40501     } catch (std::exception& e) {
40502       {
40503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40504       };
40505     } catch (...) {
40506       {
40507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40508       };
40509     }
40510   }
40511 }
40512
40513
40514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40515   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40516   SwigValueWrapper< Dali::Property > arg2 ;
40517   SwigValueWrapper< Dali::Property > arg3 ;
40518   Dali::Vector2 *arg4 = 0 ;
40519   Dali::Property *argp2 ;
40520   Dali::Property *argp3 ;
40521
40522   arg1 = (Dali::LinearConstrainer *)jarg1;
40523   argp2 = (Dali::Property *)jarg2;
40524   if (!argp2) {
40525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40526     return ;
40527   }
40528   arg2 = *argp2;
40529   argp3 = (Dali::Property *)jarg3;
40530   if (!argp3) {
40531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40532     return ;
40533   }
40534   arg3 = *argp3;
40535   arg4 = (Dali::Vector2 *)jarg4;
40536   if (!arg4) {
40537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40538     return ;
40539   }
40540   {
40541     try {
40542       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40543     } catch (std::out_of_range& e) {
40544       {
40545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40546       };
40547     } catch (std::exception& e) {
40548       {
40549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40550       };
40551     } catch (...) {
40552       {
40553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40554       };
40555     }
40556   }
40557 }
40558
40559
40560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40561   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40562   Dali::Handle *arg2 = 0 ;
40563
40564   arg1 = (Dali::LinearConstrainer *)jarg1;
40565   arg2 = (Dali::Handle *)jarg2;
40566   if (!arg2) {
40567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40568     return ;
40569   }
40570   {
40571     try {
40572       (arg1)->Remove(*arg2);
40573     } catch (std::out_of_range& e) {
40574       {
40575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40576       };
40577     } catch (std::exception& e) {
40578       {
40579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40580       };
40581     } catch (...) {
40582       {
40583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40584       };
40585     }
40586   }
40587 }
40588
40589
40590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40591   int jresult ;
40592   int result;
40593
40594   result = (int)Dali::PathConstrainer::Property::FORWARD;
40595   jresult = (int)result;
40596   return jresult;
40597 }
40598
40599
40600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40601   int jresult ;
40602   int result;
40603
40604   result = (int)Dali::PathConstrainer::Property::POINTS;
40605   jresult = (int)result;
40606   return jresult;
40607 }
40608
40609
40610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40611   int jresult ;
40612   int result;
40613
40614   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40615   jresult = (int)result;
40616   return jresult;
40617 }
40618
40619
40620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40621   void * jresult ;
40622   Dali::PathConstrainer::Property *result = 0 ;
40623
40624   {
40625     try {
40626       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40627     } catch (std::out_of_range& e) {
40628       {
40629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40630       };
40631     } catch (std::exception& e) {
40632       {
40633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40634       };
40635     } catch (...) {
40636       {
40637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40638       };
40639     }
40640   }
40641   jresult = (void *)result;
40642   return jresult;
40643 }
40644
40645
40646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40647   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40648
40649   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40650   {
40651     try {
40652       delete arg1;
40653     } catch (std::out_of_range& e) {
40654       {
40655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40656       };
40657     } catch (std::exception& e) {
40658       {
40659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40660       };
40661     } catch (...) {
40662       {
40663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40664       };
40665     }
40666   }
40667 }
40668
40669
40670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40671   void * jresult ;
40672   Dali::PathConstrainer result;
40673
40674   {
40675     try {
40676       result = Dali::PathConstrainer::New();
40677     } catch (std::out_of_range& e) {
40678       {
40679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40680       };
40681     } catch (std::exception& e) {
40682       {
40683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40684       };
40685     } catch (...) {
40686       {
40687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40688       };
40689     }
40690   }
40691   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40692   return jresult;
40693 }
40694
40695
40696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40697   void * jresult ;
40698   Dali::BaseHandle arg1 ;
40699   Dali::BaseHandle *argp1 ;
40700   Dali::PathConstrainer result;
40701
40702   argp1 = (Dali::BaseHandle *)jarg1;
40703   if (!argp1) {
40704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40705     return 0;
40706   }
40707   arg1 = *argp1;
40708   {
40709     try {
40710       result = Dali::PathConstrainer::DownCast(arg1);
40711     } catch (std::out_of_range& e) {
40712       {
40713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40714       };
40715     } catch (std::exception& e) {
40716       {
40717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40718       };
40719     } catch (...) {
40720       {
40721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40722       };
40723     }
40724   }
40725   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40726   return jresult;
40727 }
40728
40729
40730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40731   void * jresult ;
40732   Dali::PathConstrainer *result = 0 ;
40733
40734   {
40735     try {
40736       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40737     } catch (std::out_of_range& e) {
40738       {
40739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40740       };
40741     } catch (std::exception& e) {
40742       {
40743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40744       };
40745     } catch (...) {
40746       {
40747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40748       };
40749     }
40750   }
40751   jresult = (void *)result;
40752   return jresult;
40753 }
40754
40755
40756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40757   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40758
40759   arg1 = (Dali::PathConstrainer *)jarg1;
40760   {
40761     try {
40762       delete arg1;
40763     } catch (std::out_of_range& e) {
40764       {
40765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40766       };
40767     } catch (std::exception& e) {
40768       {
40769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40770       };
40771     } catch (...) {
40772       {
40773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40774       };
40775     }
40776   }
40777 }
40778
40779
40780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
40781   void * jresult ;
40782   Dali::PathConstrainer *arg1 = 0 ;
40783   Dali::PathConstrainer *result = 0 ;
40784
40785   arg1 = (Dali::PathConstrainer *)jarg1;
40786   if (!arg1) {
40787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40788     return 0;
40789   }
40790   {
40791     try {
40792       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
40793     } catch (std::out_of_range& e) {
40794       {
40795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40796       };
40797     } catch (std::exception& e) {
40798       {
40799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40800       };
40801     } catch (...) {
40802       {
40803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40804       };
40805     }
40806   }
40807   jresult = (void *)result;
40808   return jresult;
40809 }
40810
40811
40812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
40813   void * jresult ;
40814   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40815   Dali::PathConstrainer *arg2 = 0 ;
40816   Dali::PathConstrainer *result = 0 ;
40817
40818   arg1 = (Dali::PathConstrainer *)jarg1;
40819   arg2 = (Dali::PathConstrainer *)jarg2;
40820   if (!arg2) {
40821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40822     return 0;
40823   }
40824   {
40825     try {
40826       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
40827     } catch (std::out_of_range& e) {
40828       {
40829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40830       };
40831     } catch (std::exception& e) {
40832       {
40833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40834       };
40835     } catch (...) {
40836       {
40837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40838       };
40839     }
40840   }
40841   jresult = (void *)result;
40842   return jresult;
40843 }
40844
40845
40846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40847   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40848   SwigValueWrapper< Dali::Property > arg2 ;
40849   SwigValueWrapper< Dali::Property > arg3 ;
40850   Dali::Vector2 *arg4 = 0 ;
40851   Dali::Vector2 *arg5 = 0 ;
40852   Dali::Property *argp2 ;
40853   Dali::Property *argp3 ;
40854
40855   arg1 = (Dali::PathConstrainer *)jarg1;
40856   argp2 = (Dali::Property *)jarg2;
40857   if (!argp2) {
40858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40859     return ;
40860   }
40861   arg2 = *argp2;
40862   argp3 = (Dali::Property *)jarg3;
40863   if (!argp3) {
40864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40865     return ;
40866   }
40867   arg3 = *argp3;
40868   arg4 = (Dali::Vector2 *)jarg4;
40869   if (!arg4) {
40870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40871     return ;
40872   }
40873   arg5 = (Dali::Vector2 *)jarg5;
40874   if (!arg5) {
40875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40876     return ;
40877   }
40878   {
40879     try {
40880       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40881     } catch (std::out_of_range& e) {
40882       {
40883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40884       };
40885     } catch (std::exception& e) {
40886       {
40887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40888       };
40889     } catch (...) {
40890       {
40891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40892       };
40893     }
40894   }
40895 }
40896
40897
40898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40899   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40900   SwigValueWrapper< Dali::Property > arg2 ;
40901   SwigValueWrapper< Dali::Property > arg3 ;
40902   Dali::Vector2 *arg4 = 0 ;
40903   Dali::Property *argp2 ;
40904   Dali::Property *argp3 ;
40905
40906   arg1 = (Dali::PathConstrainer *)jarg1;
40907   argp2 = (Dali::Property *)jarg2;
40908   if (!argp2) {
40909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40910     return ;
40911   }
40912   arg2 = *argp2;
40913   argp3 = (Dali::Property *)jarg3;
40914   if (!argp3) {
40915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40916     return ;
40917   }
40918   arg3 = *argp3;
40919   arg4 = (Dali::Vector2 *)jarg4;
40920   if (!arg4) {
40921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40922     return ;
40923   }
40924   {
40925     try {
40926       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40927     } catch (std::out_of_range& e) {
40928       {
40929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40930       };
40931     } catch (std::exception& e) {
40932       {
40933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40934       };
40935     } catch (...) {
40936       {
40937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40938       };
40939     }
40940   }
40941 }
40942
40943
40944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
40945   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40946   Dali::Handle *arg2 = 0 ;
40947
40948   arg1 = (Dali::PathConstrainer *)jarg1;
40949   arg2 = (Dali::Handle *)jarg2;
40950   if (!arg2) {
40951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40952     return ;
40953   }
40954   {
40955     try {
40956       (arg1)->Remove(*arg2);
40957     } catch (std::out_of_range& e) {
40958       {
40959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40960       };
40961     } catch (std::exception& e) {
40962       {
40963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40964       };
40965     } catch (...) {
40966       {
40967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40968       };
40969     }
40970   }
40971 }
40972
40973
40974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
40975   int jresult ;
40976   Dali::FittingMode::Type result;
40977
40978   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
40979   jresult = (int)result;
40980   return jresult;
40981 }
40982
40983
40984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
40985   int jresult ;
40986   Dali::SamplingMode::Type result;
40987
40988   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
40989   jresult = (int)result;
40990   return jresult;
40991 }
40992
40993
40994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
40995   void * jresult ;
40996   Dali::BufferImage *result = 0 ;
40997
40998   {
40999     try {
41000       result = (Dali::BufferImage *)new Dali::BufferImage();
41001     } catch (std::out_of_range& e) {
41002       {
41003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41004       };
41005     } catch (std::exception& e) {
41006       {
41007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41008       };
41009     } catch (...) {
41010       {
41011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41012       };
41013     }
41014   }
41015   jresult = (void *)result;
41016   return jresult;
41017 }
41018
41019
41020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41021   void * jresult ;
41022   unsigned int arg1 ;
41023   unsigned int arg2 ;
41024   Dali::Pixel::Format arg3 ;
41025   Dali::BufferImage result;
41026
41027   arg1 = (unsigned int)jarg1;
41028   arg2 = (unsigned int)jarg2;
41029   arg3 = (Dali::Pixel::Format)jarg3;
41030   {
41031     try {
41032       result = Dali::BufferImage::New(arg1,arg2,arg3);
41033     } catch (std::out_of_range& e) {
41034       {
41035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41036       };
41037     } catch (std::exception& e) {
41038       {
41039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41040       };
41041     } catch (...) {
41042       {
41043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41044       };
41045     }
41046   }
41047   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41048   return jresult;
41049 }
41050
41051
41052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41053   void * jresult ;
41054   unsigned int arg1 ;
41055   unsigned int arg2 ;
41056   Dali::BufferImage result;
41057
41058   arg1 = (unsigned int)jarg1;
41059   arg2 = (unsigned int)jarg2;
41060   {
41061     try {
41062       result = Dali::BufferImage::New(arg1,arg2);
41063     } catch (std::out_of_range& e) {
41064       {
41065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41066       };
41067     } catch (std::exception& e) {
41068       {
41069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41070       };
41071     } catch (...) {
41072       {
41073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41074       };
41075     }
41076   }
41077   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41078   return jresult;
41079 }
41080
41081
41082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41083   void * jresult ;
41084   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41085   unsigned int arg2 ;
41086   unsigned int arg3 ;
41087   Dali::Pixel::Format arg4 ;
41088   unsigned int arg5 ;
41089   Dali::BufferImage result;
41090
41091   arg1 = jarg1;
41092   arg2 = (unsigned int)jarg2;
41093   arg3 = (unsigned int)jarg3;
41094   arg4 = (Dali::Pixel::Format)jarg4;
41095   arg5 = (unsigned int)jarg5;
41096   {
41097     try {
41098       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41099     } catch (std::out_of_range& e) {
41100       {
41101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41102       };
41103     } catch (std::exception& e) {
41104       {
41105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41106       };
41107     } catch (...) {
41108       {
41109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41110       };
41111     }
41112   }
41113   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41114
41115
41116   return jresult;
41117 }
41118
41119
41120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41121   void * jresult ;
41122   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41123   unsigned int arg2 ;
41124   unsigned int arg3 ;
41125   Dali::Pixel::Format arg4 ;
41126   Dali::BufferImage result;
41127
41128   arg1 = jarg1;
41129   arg2 = (unsigned int)jarg2;
41130   arg3 = (unsigned int)jarg3;
41131   arg4 = (Dali::Pixel::Format)jarg4;
41132   {
41133     try {
41134       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41135     } catch (std::out_of_range& e) {
41136       {
41137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41138       };
41139     } catch (std::exception& e) {
41140       {
41141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41142       };
41143     } catch (...) {
41144       {
41145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41146       };
41147     }
41148   }
41149   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41150
41151
41152   return jresult;
41153 }
41154
41155
41156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41157   void * jresult ;
41158   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41159   unsigned int arg2 ;
41160   unsigned int arg3 ;
41161   Dali::BufferImage result;
41162
41163   arg1 = jarg1;
41164   arg2 = (unsigned int)jarg2;
41165   arg3 = (unsigned int)jarg3;
41166   {
41167     try {
41168       result = Dali::BufferImage::New(arg1,arg2,arg3);
41169     } catch (std::out_of_range& e) {
41170       {
41171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41172       };
41173     } catch (std::exception& e) {
41174       {
41175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41176       };
41177     } catch (...) {
41178       {
41179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41180       };
41181     }
41182   }
41183   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41184
41185
41186   return jresult;
41187 }
41188
41189
41190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41191   void * jresult ;
41192   Dali::BaseHandle arg1 ;
41193   Dali::BaseHandle *argp1 ;
41194   Dali::BufferImage result;
41195
41196   argp1 = (Dali::BaseHandle *)jarg1;
41197   if (!argp1) {
41198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41199     return 0;
41200   }
41201   arg1 = *argp1;
41202   {
41203     try {
41204       result = Dali::BufferImage::DownCast(arg1);
41205     } catch (std::out_of_range& e) {
41206       {
41207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41208       };
41209     } catch (std::exception& e) {
41210       {
41211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41212       };
41213     } catch (...) {
41214       {
41215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41216       };
41217     }
41218   }
41219   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41220   return jresult;
41221 }
41222
41223
41224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41225   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41226
41227   arg1 = (Dali::BufferImage *)jarg1;
41228   {
41229     try {
41230       delete arg1;
41231     } catch (std::out_of_range& e) {
41232       {
41233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41234       };
41235     } catch (std::exception& e) {
41236       {
41237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41238       };
41239     } catch (...) {
41240       {
41241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41242       };
41243     }
41244   }
41245 }
41246
41247
41248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41249   void * jresult ;
41250   Dali::BufferImage *arg1 = 0 ;
41251   Dali::BufferImage *result = 0 ;
41252
41253   arg1 = (Dali::BufferImage *)jarg1;
41254   if (!arg1) {
41255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41256     return 0;
41257   }
41258   {
41259     try {
41260       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41261     } catch (std::out_of_range& e) {
41262       {
41263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41264       };
41265     } catch (std::exception& e) {
41266       {
41267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41268       };
41269     } catch (...) {
41270       {
41271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41272       };
41273     }
41274   }
41275   jresult = (void *)result;
41276   return jresult;
41277 }
41278
41279
41280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41281   void * jresult ;
41282   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41283   Dali::BufferImage *arg2 = 0 ;
41284   Dali::BufferImage *result = 0 ;
41285
41286   arg1 = (Dali::BufferImage *)jarg1;
41287   arg2 = (Dali::BufferImage *)jarg2;
41288   if (!arg2) {
41289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41290     return 0;
41291   }
41292   {
41293     try {
41294       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41295     } catch (std::out_of_range& e) {
41296       {
41297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41298       };
41299     } catch (std::exception& e) {
41300       {
41301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41302       };
41303     } catch (...) {
41304       {
41305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41306       };
41307     }
41308   }
41309   jresult = (void *)result;
41310   return jresult;
41311 }
41312
41313
41314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41315   void * jresult ;
41316   Dali::BufferImage result;
41317
41318   {
41319     try {
41320       result = Dali::BufferImage::WHITE();
41321     } catch (std::out_of_range& e) {
41322       {
41323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41324       };
41325     } catch (std::exception& e) {
41326       {
41327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41328       };
41329     } catch (...) {
41330       {
41331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41332       };
41333     }
41334   }
41335   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41336   return jresult;
41337 }
41338
41339
41340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41341   void * jresult ;
41342   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41343   Dali::PixelBuffer *result = 0 ;
41344
41345   arg1 = (Dali::BufferImage *)jarg1;
41346   {
41347     try {
41348       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41349     } catch (std::out_of_range& e) {
41350       {
41351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41352       };
41353     } catch (std::exception& e) {
41354       {
41355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41356       };
41357     } catch (...) {
41358       {
41359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41360       };
41361     }
41362   }
41363   jresult = (void *)result;
41364   return jresult;
41365 }
41366
41367
41368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41369   unsigned int jresult ;
41370   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41371   unsigned int result;
41372
41373   arg1 = (Dali::BufferImage *)jarg1;
41374   {
41375     try {
41376       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41377     } catch (std::out_of_range& e) {
41378       {
41379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41380       };
41381     } catch (std::exception& e) {
41382       {
41383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41384       };
41385     } catch (...) {
41386       {
41387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41388       };
41389     }
41390   }
41391   jresult = result;
41392   return jresult;
41393 }
41394
41395
41396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41397   unsigned int jresult ;
41398   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41399   unsigned int result;
41400
41401   arg1 = (Dali::BufferImage *)jarg1;
41402   {
41403     try {
41404       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41405     } catch (std::out_of_range& e) {
41406       {
41407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41408       };
41409     } catch (std::exception& e) {
41410       {
41411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41412       };
41413     } catch (...) {
41414       {
41415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41416       };
41417     }
41418   }
41419   jresult = result;
41420   return jresult;
41421 }
41422
41423
41424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41425   int jresult ;
41426   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41427   Dali::Pixel::Format result;
41428
41429   arg1 = (Dali::BufferImage *)jarg1;
41430   {
41431     try {
41432       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41433     } catch (std::out_of_range& e) {
41434       {
41435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41436       };
41437     } catch (std::exception& e) {
41438       {
41439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41440       };
41441     } catch (...) {
41442       {
41443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41444       };
41445     }
41446   }
41447   jresult = (int)result;
41448   return jresult;
41449 }
41450
41451
41452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41453   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41454
41455   arg1 = (Dali::BufferImage *)jarg1;
41456   {
41457     try {
41458       (arg1)->Update();
41459     } catch (std::out_of_range& e) {
41460       {
41461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41462       };
41463     } catch (std::exception& e) {
41464       {
41465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41466       };
41467     } catch (...) {
41468       {
41469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41470       };
41471     }
41472   }
41473 }
41474
41475
41476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41477   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41478   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41479   Dali::RectArea *argp2 ;
41480
41481   arg1 = (Dali::BufferImage *)jarg1;
41482   argp2 = (Dali::RectArea *)jarg2;
41483   if (!argp2) {
41484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41485     return ;
41486   }
41487   arg2 = *argp2;
41488   {
41489     try {
41490       (arg1)->Update(arg2);
41491     } catch (std::out_of_range& e) {
41492       {
41493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41494       };
41495     } catch (std::exception& e) {
41496       {
41497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41498       };
41499     } catch (...) {
41500       {
41501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41502       };
41503     }
41504   }
41505 }
41506
41507
41508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41509   unsigned int jresult ;
41510   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41511   bool result;
41512
41513   arg1 = (Dali::BufferImage *)jarg1;
41514   {
41515     try {
41516       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41517     } catch (std::out_of_range& e) {
41518       {
41519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41520       };
41521     } catch (std::exception& e) {
41522       {
41523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41524       };
41525     } catch (...) {
41526       {
41527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41528       };
41529     }
41530   }
41531   jresult = result;
41532   return jresult;
41533 }
41534
41535
41536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41537   void * jresult ;
41538   Dali::EncodedBufferImage *result = 0 ;
41539
41540   {
41541     try {
41542       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41543     } catch (std::out_of_range& e) {
41544       {
41545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41546       };
41547     } catch (std::exception& e) {
41548       {
41549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41550       };
41551     } catch (...) {
41552       {
41553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41554       };
41555     }
41556   }
41557   jresult = (void *)result;
41558   return jresult;
41559 }
41560
41561
41562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41563   void * jresult ;
41564   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41565   std::size_t arg2 ;
41566   Dali::EncodedBufferImage result;
41567
41568   arg1 = (uint8_t *)jarg1;
41569   arg2 = (std::size_t)jarg2;
41570   {
41571     try {
41572       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41573     } catch (std::out_of_range& e) {
41574       {
41575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41576       };
41577     } catch (std::exception& e) {
41578       {
41579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41580       };
41581     } catch (...) {
41582       {
41583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41584       };
41585     }
41586   }
41587   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41588   return jresult;
41589 }
41590
41591
41592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41593   void * jresult ;
41594   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41595   std::size_t arg2 ;
41596   Dali::ImageDimensions arg3 ;
41597   Dali::FittingMode::Type arg4 ;
41598   Dali::SamplingMode::Type arg5 ;
41599   bool arg6 ;
41600   Dali::ImageDimensions *argp3 ;
41601   Dali::EncodedBufferImage result;
41602
41603   arg1 = (uint8_t *)jarg1;
41604   arg2 = (std::size_t)jarg2;
41605   argp3 = (Dali::ImageDimensions *)jarg3;
41606   if (!argp3) {
41607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41608     return 0;
41609   }
41610   arg3 = *argp3;
41611   arg4 = (Dali::FittingMode::Type)jarg4;
41612   arg5 = (Dali::SamplingMode::Type)jarg5;
41613   arg6 = jarg6 ? true : false;
41614   {
41615     try {
41616       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41617     } catch (std::out_of_range& e) {
41618       {
41619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41620       };
41621     } catch (std::exception& e) {
41622       {
41623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41624       };
41625     } catch (...) {
41626       {
41627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41628       };
41629     }
41630   }
41631   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41632   return jresult;
41633 }
41634
41635
41636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41637   void * jresult ;
41638   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41639   std::size_t arg2 ;
41640   Dali::ImageDimensions arg3 ;
41641   Dali::FittingMode::Type arg4 ;
41642   Dali::SamplingMode::Type arg5 ;
41643   Dali::ImageDimensions *argp3 ;
41644   Dali::EncodedBufferImage result;
41645
41646   arg1 = (uint8_t *)jarg1;
41647   arg2 = (std::size_t)jarg2;
41648   argp3 = (Dali::ImageDimensions *)jarg3;
41649   if (!argp3) {
41650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41651     return 0;
41652   }
41653   arg3 = *argp3;
41654   arg4 = (Dali::FittingMode::Type)jarg4;
41655   arg5 = (Dali::SamplingMode::Type)jarg5;
41656   {
41657     try {
41658       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41659     } catch (std::out_of_range& e) {
41660       {
41661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41662       };
41663     } catch (std::exception& e) {
41664       {
41665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41666       };
41667     } catch (...) {
41668       {
41669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41670       };
41671     }
41672   }
41673   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41674   return jresult;
41675 }
41676
41677
41678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41679   void * jresult ;
41680   Dali::BaseHandle arg1 ;
41681   Dali::BaseHandle *argp1 ;
41682   Dali::EncodedBufferImage result;
41683
41684   argp1 = (Dali::BaseHandle *)jarg1;
41685   if (!argp1) {
41686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41687     return 0;
41688   }
41689   arg1 = *argp1;
41690   {
41691     try {
41692       result = Dali::EncodedBufferImage::DownCast(arg1);
41693     } catch (std::out_of_range& e) {
41694       {
41695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41696       };
41697     } catch (std::exception& e) {
41698       {
41699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41700       };
41701     } catch (...) {
41702       {
41703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41704       };
41705     }
41706   }
41707   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41708   return jresult;
41709 }
41710
41711
41712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41713   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41714
41715   arg1 = (Dali::EncodedBufferImage *)jarg1;
41716   {
41717     try {
41718       delete arg1;
41719     } catch (std::out_of_range& e) {
41720       {
41721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41722       };
41723     } catch (std::exception& e) {
41724       {
41725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41726       };
41727     } catch (...) {
41728       {
41729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41730       };
41731     }
41732   }
41733 }
41734
41735
41736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41737   void * jresult ;
41738   Dali::EncodedBufferImage *arg1 = 0 ;
41739   Dali::EncodedBufferImage *result = 0 ;
41740
41741   arg1 = (Dali::EncodedBufferImage *)jarg1;
41742   if (!arg1) {
41743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41744     return 0;
41745   }
41746   {
41747     try {
41748       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41749     } catch (std::out_of_range& e) {
41750       {
41751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41752       };
41753     } catch (std::exception& e) {
41754       {
41755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41756       };
41757     } catch (...) {
41758       {
41759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41760       };
41761     }
41762   }
41763   jresult = (void *)result;
41764   return jresult;
41765 }
41766
41767
41768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
41769   void * jresult ;
41770   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41771   Dali::EncodedBufferImage *arg2 = 0 ;
41772   Dali::EncodedBufferImage *result = 0 ;
41773
41774   arg1 = (Dali::EncodedBufferImage *)jarg1;
41775   arg2 = (Dali::EncodedBufferImage *)jarg2;
41776   if (!arg2) {
41777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41778     return 0;
41779   }
41780   {
41781     try {
41782       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
41783     } catch (std::out_of_range& e) {
41784       {
41785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41786       };
41787     } catch (std::exception& e) {
41788       {
41789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41790       };
41791     } catch (...) {
41792       {
41793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41794       };
41795     }
41796   }
41797   jresult = (void *)result;
41798   return jresult;
41799 }
41800
41801
41802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
41803   void * jresult ;
41804   Dali::NativeImage *result = 0 ;
41805
41806   {
41807     try {
41808       result = (Dali::NativeImage *)new Dali::NativeImage();
41809     } catch (std::out_of_range& e) {
41810       {
41811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41812       };
41813     } catch (std::exception& e) {
41814       {
41815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41816       };
41817     } catch (...) {
41818       {
41819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41820       };
41821     }
41822   }
41823   jresult = (void *)result;
41824   return jresult;
41825 }
41826
41827
41828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
41829   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41830
41831   arg1 = (Dali::NativeImage *)jarg1;
41832   {
41833     try {
41834       delete arg1;
41835     } catch (std::out_of_range& e) {
41836       {
41837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41838       };
41839     } catch (std::exception& e) {
41840       {
41841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41842       };
41843     } catch (...) {
41844       {
41845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41846       };
41847     }
41848   }
41849 }
41850
41851
41852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
41853   void * jresult ;
41854   Dali::NativeImage *arg1 = 0 ;
41855   Dali::NativeImage *result = 0 ;
41856
41857   arg1 = (Dali::NativeImage *)jarg1;
41858   if (!arg1) {
41859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41860     return 0;
41861   }
41862   {
41863     try {
41864       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
41865     } catch (std::out_of_range& e) {
41866       {
41867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41868       };
41869     } catch (std::exception& e) {
41870       {
41871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41872       };
41873     } catch (...) {
41874       {
41875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41876       };
41877     }
41878   }
41879   jresult = (void *)result;
41880   return jresult;
41881 }
41882
41883
41884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
41885   void * jresult ;
41886   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41887   Dali::NativeImage *arg2 = 0 ;
41888   Dali::NativeImage *result = 0 ;
41889
41890   arg1 = (Dali::NativeImage *)jarg1;
41891   arg2 = (Dali::NativeImage *)jarg2;
41892   if (!arg2) {
41893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41894     return 0;
41895   }
41896   {
41897     try {
41898       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
41899     } catch (std::out_of_range& e) {
41900       {
41901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41902       };
41903     } catch (std::exception& e) {
41904       {
41905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41906       };
41907     } catch (...) {
41908       {
41909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41910       };
41911     }
41912   }
41913   jresult = (void *)result;
41914   return jresult;
41915 }
41916
41917
41918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
41919   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41920
41921   arg1 = (Dali::NativeImage *)jarg1;
41922   {
41923     try {
41924       (arg1)->CreateGlTexture();
41925     } catch (std::out_of_range& e) {
41926       {
41927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41928       };
41929     } catch (std::exception& e) {
41930       {
41931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41932       };
41933     } catch (...) {
41934       {
41935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41936       };
41937     }
41938   }
41939 }
41940
41941
41942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
41943   void * jresult ;
41944   NativeImageInterface *arg1 = 0 ;
41945   Dali::NativeImage result;
41946
41947   arg1 = (NativeImageInterface *)jarg1;
41948   if (!arg1) {
41949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
41950     return 0;
41951   }
41952   {
41953     try {
41954       result = Dali::NativeImage::New(*arg1);
41955     } catch (std::out_of_range& e) {
41956       {
41957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41958       };
41959     } catch (std::exception& e) {
41960       {
41961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41962       };
41963     } catch (...) {
41964       {
41965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41966       };
41967     }
41968   }
41969   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
41970   return jresult;
41971 }
41972
41973
41974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
41975   void * jresult ;
41976   Dali::BaseHandle arg1 ;
41977   Dali::BaseHandle *argp1 ;
41978   Dali::NativeImage result;
41979
41980   argp1 = (Dali::BaseHandle *)jarg1;
41981   if (!argp1) {
41982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41983     return 0;
41984   }
41985   arg1 = *argp1;
41986   {
41987     try {
41988       result = Dali::NativeImage::DownCast(arg1);
41989     } catch (std::out_of_range& e) {
41990       {
41991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41992       };
41993     } catch (std::exception& e) {
41994       {
41995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41996       };
41997     } catch (...) {
41998       {
41999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42000       };
42001     }
42002   }
42003   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42004   return jresult;
42005 }
42006
42007
42008 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42009   char * jresult ;
42010   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42011   char *result = 0 ;
42012
42013   arg1 = (Dali::NativeImage *)jarg1;
42014   {
42015     try {
42016       result = (char *)(arg1)->GetCustomFragmentPreFix();
42017     } catch (std::out_of_range& e) {
42018       {
42019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42020       };
42021     } catch (std::exception& e) {
42022       {
42023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42024       };
42025     } catch (...) {
42026       {
42027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42028       };
42029     }
42030   }
42031   jresult = SWIG_csharp_string_callback((const char *)result);
42032   return jresult;
42033 }
42034
42035
42036 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42037   char * jresult ;
42038   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42039   char *result = 0 ;
42040
42041   arg1 = (Dali::NativeImage *)jarg1;
42042   {
42043     try {
42044       result = (char *)(arg1)->GetCustomSamplerTypename();
42045     } catch (std::out_of_range& e) {
42046       {
42047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42048       };
42049     } catch (std::exception& e) {
42050       {
42051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42052       };
42053     } catch (...) {
42054       {
42055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42056       };
42057     }
42058   }
42059   jresult = SWIG_csharp_string_callback((const char *)result);
42060   return jresult;
42061 }
42062
42063
42064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42065   unsigned int jresult ;
42066   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42067   bool result;
42068
42069   arg1 = (Dali::NativeImageInterface *)jarg1;
42070   {
42071     try {
42072       result = (bool)(arg1)->GlExtensionCreate();
42073     } catch (std::out_of_range& e) {
42074       {
42075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42076       };
42077     } catch (std::exception& e) {
42078       {
42079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42080       };
42081     } catch (...) {
42082       {
42083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42084       };
42085     }
42086   }
42087   jresult = result;
42088   return jresult;
42089 }
42090
42091
42092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42093   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42094
42095   arg1 = (Dali::NativeImageInterface *)jarg1;
42096   {
42097     try {
42098       (arg1)->GlExtensionDestroy();
42099     } catch (std::out_of_range& e) {
42100       {
42101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42102       };
42103     } catch (std::exception& e) {
42104       {
42105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42106       };
42107     } catch (...) {
42108       {
42109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42110       };
42111     }
42112   }
42113 }
42114
42115
42116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42117   unsigned int jresult ;
42118   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42119   unsigned int result;
42120
42121   arg1 = (Dali::NativeImageInterface *)jarg1;
42122   {
42123     try {
42124       result = (unsigned int)(arg1)->TargetTexture();
42125     } catch (std::out_of_range& e) {
42126       {
42127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42128       };
42129     } catch (std::exception& e) {
42130       {
42131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42132       };
42133     } catch (...) {
42134       {
42135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42136       };
42137     }
42138   }
42139   jresult = result;
42140   return jresult;
42141 }
42142
42143
42144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42145   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42146
42147   arg1 = (Dali::NativeImageInterface *)jarg1;
42148   {
42149     try {
42150       (arg1)->PrepareTexture();
42151     } catch (std::out_of_range& e) {
42152       {
42153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42154       };
42155     } catch (std::exception& e) {
42156       {
42157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42158       };
42159     } catch (...) {
42160       {
42161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42162       };
42163     }
42164   }
42165 }
42166
42167
42168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42169   unsigned int jresult ;
42170   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42171   unsigned int result;
42172
42173   arg1 = (Dali::NativeImageInterface *)jarg1;
42174   {
42175     try {
42176       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42177     } catch (std::out_of_range& e) {
42178       {
42179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42180       };
42181     } catch (std::exception& e) {
42182       {
42183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42184       };
42185     } catch (...) {
42186       {
42187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42188       };
42189     }
42190   }
42191   jresult = result;
42192   return jresult;
42193 }
42194
42195
42196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42197   unsigned int jresult ;
42198   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42199   unsigned int result;
42200
42201   arg1 = (Dali::NativeImageInterface *)jarg1;
42202   {
42203     try {
42204       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42205     } catch (std::out_of_range& e) {
42206       {
42207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42208       };
42209     } catch (std::exception& e) {
42210       {
42211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42212       };
42213     } catch (...) {
42214       {
42215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42216       };
42217     }
42218   }
42219   jresult = result;
42220   return jresult;
42221 }
42222
42223
42224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42225   unsigned int jresult ;
42226   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42227   bool result;
42228
42229   arg1 = (Dali::NativeImageInterface *)jarg1;
42230   {
42231     try {
42232       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42233     } catch (std::out_of_range& e) {
42234       {
42235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42236       };
42237     } catch (std::exception& e) {
42238       {
42239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42240       };
42241     } catch (...) {
42242       {
42243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42244       };
42245     }
42246   }
42247   jresult = result;
42248   return jresult;
42249 }
42250
42251
42252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42253   void * jresult ;
42254   std::string *arg1 = 0 ;
42255   Dali::ImageDimensions result;
42256
42257   if (!jarg1) {
42258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42259     return 0;
42260   }
42261   std::string arg1_str(jarg1);
42262   arg1 = &arg1_str;
42263   {
42264     try {
42265       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42266     } catch (std::out_of_range& e) {
42267       {
42268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42269       };
42270     } catch (std::exception& e) {
42271       {
42272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42273       };
42274     } catch (...) {
42275       {
42276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42277       };
42278     }
42279   }
42280   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42281
42282   //argout typemap for const std::string&
42283
42284   return jresult;
42285 }
42286
42287
42288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42289   void * jresult ;
42290   Dali::ResourceImage *result = 0 ;
42291
42292   {
42293     try {
42294       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42295     } catch (std::out_of_range& e) {
42296       {
42297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42298       };
42299     } catch (std::exception& e) {
42300       {
42301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42302       };
42303     } catch (...) {
42304       {
42305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42306       };
42307     }
42308   }
42309   jresult = (void *)result;
42310   return jresult;
42311 }
42312
42313
42314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42315   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42316
42317   arg1 = (Dali::ResourceImage *)jarg1;
42318   {
42319     try {
42320       delete arg1;
42321     } catch (std::out_of_range& e) {
42322       {
42323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42324       };
42325     } catch (std::exception& e) {
42326       {
42327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42328       };
42329     } catch (...) {
42330       {
42331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42332       };
42333     }
42334   }
42335 }
42336
42337
42338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42339   void * jresult ;
42340   Dali::ResourceImage *arg1 = 0 ;
42341   Dali::ResourceImage *result = 0 ;
42342
42343   arg1 = (Dali::ResourceImage *)jarg1;
42344   if (!arg1) {
42345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42346     return 0;
42347   }
42348   {
42349     try {
42350       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42351     } catch (std::out_of_range& e) {
42352       {
42353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42354       };
42355     } catch (std::exception& e) {
42356       {
42357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42358       };
42359     } catch (...) {
42360       {
42361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42362       };
42363     }
42364   }
42365   jresult = (void *)result;
42366   return jresult;
42367 }
42368
42369
42370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42371   void * jresult ;
42372   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42373   Dali::ResourceImage *arg2 = 0 ;
42374   Dali::ResourceImage *result = 0 ;
42375
42376   arg1 = (Dali::ResourceImage *)jarg1;
42377   arg2 = (Dali::ResourceImage *)jarg2;
42378   if (!arg2) {
42379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42380     return 0;
42381   }
42382   {
42383     try {
42384       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42385     } catch (std::out_of_range& e) {
42386       {
42387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42388       };
42389     } catch (std::exception& e) {
42390       {
42391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42392       };
42393     } catch (...) {
42394       {
42395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42396       };
42397     }
42398   }
42399   jresult = (void *)result;
42400   return jresult;
42401 }
42402
42403
42404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42405   void * jresult ;
42406   std::string *arg1 = 0 ;
42407   bool arg2 ;
42408   Dali::ResourceImage result;
42409
42410   if (!jarg1) {
42411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42412     return 0;
42413   }
42414   std::string arg1_str(jarg1);
42415   arg1 = &arg1_str;
42416   arg2 = jarg2 ? true : false;
42417   {
42418     try {
42419       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42420     } catch (std::out_of_range& e) {
42421       {
42422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42423       };
42424     } catch (std::exception& e) {
42425       {
42426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42427       };
42428     } catch (...) {
42429       {
42430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42431       };
42432     }
42433   }
42434   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42435
42436   //argout typemap for const std::string&
42437
42438   return jresult;
42439 }
42440
42441
42442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42443   void * jresult ;
42444   std::string *arg1 = 0 ;
42445   Dali::ResourceImage result;
42446
42447   if (!jarg1) {
42448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42449     return 0;
42450   }
42451   std::string arg1_str(jarg1);
42452   arg1 = &arg1_str;
42453   {
42454     try {
42455       result = Dali::ResourceImage::New((std::string const &)*arg1);
42456     } catch (std::out_of_range& e) {
42457       {
42458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42459       };
42460     } catch (std::exception& e) {
42461       {
42462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42463       };
42464     } catch (...) {
42465       {
42466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42467       };
42468     }
42469   }
42470   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42471
42472   //argout typemap for const std::string&
42473
42474   return jresult;
42475 }
42476
42477
42478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42479   void * jresult ;
42480   std::string *arg1 = 0 ;
42481   Dali::ImageDimensions arg2 ;
42482   Dali::FittingMode::Type arg3 ;
42483   Dali::SamplingMode::Type arg4 ;
42484   bool arg5 ;
42485   Dali::ImageDimensions *argp2 ;
42486   Dali::ResourceImage result;
42487
42488   if (!jarg1) {
42489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42490     return 0;
42491   }
42492   std::string arg1_str(jarg1);
42493   arg1 = &arg1_str;
42494   argp2 = (Dali::ImageDimensions *)jarg2;
42495   if (!argp2) {
42496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42497     return 0;
42498   }
42499   arg2 = *argp2;
42500   arg3 = (Dali::FittingMode::Type)jarg3;
42501   arg4 = (Dali::SamplingMode::Type)jarg4;
42502   arg5 = jarg5 ? true : false;
42503   {
42504     try {
42505       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42506     } catch (std::out_of_range& e) {
42507       {
42508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42509       };
42510     } catch (std::exception& e) {
42511       {
42512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42513       };
42514     } catch (...) {
42515       {
42516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42517       };
42518     }
42519   }
42520   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42521
42522   //argout typemap for const std::string&
42523
42524   return jresult;
42525 }
42526
42527
42528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42529   void * jresult ;
42530   std::string *arg1 = 0 ;
42531   Dali::ImageDimensions arg2 ;
42532   Dali::FittingMode::Type arg3 ;
42533   Dali::SamplingMode::Type arg4 ;
42534   Dali::ImageDimensions *argp2 ;
42535   Dali::ResourceImage result;
42536
42537   if (!jarg1) {
42538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42539     return 0;
42540   }
42541   std::string arg1_str(jarg1);
42542   arg1 = &arg1_str;
42543   argp2 = (Dali::ImageDimensions *)jarg2;
42544   if (!argp2) {
42545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42546     return 0;
42547   }
42548   arg2 = *argp2;
42549   arg3 = (Dali::FittingMode::Type)jarg3;
42550   arg4 = (Dali::SamplingMode::Type)jarg4;
42551   {
42552     try {
42553       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42554     } catch (std::out_of_range& e) {
42555       {
42556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42557       };
42558     } catch (std::exception& e) {
42559       {
42560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42561       };
42562     } catch (...) {
42563       {
42564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42565       };
42566     }
42567   }
42568   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42569
42570   //argout typemap for const std::string&
42571
42572   return jresult;
42573 }
42574
42575
42576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42577   void * jresult ;
42578   std::string *arg1 = 0 ;
42579   Dali::ImageDimensions arg2 ;
42580   Dali::FittingMode::Type arg3 ;
42581   Dali::ImageDimensions *argp2 ;
42582   Dali::ResourceImage result;
42583
42584   if (!jarg1) {
42585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42586     return 0;
42587   }
42588   std::string arg1_str(jarg1);
42589   arg1 = &arg1_str;
42590   argp2 = (Dali::ImageDimensions *)jarg2;
42591   if (!argp2) {
42592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42593     return 0;
42594   }
42595   arg2 = *argp2;
42596   arg3 = (Dali::FittingMode::Type)jarg3;
42597   {
42598     try {
42599       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42600     } catch (std::out_of_range& e) {
42601       {
42602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42603       };
42604     } catch (std::exception& e) {
42605       {
42606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42607       };
42608     } catch (...) {
42609       {
42610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42611       };
42612     }
42613   }
42614   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42615
42616   //argout typemap for const std::string&
42617
42618   return jresult;
42619 }
42620
42621
42622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42623   void * jresult ;
42624   std::string *arg1 = 0 ;
42625   Dali::ImageDimensions arg2 ;
42626   Dali::ImageDimensions *argp2 ;
42627   Dali::ResourceImage result;
42628
42629   if (!jarg1) {
42630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42631     return 0;
42632   }
42633   std::string arg1_str(jarg1);
42634   arg1 = &arg1_str;
42635   argp2 = (Dali::ImageDimensions *)jarg2;
42636   if (!argp2) {
42637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42638     return 0;
42639   }
42640   arg2 = *argp2;
42641   {
42642     try {
42643       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42644     } catch (std::out_of_range& e) {
42645       {
42646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42647       };
42648     } catch (std::exception& e) {
42649       {
42650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42651       };
42652     } catch (...) {
42653       {
42654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42655       };
42656     }
42657   }
42658   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42659
42660   //argout typemap for const std::string&
42661
42662   return jresult;
42663 }
42664
42665
42666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42667   void * jresult ;
42668   Dali::BaseHandle arg1 ;
42669   Dali::BaseHandle *argp1 ;
42670   Dali::ResourceImage result;
42671
42672   argp1 = (Dali::BaseHandle *)jarg1;
42673   if (!argp1) {
42674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42675     return 0;
42676   }
42677   arg1 = *argp1;
42678   {
42679     try {
42680       result = Dali::ResourceImage::DownCast(arg1);
42681     } catch (std::out_of_range& e) {
42682       {
42683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42684       };
42685     } catch (std::exception& e) {
42686       {
42687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42688       };
42689     } catch (...) {
42690       {
42691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42692       };
42693     }
42694   }
42695   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42696   return jresult;
42697 }
42698
42699
42700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42701   int jresult ;
42702   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42703   Dali::LoadingState result;
42704
42705   arg1 = (Dali::ResourceImage *)jarg1;
42706   {
42707     try {
42708       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42709     } catch (std::out_of_range& e) {
42710       {
42711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42712       };
42713     } catch (std::exception& e) {
42714       {
42715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42716       };
42717     } catch (...) {
42718       {
42719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42720       };
42721     }
42722   }
42723   jresult = (int)result;
42724   return jresult;
42725 }
42726
42727
42728 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42729   char * jresult ;
42730   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42731   std::string result;
42732
42733   arg1 = (Dali::ResourceImage *)jarg1;
42734   {
42735     try {
42736       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42737     } catch (std::out_of_range& e) {
42738       {
42739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42740       };
42741     } catch (std::exception& e) {
42742       {
42743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42744       };
42745     } catch (...) {
42746       {
42747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42748       };
42749     }
42750   }
42751   jresult = SWIG_csharp_string_callback((&result)->c_str());
42752   return jresult;
42753 }
42754
42755
42756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42757   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42758
42759   arg1 = (Dali::ResourceImage *)jarg1;
42760   {
42761     try {
42762       (arg1)->Reload();
42763     } catch (std::out_of_range& e) {
42764       {
42765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42766       };
42767     } catch (std::exception& e) {
42768       {
42769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42770       };
42771     } catch (...) {
42772       {
42773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42774       };
42775     }
42776   }
42777 }
42778
42779
42780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
42781   void * jresult ;
42782   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42783   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
42784
42785   arg1 = (Dali::ResourceImage *)jarg1;
42786   {
42787     try {
42788       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
42789     } catch (std::out_of_range& e) {
42790       {
42791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42792       };
42793     } catch (std::exception& e) {
42794       {
42795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42796       };
42797     } catch (...) {
42798       {
42799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42800       };
42801     }
42802   }
42803   jresult = (void *)result;
42804   return jresult;
42805 }
42806
42807
42808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
42809   void * jresult ;
42810   Dali::FrameBufferImage *result = 0 ;
42811
42812   {
42813     try {
42814       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
42815     } catch (std::out_of_range& e) {
42816       {
42817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42818       };
42819     } catch (std::exception& e) {
42820       {
42821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42822       };
42823     } catch (...) {
42824       {
42825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42826       };
42827     }
42828   }
42829   jresult = (void *)result;
42830   return jresult;
42831 }
42832
42833
42834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
42835   void * jresult ;
42836   unsigned int arg1 ;
42837   unsigned int arg2 ;
42838   Dali::Pixel::Format arg3 ;
42839   Dali::RenderBuffer::Format arg4 ;
42840   Dali::FrameBufferImage result;
42841
42842   arg1 = (unsigned int)jarg1;
42843   arg2 = (unsigned int)jarg2;
42844   arg3 = (Dali::Pixel::Format)jarg3;
42845   arg4 = (Dali::RenderBuffer::Format)jarg4;
42846   {
42847     try {
42848       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
42849     } catch (std::out_of_range& e) {
42850       {
42851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42852       };
42853     } catch (std::exception& e) {
42854       {
42855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42856       };
42857     } catch (...) {
42858       {
42859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42860       };
42861     }
42862   }
42863   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42864   return jresult;
42865 }
42866
42867
42868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
42869   void * jresult ;
42870   unsigned int arg1 ;
42871   unsigned int arg2 ;
42872   Dali::Pixel::Format arg3 ;
42873   Dali::FrameBufferImage result;
42874
42875   arg1 = (unsigned int)jarg1;
42876   arg2 = (unsigned int)jarg2;
42877   arg3 = (Dali::Pixel::Format)jarg3;
42878   {
42879     try {
42880       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
42881     } catch (std::out_of_range& e) {
42882       {
42883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42884       };
42885     } catch (std::exception& e) {
42886       {
42887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42888       };
42889     } catch (...) {
42890       {
42891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42892       };
42893     }
42894   }
42895   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42896   return jresult;
42897 }
42898
42899
42900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
42901   void * jresult ;
42902   unsigned int arg1 ;
42903   unsigned int arg2 ;
42904   Dali::FrameBufferImage result;
42905
42906   arg1 = (unsigned int)jarg1;
42907   arg2 = (unsigned int)jarg2;
42908   {
42909     try {
42910       result = Dali::FrameBufferImage::New(arg1,arg2);
42911     } catch (std::out_of_range& e) {
42912       {
42913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42914       };
42915     } catch (std::exception& e) {
42916       {
42917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42918       };
42919     } catch (...) {
42920       {
42921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42922       };
42923     }
42924   }
42925   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42926   return jresult;
42927 }
42928
42929
42930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
42931   void * jresult ;
42932   unsigned int arg1 ;
42933   Dali::FrameBufferImage result;
42934
42935   arg1 = (unsigned int)jarg1;
42936   {
42937     try {
42938       result = Dali::FrameBufferImage::New(arg1);
42939     } catch (std::out_of_range& e) {
42940       {
42941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42942       };
42943     } catch (std::exception& e) {
42944       {
42945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42946       };
42947     } catch (...) {
42948       {
42949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42950       };
42951     }
42952   }
42953   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42954   return jresult;
42955 }
42956
42957
42958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
42959   void * jresult ;
42960   Dali::FrameBufferImage result;
42961
42962   {
42963     try {
42964       result = Dali::FrameBufferImage::New();
42965     } catch (std::out_of_range& e) {
42966       {
42967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42968       };
42969     } catch (std::exception& e) {
42970       {
42971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42972       };
42973     } catch (...) {
42974       {
42975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42976       };
42977     }
42978   }
42979   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42980   return jresult;
42981 }
42982
42983
42984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
42985   void * jresult ;
42986   Dali::NativeImageInterface *arg1 = 0 ;
42987   Dali::FrameBufferImage result;
42988
42989   arg1 = (Dali::NativeImageInterface *)jarg1;
42990   if (!arg1) {
42991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
42992     return 0;
42993   }
42994   {
42995     try {
42996       result = Dali::FrameBufferImage::New(*arg1);
42997     } catch (std::out_of_range& e) {
42998       {
42999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43000       };
43001     } catch (std::exception& e) {
43002       {
43003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43004       };
43005     } catch (...) {
43006       {
43007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43008       };
43009     }
43010   }
43011   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43012   return jresult;
43013 }
43014
43015
43016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43017   void * jresult ;
43018   Dali::BaseHandle arg1 ;
43019   Dali::BaseHandle *argp1 ;
43020   Dali::FrameBufferImage result;
43021
43022   argp1 = (Dali::BaseHandle *)jarg1;
43023   if (!argp1) {
43024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43025     return 0;
43026   }
43027   arg1 = *argp1;
43028   {
43029     try {
43030       result = Dali::FrameBufferImage::DownCast(arg1);
43031     } catch (std::out_of_range& e) {
43032       {
43033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43034       };
43035     } catch (std::exception& e) {
43036       {
43037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43038       };
43039     } catch (...) {
43040       {
43041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43042       };
43043     }
43044   }
43045   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43046   return jresult;
43047 }
43048
43049
43050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43051   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43052
43053   arg1 = (Dali::FrameBufferImage *)jarg1;
43054   {
43055     try {
43056       delete arg1;
43057     } catch (std::out_of_range& e) {
43058       {
43059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43060       };
43061     } catch (std::exception& e) {
43062       {
43063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43064       };
43065     } catch (...) {
43066       {
43067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43068       };
43069     }
43070   }
43071 }
43072
43073
43074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43075   void * jresult ;
43076   Dali::FrameBufferImage *arg1 = 0 ;
43077   Dali::FrameBufferImage *result = 0 ;
43078
43079   arg1 = (Dali::FrameBufferImage *)jarg1;
43080   if (!arg1) {
43081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43082     return 0;
43083   }
43084   {
43085     try {
43086       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43087     } catch (std::out_of_range& e) {
43088       {
43089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43090       };
43091     } catch (std::exception& e) {
43092       {
43093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43094       };
43095     } catch (...) {
43096       {
43097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43098       };
43099     }
43100   }
43101   jresult = (void *)result;
43102   return jresult;
43103 }
43104
43105
43106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43107   void * jresult ;
43108   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43109   Dali::FrameBufferImage *arg2 = 0 ;
43110   Dali::FrameBufferImage *result = 0 ;
43111
43112   arg1 = (Dali::FrameBufferImage *)jarg1;
43113   arg2 = (Dali::FrameBufferImage *)jarg2;
43114   if (!arg2) {
43115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43116     return 0;
43117   }
43118   {
43119     try {
43120       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43121     } catch (std::out_of_range& e) {
43122       {
43123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43124       };
43125     } catch (std::exception& e) {
43126       {
43127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43128       };
43129     } catch (...) {
43130       {
43131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43132       };
43133     }
43134   }
43135   jresult = (void *)result;
43136   return jresult;
43137 }
43138
43139
43140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43141   void * jresult ;
43142   Dali::NinePatchImage *result = 0 ;
43143
43144   {
43145     try {
43146       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43147     } catch (std::out_of_range& e) {
43148       {
43149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43150       };
43151     } catch (std::exception& e) {
43152       {
43153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43154       };
43155     } catch (...) {
43156       {
43157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43158       };
43159     }
43160   }
43161   jresult = (void *)result;
43162   return jresult;
43163 }
43164
43165
43166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43167   void * jresult ;
43168   std::string *arg1 = 0 ;
43169   Dali::NinePatchImage result;
43170
43171   if (!jarg1) {
43172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43173     return 0;
43174   }
43175   std::string arg1_str(jarg1);
43176   arg1 = &arg1_str;
43177   {
43178     try {
43179       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43180     } catch (std::out_of_range& e) {
43181       {
43182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43183       };
43184     } catch (std::exception& e) {
43185       {
43186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43187       };
43188     } catch (...) {
43189       {
43190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43191       };
43192     }
43193   }
43194   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43195
43196   //argout typemap for const std::string&
43197
43198   return jresult;
43199 }
43200
43201
43202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43203   void * jresult ;
43204   Dali::BaseHandle arg1 ;
43205   Dali::BaseHandle *argp1 ;
43206   Dali::NinePatchImage result;
43207
43208   argp1 = (Dali::BaseHandle *)jarg1;
43209   if (!argp1) {
43210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43211     return 0;
43212   }
43213   arg1 = *argp1;
43214   {
43215     try {
43216       result = Dali::NinePatchImage::DownCast(arg1);
43217     } catch (std::out_of_range& e) {
43218       {
43219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43220       };
43221     } catch (std::exception& e) {
43222       {
43223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43224       };
43225     } catch (...) {
43226       {
43227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43228       };
43229     }
43230   }
43231   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43232   return jresult;
43233 }
43234
43235
43236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43237   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43238
43239   arg1 = (Dali::NinePatchImage *)jarg1;
43240   {
43241     try {
43242       delete arg1;
43243     } catch (std::out_of_range& e) {
43244       {
43245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43246       };
43247     } catch (std::exception& e) {
43248       {
43249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43250       };
43251     } catch (...) {
43252       {
43253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43254       };
43255     }
43256   }
43257 }
43258
43259
43260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43261   void * jresult ;
43262   Dali::NinePatchImage *arg1 = 0 ;
43263   Dali::NinePatchImage *result = 0 ;
43264
43265   arg1 = (Dali::NinePatchImage *)jarg1;
43266   if (!arg1) {
43267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43268     return 0;
43269   }
43270   {
43271     try {
43272       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43273     } catch (std::out_of_range& e) {
43274       {
43275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43276       };
43277     } catch (std::exception& e) {
43278       {
43279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43280       };
43281     } catch (...) {
43282       {
43283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43284       };
43285     }
43286   }
43287   jresult = (void *)result;
43288   return jresult;
43289 }
43290
43291
43292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43293   void * jresult ;
43294   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43295   Dali::NinePatchImage *arg2 = 0 ;
43296   Dali::NinePatchImage *result = 0 ;
43297
43298   arg1 = (Dali::NinePatchImage *)jarg1;
43299   arg2 = (Dali::NinePatchImage *)jarg2;
43300   if (!arg2) {
43301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43302     return 0;
43303   }
43304   {
43305     try {
43306       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43307     } catch (std::out_of_range& e) {
43308       {
43309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43310       };
43311     } catch (std::exception& e) {
43312       {
43313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43314       };
43315     } catch (...) {
43316       {
43317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43318       };
43319     }
43320   }
43321   jresult = (void *)result;
43322   return jresult;
43323 }
43324
43325
43326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43327   void * jresult ;
43328   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43329   Dali::Vector4 result;
43330
43331   arg1 = (Dali::NinePatchImage *)jarg1;
43332   {
43333     try {
43334       result = (arg1)->GetStretchBorders();
43335     } catch (std::out_of_range& e) {
43336       {
43337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43338       };
43339     } catch (std::exception& e) {
43340       {
43341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43342       };
43343     } catch (...) {
43344       {
43345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43346       };
43347     }
43348   }
43349   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43350   return jresult;
43351 }
43352
43353
43354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43355   void * jresult ;
43356   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43357   Dali::NinePatchImage::StretchRanges *result = 0 ;
43358
43359   arg1 = (Dali::NinePatchImage *)jarg1;
43360   {
43361     try {
43362       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43363     } catch (std::out_of_range& e) {
43364       {
43365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43366       };
43367     } catch (std::exception& e) {
43368       {
43369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43370       };
43371     } catch (...) {
43372       {
43373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43374       };
43375     }
43376   }
43377   jresult = (void *)result;
43378   return jresult;
43379 }
43380
43381
43382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43383   void * jresult ;
43384   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43385   Dali::NinePatchImage::StretchRanges *result = 0 ;
43386
43387   arg1 = (Dali::NinePatchImage *)jarg1;
43388   {
43389     try {
43390       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43391     } catch (std::out_of_range& e) {
43392       {
43393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43394       };
43395     } catch (std::exception& e) {
43396       {
43397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43398       };
43399     } catch (...) {
43400       {
43401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43402       };
43403     }
43404   }
43405   jresult = (void *)result;
43406   return jresult;
43407 }
43408
43409
43410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43411   void * jresult ;
43412   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43413   Dali::Rect< int > result;
43414
43415   arg1 = (Dali::NinePatchImage *)jarg1;
43416   {
43417     try {
43418       result = (arg1)->GetChildRectangle();
43419     } catch (std::out_of_range& e) {
43420       {
43421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43422       };
43423     } catch (std::exception& e) {
43424       {
43425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43426       };
43427     } catch (...) {
43428       {
43429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43430       };
43431     }
43432   }
43433   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43434   return jresult;
43435 }
43436
43437
43438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43439   void * jresult ;
43440   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43441   Dali::BufferImage result;
43442
43443   arg1 = (Dali::NinePatchImage *)jarg1;
43444   {
43445     try {
43446       result = (arg1)->CreateCroppedBufferImage();
43447     } catch (std::out_of_range& e) {
43448       {
43449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43450       };
43451     } catch (std::exception& e) {
43452       {
43453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43454       };
43455     } catch (...) {
43456       {
43457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43458       };
43459     }
43460   }
43461   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43462   return jresult;
43463 }
43464
43465
43466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43467   unsigned int jresult ;
43468   std::string *arg1 = 0 ;
43469   bool result;
43470
43471   if (!jarg1) {
43472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43473     return 0;
43474   }
43475   std::string arg1_str(jarg1);
43476   arg1 = &arg1_str;
43477   {
43478     try {
43479       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43480     } catch (std::out_of_range& e) {
43481       {
43482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43483       };
43484     } catch (std::exception& e) {
43485       {
43486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43487       };
43488     } catch (...) {
43489       {
43490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43491       };
43492     }
43493   }
43494   jresult = result;
43495
43496   //argout typemap for const std::string&
43497
43498   return jresult;
43499 }
43500
43501
43502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43503   int jresult ;
43504   int result;
43505
43506   result = (int)Dali::CameraActor::Property::TYPE;
43507   jresult = (int)result;
43508   return jresult;
43509 }
43510
43511
43512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43513   int jresult ;
43514   int result;
43515
43516   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43517   jresult = (int)result;
43518   return jresult;
43519 }
43520
43521
43522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43523   int jresult ;
43524   int result;
43525
43526   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43527   jresult = (int)result;
43528   return jresult;
43529 }
43530
43531
43532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43533   int jresult ;
43534   int result;
43535
43536   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43537   jresult = (int)result;
43538   return jresult;
43539 }
43540
43541
43542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43543   int jresult ;
43544   int result;
43545
43546   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43547   jresult = (int)result;
43548   return jresult;
43549 }
43550
43551
43552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43553   int jresult ;
43554   int result;
43555
43556   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43557   jresult = (int)result;
43558   return jresult;
43559 }
43560
43561
43562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43563   int jresult ;
43564   int result;
43565
43566   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43567   jresult = (int)result;
43568   return jresult;
43569 }
43570
43571
43572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43573   int jresult ;
43574   int result;
43575
43576   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43577   jresult = (int)result;
43578   return jresult;
43579 }
43580
43581
43582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43583   int jresult ;
43584   int result;
43585
43586   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43587   jresult = (int)result;
43588   return jresult;
43589 }
43590
43591
43592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43593   int jresult ;
43594   int result;
43595
43596   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43597   jresult = (int)result;
43598   return jresult;
43599 }
43600
43601
43602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43603   int jresult ;
43604   int result;
43605
43606   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43607   jresult = (int)result;
43608   return jresult;
43609 }
43610
43611
43612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43613   int jresult ;
43614   int result;
43615
43616   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43617   jresult = (int)result;
43618   return jresult;
43619 }
43620
43621
43622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43623   int jresult ;
43624   int result;
43625
43626   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43627   jresult = (int)result;
43628   return jresult;
43629 }
43630
43631
43632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43633   int jresult ;
43634   int result;
43635
43636   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43637   jresult = (int)result;
43638   return jresult;
43639 }
43640
43641
43642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43643   void * jresult ;
43644   Dali::CameraActor::Property *result = 0 ;
43645
43646   {
43647     try {
43648       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43649     } catch (std::out_of_range& e) {
43650       {
43651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43652       };
43653     } catch (std::exception& e) {
43654       {
43655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43656       };
43657     } catch (...) {
43658       {
43659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43660       };
43661     }
43662   }
43663   jresult = (void *)result;
43664   return jresult;
43665 }
43666
43667
43668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43669   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43670
43671   arg1 = (Dali::CameraActor::Property *)jarg1;
43672   {
43673     try {
43674       delete arg1;
43675     } catch (std::out_of_range& e) {
43676       {
43677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43678       };
43679     } catch (std::exception& e) {
43680       {
43681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43682       };
43683     } catch (...) {
43684       {
43685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43686       };
43687     }
43688   }
43689 }
43690
43691
43692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43693   void * jresult ;
43694   Dali::CameraActor *result = 0 ;
43695
43696   {
43697     try {
43698       result = (Dali::CameraActor *)new Dali::CameraActor();
43699     } catch (std::out_of_range& e) {
43700       {
43701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43702       };
43703     } catch (std::exception& e) {
43704       {
43705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43706       };
43707     } catch (...) {
43708       {
43709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43710       };
43711     }
43712   }
43713   jresult = (void *)result;
43714   return jresult;
43715 }
43716
43717
43718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43719   void * jresult ;
43720   Dali::CameraActor result;
43721
43722   {
43723     try {
43724       result = Dali::CameraActor::New();
43725     } catch (std::out_of_range& e) {
43726       {
43727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43728       };
43729     } catch (std::exception& e) {
43730       {
43731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43732       };
43733     } catch (...) {
43734       {
43735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43736       };
43737     }
43738   }
43739   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43740   return jresult;
43741 }
43742
43743
43744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43745   void * jresult ;
43746   Dali::Size *arg1 = 0 ;
43747   Dali::CameraActor result;
43748
43749   arg1 = (Dali::Size *)jarg1;
43750   if (!arg1) {
43751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43752     return 0;
43753   }
43754   {
43755     try {
43756       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43757     } catch (std::out_of_range& e) {
43758       {
43759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43760       };
43761     } catch (std::exception& e) {
43762       {
43763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43764       };
43765     } catch (...) {
43766       {
43767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43768       };
43769     }
43770   }
43771   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43772   return jresult;
43773 }
43774
43775
43776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
43777   void * jresult ;
43778   Dali::BaseHandle arg1 ;
43779   Dali::BaseHandle *argp1 ;
43780   Dali::CameraActor result;
43781
43782   argp1 = (Dali::BaseHandle *)jarg1;
43783   if (!argp1) {
43784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43785     return 0;
43786   }
43787   arg1 = *argp1;
43788   {
43789     try {
43790       result = Dali::CameraActor::DownCast(arg1);
43791     } catch (std::out_of_range& e) {
43792       {
43793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43794       };
43795     } catch (std::exception& e) {
43796       {
43797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43798       };
43799     } catch (...) {
43800       {
43801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43802       };
43803     }
43804   }
43805   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43806   return jresult;
43807 }
43808
43809
43810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
43811   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43812
43813   arg1 = (Dali::CameraActor *)jarg1;
43814   {
43815     try {
43816       delete arg1;
43817     } catch (std::out_of_range& e) {
43818       {
43819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43820       };
43821     } catch (std::exception& e) {
43822       {
43823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43824       };
43825     } catch (...) {
43826       {
43827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43828       };
43829     }
43830   }
43831 }
43832
43833
43834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
43835   void * jresult ;
43836   Dali::CameraActor *arg1 = 0 ;
43837   Dali::CameraActor *result = 0 ;
43838
43839   arg1 = (Dali::CameraActor *)jarg1;
43840   if (!arg1) {
43841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43842     return 0;
43843   }
43844   {
43845     try {
43846       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
43847     } catch (std::out_of_range& e) {
43848       {
43849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43850       };
43851     } catch (std::exception& e) {
43852       {
43853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43854       };
43855     } catch (...) {
43856       {
43857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43858       };
43859     }
43860   }
43861   jresult = (void *)result;
43862   return jresult;
43863 }
43864
43865
43866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
43867   void * jresult ;
43868   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43869   Dali::CameraActor *arg2 = 0 ;
43870   Dali::CameraActor *result = 0 ;
43871
43872   arg1 = (Dali::CameraActor *)jarg1;
43873   arg2 = (Dali::CameraActor *)jarg2;
43874   if (!arg2) {
43875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43876     return 0;
43877   }
43878   {
43879     try {
43880       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
43881     } catch (std::out_of_range& e) {
43882       {
43883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43884       };
43885     } catch (std::exception& e) {
43886       {
43887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43888       };
43889     } catch (...) {
43890       {
43891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43892       };
43893     }
43894   }
43895   jresult = (void *)result;
43896   return jresult;
43897 }
43898
43899
43900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
43901   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43902   Dali::Camera::Type arg2 ;
43903
43904   arg1 = (Dali::CameraActor *)jarg1;
43905   arg2 = (Dali::Camera::Type)jarg2;
43906   {
43907     try {
43908       (arg1)->SetType(arg2);
43909     } catch (std::out_of_range& e) {
43910       {
43911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43912       };
43913     } catch (std::exception& e) {
43914       {
43915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43916       };
43917     } catch (...) {
43918       {
43919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43920       };
43921     }
43922   }
43923 }
43924
43925
43926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
43927   int jresult ;
43928   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43929   Dali::Camera::Type result;
43930
43931   arg1 = (Dali::CameraActor *)jarg1;
43932   {
43933     try {
43934       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
43935     } catch (std::out_of_range& e) {
43936       {
43937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43938       };
43939     } catch (std::exception& e) {
43940       {
43941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43942       };
43943     } catch (...) {
43944       {
43945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43946       };
43947     }
43948   }
43949   jresult = (int)result;
43950   return jresult;
43951 }
43952
43953
43954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
43955   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43956   Dali::Camera::ProjectionMode arg2 ;
43957
43958   arg1 = (Dali::CameraActor *)jarg1;
43959   arg2 = (Dali::Camera::ProjectionMode)jarg2;
43960   {
43961     try {
43962       (arg1)->SetProjectionMode(arg2);
43963     } catch (std::out_of_range& e) {
43964       {
43965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43966       };
43967     } catch (std::exception& e) {
43968       {
43969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43970       };
43971     } catch (...) {
43972       {
43973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43974       };
43975     }
43976   }
43977 }
43978
43979
43980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
43981   int jresult ;
43982   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43983   Dali::Camera::ProjectionMode result;
43984
43985   arg1 = (Dali::CameraActor *)jarg1;
43986   {
43987     try {
43988       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
43989     } catch (std::out_of_range& e) {
43990       {
43991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43992       };
43993     } catch (std::exception& e) {
43994       {
43995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43996       };
43997     } catch (...) {
43998       {
43999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44000       };
44001     }
44002   }
44003   jresult = (int)result;
44004   return jresult;
44005 }
44006
44007
44008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44009   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44010   float arg2 ;
44011
44012   arg1 = (Dali::CameraActor *)jarg1;
44013   arg2 = (float)jarg2;
44014   {
44015     try {
44016       (arg1)->SetFieldOfView(arg2);
44017     } catch (std::out_of_range& e) {
44018       {
44019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44020       };
44021     } catch (std::exception& e) {
44022       {
44023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44024       };
44025     } catch (...) {
44026       {
44027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44028       };
44029     }
44030   }
44031 }
44032
44033
44034 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44035   float jresult ;
44036   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44037   float result;
44038
44039   arg1 = (Dali::CameraActor *)jarg1;
44040   {
44041     try {
44042       result = (float)(arg1)->GetFieldOfView();
44043     } catch (std::out_of_range& e) {
44044       {
44045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44046       };
44047     } catch (std::exception& e) {
44048       {
44049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44050       };
44051     } catch (...) {
44052       {
44053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44054       };
44055     }
44056   }
44057   jresult = result;
44058   return jresult;
44059 }
44060
44061
44062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44063   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44064   float arg2 ;
44065
44066   arg1 = (Dali::CameraActor *)jarg1;
44067   arg2 = (float)jarg2;
44068   {
44069     try {
44070       (arg1)->SetAspectRatio(arg2);
44071     } catch (std::out_of_range& e) {
44072       {
44073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44074       };
44075     } catch (std::exception& e) {
44076       {
44077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44078       };
44079     } catch (...) {
44080       {
44081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44082       };
44083     }
44084   }
44085 }
44086
44087
44088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44089   float jresult ;
44090   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44091   float result;
44092
44093   arg1 = (Dali::CameraActor *)jarg1;
44094   {
44095     try {
44096       result = (float)(arg1)->GetAspectRatio();
44097     } catch (std::out_of_range& e) {
44098       {
44099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44100       };
44101     } catch (std::exception& e) {
44102       {
44103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44104       };
44105     } catch (...) {
44106       {
44107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44108       };
44109     }
44110   }
44111   jresult = result;
44112   return jresult;
44113 }
44114
44115
44116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44117   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44118   float arg2 ;
44119
44120   arg1 = (Dali::CameraActor *)jarg1;
44121   arg2 = (float)jarg2;
44122   {
44123     try {
44124       (arg1)->SetNearClippingPlane(arg2);
44125     } catch (std::out_of_range& e) {
44126       {
44127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44128       };
44129     } catch (std::exception& e) {
44130       {
44131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44132       };
44133     } catch (...) {
44134       {
44135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44136       };
44137     }
44138   }
44139 }
44140
44141
44142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44143   float jresult ;
44144   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44145   float result;
44146
44147   arg1 = (Dali::CameraActor *)jarg1;
44148   {
44149     try {
44150       result = (float)(arg1)->GetNearClippingPlane();
44151     } catch (std::out_of_range& e) {
44152       {
44153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44154       };
44155     } catch (std::exception& e) {
44156       {
44157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44158       };
44159     } catch (...) {
44160       {
44161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44162       };
44163     }
44164   }
44165   jresult = result;
44166   return jresult;
44167 }
44168
44169
44170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44171   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44172   float arg2 ;
44173
44174   arg1 = (Dali::CameraActor *)jarg1;
44175   arg2 = (float)jarg2;
44176   {
44177     try {
44178       (arg1)->SetFarClippingPlane(arg2);
44179     } catch (std::out_of_range& e) {
44180       {
44181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44182       };
44183     } catch (std::exception& e) {
44184       {
44185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44186       };
44187     } catch (...) {
44188       {
44189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44190       };
44191     }
44192   }
44193 }
44194
44195
44196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44197   float jresult ;
44198   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44199   float result;
44200
44201   arg1 = (Dali::CameraActor *)jarg1;
44202   {
44203     try {
44204       result = (float)(arg1)->GetFarClippingPlane();
44205     } catch (std::out_of_range& e) {
44206       {
44207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44208       };
44209     } catch (std::exception& e) {
44210       {
44211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44212       };
44213     } catch (...) {
44214       {
44215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44216       };
44217     }
44218   }
44219   jresult = result;
44220   return jresult;
44221 }
44222
44223
44224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44225   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44226   Dali::Vector3 *arg2 = 0 ;
44227
44228   arg1 = (Dali::CameraActor *)jarg1;
44229   arg2 = (Dali::Vector3 *)jarg2;
44230   if (!arg2) {
44231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44232     return ;
44233   }
44234   {
44235     try {
44236       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44237     } catch (std::out_of_range& e) {
44238       {
44239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44240       };
44241     } catch (std::exception& e) {
44242       {
44243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44244       };
44245     } catch (...) {
44246       {
44247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44248       };
44249     }
44250   }
44251 }
44252
44253
44254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44255   void * jresult ;
44256   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44257   Dali::Vector3 result;
44258
44259   arg1 = (Dali::CameraActor *)jarg1;
44260   {
44261     try {
44262       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44263     } catch (std::out_of_range& e) {
44264       {
44265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44266       };
44267     } catch (std::exception& e) {
44268       {
44269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44270       };
44271     } catch (...) {
44272       {
44273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44274       };
44275     }
44276   }
44277   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44278   return jresult;
44279 }
44280
44281
44282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44283   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44284   bool arg2 ;
44285
44286   arg1 = (Dali::CameraActor *)jarg1;
44287   arg2 = jarg2 ? true : false;
44288   {
44289     try {
44290       (arg1)->SetInvertYAxis(arg2);
44291     } catch (std::out_of_range& e) {
44292       {
44293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44294       };
44295     } catch (std::exception& e) {
44296       {
44297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44298       };
44299     } catch (...) {
44300       {
44301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44302       };
44303     }
44304   }
44305 }
44306
44307
44308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44309   unsigned int jresult ;
44310   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44311   bool result;
44312
44313   arg1 = (Dali::CameraActor *)jarg1;
44314   {
44315     try {
44316       result = (bool)(arg1)->GetInvertYAxis();
44317     } catch (std::out_of_range& e) {
44318       {
44319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44320       };
44321     } catch (std::exception& e) {
44322       {
44323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44324       };
44325     } catch (...) {
44326       {
44327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44328       };
44329     }
44330   }
44331   jresult = result;
44332   return jresult;
44333 }
44334
44335
44336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44337   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44338   Dali::Size *arg2 = 0 ;
44339
44340   arg1 = (Dali::CameraActor *)jarg1;
44341   arg2 = (Dali::Size *)jarg2;
44342   if (!arg2) {
44343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44344     return ;
44345   }
44346   {
44347     try {
44348       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44349     } catch (std::out_of_range& e) {
44350       {
44351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44352       };
44353     } catch (std::exception& e) {
44354       {
44355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44356       };
44357     } catch (...) {
44358       {
44359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44360       };
44361     }
44362   }
44363 }
44364
44365
44366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44367   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44368   Dali::Size *arg2 = 0 ;
44369
44370   arg1 = (Dali::CameraActor *)jarg1;
44371   arg2 = (Dali::Size *)jarg2;
44372   if (!arg2) {
44373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44374     return ;
44375   }
44376   {
44377     try {
44378       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44379     } catch (std::out_of_range& e) {
44380       {
44381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44382       };
44383     } catch (std::exception& e) {
44384       {
44385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44386       };
44387     } catch (...) {
44388       {
44389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44390       };
44391     }
44392   }
44393 }
44394
44395
44396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44397   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44398   float arg2 ;
44399   float arg3 ;
44400   float arg4 ;
44401   float arg5 ;
44402   float arg6 ;
44403   float arg7 ;
44404
44405   arg1 = (Dali::CameraActor *)jarg1;
44406   arg2 = (float)jarg2;
44407   arg3 = (float)jarg3;
44408   arg4 = (float)jarg4;
44409   arg5 = (float)jarg5;
44410   arg6 = (float)jarg6;
44411   arg7 = (float)jarg7;
44412   {
44413     try {
44414       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44415     } catch (std::out_of_range& e) {
44416       {
44417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44418       };
44419     } catch (std::exception& e) {
44420       {
44421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44422       };
44423     } catch (...) {
44424       {
44425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44426       };
44427     }
44428   }
44429 }
44430
44431
44432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44433   void * jresult ;
44434   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44435
44436   {
44437     try {
44438       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44439     } catch (std::out_of_range& e) {
44440       {
44441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44442       };
44443     } catch (std::exception& e) {
44444       {
44445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44446       };
44447     } catch (...) {
44448       {
44449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44450       };
44451     }
44452   }
44453   jresult = (void *)result;
44454   return jresult;
44455 }
44456
44457
44458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44459   void * jresult ;
44460   std::string arg1 ;
44461   Dali::Property::Value arg2 ;
44462   Dali::Property::Value *argp2 ;
44463   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44464
44465   if (!jarg1) {
44466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44467     return 0;
44468   }
44469   (&arg1)->assign(jarg1);
44470   argp2 = (Dali::Property::Value *)jarg2;
44471   if (!argp2) {
44472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44473     return 0;
44474   }
44475   arg2 = *argp2;
44476   {
44477     try {
44478       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44479     } catch (std::out_of_range& e) {
44480       {
44481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44482       };
44483     } catch (std::exception& e) {
44484       {
44485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44486       };
44487     } catch (...) {
44488       {
44489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44490       };
44491     }
44492   }
44493   jresult = (void *)result;
44494   return jresult;
44495 }
44496
44497
44498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44499   void * jresult ;
44500   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44501   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44502
44503   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44504   if (!arg1) {
44505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44506     return 0;
44507   }
44508   {
44509     try {
44510       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);
44511     } catch (std::out_of_range& e) {
44512       {
44513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44514       };
44515     } catch (std::exception& e) {
44516       {
44517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44518       };
44519     } catch (...) {
44520       {
44521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44522       };
44523     }
44524   }
44525   jresult = (void *)result;
44526   return jresult;
44527 }
44528
44529
44530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44531   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44532   std::string *arg2 = 0 ;
44533
44534   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44535   if (!jarg2) {
44536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44537     return ;
44538   }
44539   std::string arg2_str(jarg2);
44540   arg2 = &arg2_str;
44541   if (arg1) (arg1)->first = *arg2;
44542
44543   //argout typemap for const std::string&
44544
44545 }
44546
44547
44548 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44549   char * jresult ;
44550   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44551   std::string *result = 0 ;
44552
44553   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44554   result = (std::string *) & ((arg1)->first);
44555   jresult = SWIG_csharp_string_callback(result->c_str());
44556   return jresult;
44557 }
44558
44559
44560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44561   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44562   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44563
44564   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44565   arg2 = (Dali::Property::Value *)jarg2;
44566   if (arg1) (arg1)->second = *arg2;
44567 }
44568
44569
44570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44571   void * jresult ;
44572   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44573   Dali::Property::Value *result = 0 ;
44574
44575   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44576   result = (Dali::Property::Value *)& ((arg1)->second);
44577   jresult = (void *)result;
44578   return jresult;
44579 }
44580
44581
44582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44583   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44584
44585   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44586   {
44587     try {
44588       delete arg1;
44589     } catch (std::out_of_range& e) {
44590       {
44591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44592       };
44593     } catch (std::exception& e) {
44594       {
44595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44596       };
44597     } catch (...) {
44598       {
44599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44600       };
44601     }
44602   }
44603 }
44604
44605
44606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44607   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44608
44609   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44610   {
44611     try {
44612       (arg1)->clear();
44613     } catch (std::out_of_range& e) {
44614       {
44615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44616       };
44617     } catch (std::exception& e) {
44618       {
44619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44620       };
44621     } catch (...) {
44622       {
44623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44624       };
44625     }
44626   }
44627 }
44628
44629
44630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44631   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44632   Dali::TouchPoint *arg2 = 0 ;
44633
44634   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44635   arg2 = (Dali::TouchPoint *)jarg2;
44636   if (!arg2) {
44637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44638     return ;
44639   }
44640   {
44641     try {
44642       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44643     } catch (std::out_of_range& e) {
44644       {
44645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44646       };
44647     } catch (std::exception& e) {
44648       {
44649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44650       };
44651     } catch (...) {
44652       {
44653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44654       };
44655     }
44656   }
44657 }
44658
44659
44660 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44661   unsigned long jresult ;
44662   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44663   std::vector< Dali::TouchPoint >::size_type result;
44664
44665   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44666   {
44667     try {
44668       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44669     } catch (std::out_of_range& e) {
44670       {
44671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44672       };
44673     } catch (std::exception& e) {
44674       {
44675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44676       };
44677     } catch (...) {
44678       {
44679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44680       };
44681     }
44682   }
44683   jresult = (unsigned long)result;
44684   return jresult;
44685 }
44686
44687
44688 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44689   unsigned long jresult ;
44690   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44691   std::vector< Dali::TouchPoint >::size_type result;
44692
44693   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44694   {
44695     try {
44696       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44697     } catch (std::out_of_range& e) {
44698       {
44699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44700       };
44701     } catch (std::exception& e) {
44702       {
44703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44704       };
44705     } catch (...) {
44706       {
44707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44708       };
44709     }
44710   }
44711   jresult = (unsigned long)result;
44712   return jresult;
44713 }
44714
44715
44716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44717   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44718   std::vector< Dali::TouchPoint >::size_type arg2 ;
44719
44720   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44721   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44722   {
44723     try {
44724       (arg1)->reserve(arg2);
44725     } catch (std::out_of_range& e) {
44726       {
44727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44728       };
44729     } catch (std::exception& e) {
44730       {
44731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44732       };
44733     } catch (...) {
44734       {
44735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44736       };
44737     }
44738   }
44739 }
44740
44741
44742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44743   void * jresult ;
44744   std::vector< Dali::TouchPoint > *result = 0 ;
44745
44746   {
44747     try {
44748       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44749     } catch (std::out_of_range& e) {
44750       {
44751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44752       };
44753     } catch (std::exception& e) {
44754       {
44755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44756       };
44757     } catch (...) {
44758       {
44759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44760       };
44761     }
44762   }
44763   jresult = (void *)result;
44764   return jresult;
44765 }
44766
44767
44768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
44769   void * jresult ;
44770   std::vector< Dali::TouchPoint > *arg1 = 0 ;
44771   std::vector< Dali::TouchPoint > *result = 0 ;
44772
44773   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44774   if (!arg1) {
44775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44776     return 0;
44777   }
44778   {
44779     try {
44780       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
44781     } catch (std::out_of_range& e) {
44782       {
44783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44784       };
44785     } catch (std::exception& e) {
44786       {
44787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44788       };
44789     } catch (...) {
44790       {
44791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44792       };
44793     }
44794   }
44795   jresult = (void *)result;
44796   return jresult;
44797 }
44798
44799
44800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
44801   void * jresult ;
44802   int arg1 ;
44803   std::vector< Dali::TouchPoint > *result = 0 ;
44804
44805   arg1 = (int)jarg1;
44806   {
44807     try {
44808       try {
44809         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
44810       }
44811       catch(std::out_of_range &_e) {
44812         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44813         return 0;
44814       }
44815
44816     } catch (std::out_of_range& e) {
44817       {
44818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44819       };
44820     } catch (std::exception& e) {
44821       {
44822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44823       };
44824     } catch (...) {
44825       {
44826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44827       };
44828     }
44829   }
44830   jresult = (void *)result;
44831   return jresult;
44832 }
44833
44834
44835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
44836   void * jresult ;
44837   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44838   int arg2 ;
44839   SwigValueWrapper< Dali::TouchPoint > result;
44840
44841   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44842   arg2 = (int)jarg2;
44843   {
44844     try {
44845       try {
44846         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
44847       }
44848       catch(std::out_of_range &_e) {
44849         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44850         return 0;
44851       }
44852
44853     } catch (std::out_of_range& e) {
44854       {
44855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44856       };
44857     } catch (std::exception& e) {
44858       {
44859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44860       };
44861     } catch (...) {
44862       {
44863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44864       };
44865     }
44866   }
44867   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
44868   return jresult;
44869 }
44870
44871
44872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
44873   void * jresult ;
44874   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44875   int arg2 ;
44876   Dali::TouchPoint *result = 0 ;
44877
44878   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44879   arg2 = (int)jarg2;
44880   {
44881     try {
44882       try {
44883         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
44884       }
44885       catch(std::out_of_range &_e) {
44886         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44887         return 0;
44888       }
44889
44890     } catch (std::out_of_range& e) {
44891       {
44892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44893       };
44894     } catch (std::exception& e) {
44895       {
44896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44897       };
44898     } catch (...) {
44899       {
44900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44901       };
44902     }
44903   }
44904   jresult = (void *)result;
44905   return jresult;
44906 }
44907
44908
44909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
44910   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44911   int arg2 ;
44912   Dali::TouchPoint *arg3 = 0 ;
44913
44914   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44915   arg2 = (int)jarg2;
44916   arg3 = (Dali::TouchPoint *)jarg3;
44917   if (!arg3) {
44918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44919     return ;
44920   }
44921   {
44922     try {
44923       try {
44924         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
44925       }
44926       catch(std::out_of_range &_e) {
44927         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44928         return ;
44929       }
44930
44931     } catch (std::out_of_range& e) {
44932       {
44933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44934       };
44935     } catch (std::exception& e) {
44936       {
44937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44938       };
44939     } catch (...) {
44940       {
44941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44942       };
44943     }
44944   }
44945 }
44946
44947
44948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
44949   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44950   std::vector< Dali::TouchPoint > *arg2 = 0 ;
44951
44952   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44953   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
44954   if (!arg2) {
44955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44956     return ;
44957   }
44958   {
44959     try {
44960       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
44961     } catch (std::out_of_range& e) {
44962       {
44963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44964       };
44965     } catch (std::exception& e) {
44966       {
44967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44968       };
44969     } catch (...) {
44970       {
44971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44972       };
44973     }
44974   }
44975 }
44976
44977
44978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
44979   void * jresult ;
44980   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44981   int arg2 ;
44982   int arg3 ;
44983   std::vector< Dali::TouchPoint > *result = 0 ;
44984
44985   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44986   arg2 = (int)jarg2;
44987   arg3 = (int)jarg3;
44988   {
44989     try {
44990       try {
44991         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
44992       }
44993       catch(std::out_of_range &_e) {
44994         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44995         return 0;
44996       }
44997       catch(std::invalid_argument &_e) {
44998         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
44999         return 0;
45000       }
45001
45002     } catch (std::out_of_range& e) {
45003       {
45004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45005       };
45006     } catch (std::exception& e) {
45007       {
45008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45009       };
45010     } catch (...) {
45011       {
45012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45013       };
45014     }
45015   }
45016   jresult = (void *)result;
45017   return jresult;
45018 }
45019
45020
45021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45022   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45023   int arg2 ;
45024   Dali::TouchPoint *arg3 = 0 ;
45025
45026   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45027   arg2 = (int)jarg2;
45028   arg3 = (Dali::TouchPoint *)jarg3;
45029   if (!arg3) {
45030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45031     return ;
45032   }
45033   {
45034     try {
45035       try {
45036         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45037       }
45038       catch(std::out_of_range &_e) {
45039         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45040         return ;
45041       }
45042
45043     } catch (std::out_of_range& e) {
45044       {
45045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45046       };
45047     } catch (std::exception& e) {
45048       {
45049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45050       };
45051     } catch (...) {
45052       {
45053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45054       };
45055     }
45056   }
45057 }
45058
45059
45060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45061   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45062   int arg2 ;
45063   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45064
45065   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45066   arg2 = (int)jarg2;
45067   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45068   if (!arg3) {
45069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45070     return ;
45071   }
45072   {
45073     try {
45074       try {
45075         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45076       }
45077       catch(std::out_of_range &_e) {
45078         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45079         return ;
45080       }
45081
45082     } catch (std::out_of_range& e) {
45083       {
45084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45085       };
45086     } catch (std::exception& e) {
45087       {
45088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45089       };
45090     } catch (...) {
45091       {
45092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45093       };
45094     }
45095   }
45096 }
45097
45098
45099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45100   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45101   int arg2 ;
45102
45103   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45104   arg2 = (int)jarg2;
45105   {
45106     try {
45107       try {
45108         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45109       }
45110       catch(std::out_of_range &_e) {
45111         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45112         return ;
45113       }
45114
45115     } catch (std::out_of_range& e) {
45116       {
45117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45118       };
45119     } catch (std::exception& e) {
45120       {
45121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45122       };
45123     } catch (...) {
45124       {
45125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45126       };
45127     }
45128   }
45129 }
45130
45131
45132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45133   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45134   int arg2 ;
45135   int arg3 ;
45136
45137   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45138   arg2 = (int)jarg2;
45139   arg3 = (int)jarg3;
45140   {
45141     try {
45142       try {
45143         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45144       }
45145       catch(std::out_of_range &_e) {
45146         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45147         return ;
45148       }
45149       catch(std::invalid_argument &_e) {
45150         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45151         return ;
45152       }
45153
45154     } catch (std::out_of_range& e) {
45155       {
45156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45157       };
45158     } catch (std::exception& e) {
45159       {
45160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45161       };
45162     } catch (...) {
45163       {
45164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45165       };
45166     }
45167   }
45168 }
45169
45170
45171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45172   void * jresult ;
45173   Dali::TouchPoint *arg1 = 0 ;
45174   int arg2 ;
45175   std::vector< Dali::TouchPoint > *result = 0 ;
45176
45177   arg1 = (Dali::TouchPoint *)jarg1;
45178   if (!arg1) {
45179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45180     return 0;
45181   }
45182   arg2 = (int)jarg2;
45183   {
45184     try {
45185       try {
45186         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45187       }
45188       catch(std::out_of_range &_e) {
45189         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45190         return 0;
45191       }
45192
45193     } catch (std::out_of_range& e) {
45194       {
45195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45196       };
45197     } catch (std::exception& e) {
45198       {
45199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45200       };
45201     } catch (...) {
45202       {
45203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45204       };
45205     }
45206   }
45207   jresult = (void *)result;
45208   return jresult;
45209 }
45210
45211
45212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45213   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45214
45215   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45216   {
45217     try {
45218       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45219     } catch (std::out_of_range& e) {
45220       {
45221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45222       };
45223     } catch (std::exception& e) {
45224       {
45225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45226       };
45227     } catch (...) {
45228       {
45229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45230       };
45231     }
45232   }
45233 }
45234
45235
45236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45237   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45238   int arg2 ;
45239   int arg3 ;
45240
45241   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45242   arg2 = (int)jarg2;
45243   arg3 = (int)jarg3;
45244   {
45245     try {
45246       try {
45247         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45248       }
45249       catch(std::out_of_range &_e) {
45250         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45251         return ;
45252       }
45253       catch(std::invalid_argument &_e) {
45254         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45255         return ;
45256       }
45257
45258     } catch (std::out_of_range& e) {
45259       {
45260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45261       };
45262     } catch (std::exception& e) {
45263       {
45264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45265       };
45266     } catch (...) {
45267       {
45268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45269       };
45270     }
45271   }
45272 }
45273
45274
45275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45276   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45277   int arg2 ;
45278   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45279
45280   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45281   arg2 = (int)jarg2;
45282   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45283   if (!arg3) {
45284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45285     return ;
45286   }
45287   {
45288     try {
45289       try {
45290         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45291       }
45292       catch(std::out_of_range &_e) {
45293         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45294         return ;
45295       }
45296
45297     } catch (std::out_of_range& e) {
45298       {
45299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45300       };
45301     } catch (std::exception& e) {
45302       {
45303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45304       };
45305     } catch (...) {
45306       {
45307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45308       };
45309     }
45310   }
45311 }
45312
45313
45314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45315   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45316
45317   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45318   {
45319     try {
45320       delete arg1;
45321     } catch (std::out_of_range& e) {
45322       {
45323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45324       };
45325     } catch (std::exception& e) {
45326       {
45327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45328       };
45329     } catch (...) {
45330       {
45331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45332       };
45333     }
45334   }
45335 }
45336
45337
45338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45339   void * jresult ;
45340   Dali::Rect< int > *result = 0 ;
45341
45342   {
45343     try {
45344       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45345     } catch (std::out_of_range& e) {
45346       {
45347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45348       };
45349     } catch (std::exception& e) {
45350       {
45351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45352       };
45353     } catch (...) {
45354       {
45355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45356       };
45357     }
45358   }
45359   jresult = (void *)result;
45360   return jresult;
45361 }
45362
45363
45364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45365   void * jresult ;
45366   int arg1 ;
45367   int arg2 ;
45368   int arg3 ;
45369   int arg4 ;
45370   Dali::Rect< int > *result = 0 ;
45371
45372   arg1 = (int)jarg1;
45373   arg2 = (int)jarg2;
45374   arg3 = (int)jarg3;
45375   arg4 = (int)jarg4;
45376   {
45377     try {
45378       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45379     } catch (std::out_of_range& e) {
45380       {
45381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45382       };
45383     } catch (std::exception& e) {
45384       {
45385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45386       };
45387     } catch (...) {
45388       {
45389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45390       };
45391     }
45392   }
45393   jresult = (void *)result;
45394   return jresult;
45395 }
45396
45397
45398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45399   void * jresult ;
45400   Dali::Rect< int > *arg1 = 0 ;
45401   Dali::Rect< int > *result = 0 ;
45402
45403   arg1 = (Dali::Rect< int > *)jarg1;
45404   if (!arg1) {
45405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45406     return 0;
45407   }
45408   {
45409     try {
45410       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45411     } catch (std::out_of_range& e) {
45412       {
45413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45414       };
45415     } catch (std::exception& e) {
45416       {
45417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45418       };
45419     } catch (...) {
45420       {
45421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45422       };
45423     }
45424   }
45425   jresult = (void *)result;
45426   return jresult;
45427 }
45428
45429
45430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45431   void * jresult ;
45432   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45433   Dali::Rect< int > *arg2 = 0 ;
45434   Dali::Rect< int > *result = 0 ;
45435
45436   arg1 = (Dali::Rect< int > *)jarg1;
45437   arg2 = (Dali::Rect< int > *)jarg2;
45438   if (!arg2) {
45439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45440     return 0;
45441   }
45442   {
45443     try {
45444       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45445     } catch (std::out_of_range& e) {
45446       {
45447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45448       };
45449     } catch (std::exception& e) {
45450       {
45451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45452       };
45453     } catch (...) {
45454       {
45455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45456       };
45457     }
45458   }
45459   jresult = (void *)result;
45460   return jresult;
45461 }
45462
45463
45464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45465   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45466   int arg2 ;
45467   int arg3 ;
45468   int arg4 ;
45469   int arg5 ;
45470
45471   arg1 = (Dali::Rect< int > *)jarg1;
45472   arg2 = (int)jarg2;
45473   arg3 = (int)jarg3;
45474   arg4 = (int)jarg4;
45475   arg5 = (int)jarg5;
45476   {
45477     try {
45478       (arg1)->Set(arg2,arg3,arg4,arg5);
45479     } catch (std::out_of_range& e) {
45480       {
45481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45482       };
45483     } catch (std::exception& e) {
45484       {
45485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45486       };
45487     } catch (...) {
45488       {
45489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45490       };
45491     }
45492   }
45493 }
45494
45495
45496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45497   unsigned int jresult ;
45498   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45499   bool result;
45500
45501   arg1 = (Dali::Rect< int > *)jarg1;
45502   {
45503     try {
45504       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45505     } catch (std::out_of_range& e) {
45506       {
45507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45508       };
45509     } catch (std::exception& e) {
45510       {
45511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45512       };
45513     } catch (...) {
45514       {
45515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45516       };
45517     }
45518   }
45519   jresult = result;
45520   return jresult;
45521 }
45522
45523
45524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45525   int jresult ;
45526   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45527   int result;
45528
45529   arg1 = (Dali::Rect< int > *)jarg1;
45530   {
45531     try {
45532       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45533     } catch (std::out_of_range& e) {
45534       {
45535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45536       };
45537     } catch (std::exception& e) {
45538       {
45539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45540       };
45541     } catch (...) {
45542       {
45543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45544       };
45545     }
45546   }
45547   jresult = result;
45548   return jresult;
45549 }
45550
45551
45552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45553   int jresult ;
45554   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45555   int result;
45556
45557   arg1 = (Dali::Rect< int > *)jarg1;
45558   {
45559     try {
45560       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45561     } catch (std::out_of_range& e) {
45562       {
45563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45564       };
45565     } catch (std::exception& e) {
45566       {
45567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45568       };
45569     } catch (...) {
45570       {
45571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45572       };
45573     }
45574   }
45575   jresult = result;
45576   return jresult;
45577 }
45578
45579
45580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45581   int jresult ;
45582   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45583   int result;
45584
45585   arg1 = (Dali::Rect< int > *)jarg1;
45586   {
45587     try {
45588       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45589     } catch (std::out_of_range& e) {
45590       {
45591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45592       };
45593     } catch (std::exception& e) {
45594       {
45595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45596       };
45597     } catch (...) {
45598       {
45599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45600       };
45601     }
45602   }
45603   jresult = result;
45604   return jresult;
45605 }
45606
45607
45608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45609   int jresult ;
45610   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45611   int result;
45612
45613   arg1 = (Dali::Rect< int > *)jarg1;
45614   {
45615     try {
45616       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45617     } catch (std::out_of_range& e) {
45618       {
45619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45620       };
45621     } catch (std::exception& e) {
45622       {
45623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45624       };
45625     } catch (...) {
45626       {
45627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45628       };
45629     }
45630   }
45631   jresult = result;
45632   return jresult;
45633 }
45634
45635
45636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45637   int jresult ;
45638   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45639   int result;
45640
45641   arg1 = (Dali::Rect< int > *)jarg1;
45642   {
45643     try {
45644       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45645     } catch (std::out_of_range& e) {
45646       {
45647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45648       };
45649     } catch (std::exception& e) {
45650       {
45651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45652       };
45653     } catch (...) {
45654       {
45655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45656       };
45657     }
45658   }
45659   jresult = result;
45660   return jresult;
45661 }
45662
45663
45664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45665   unsigned int jresult ;
45666   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45667   Dali::Rect< int > *arg2 = 0 ;
45668   bool result;
45669
45670   arg1 = (Dali::Rect< int > *)jarg1;
45671   arg2 = (Dali::Rect< int > *)jarg2;
45672   if (!arg2) {
45673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45674     return 0;
45675   }
45676   {
45677     try {
45678       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45679     } catch (std::out_of_range& e) {
45680       {
45681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45682       };
45683     } catch (std::exception& e) {
45684       {
45685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45686       };
45687     } catch (...) {
45688       {
45689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45690       };
45691     }
45692   }
45693   jresult = result;
45694   return jresult;
45695 }
45696
45697
45698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45699   unsigned int jresult ;
45700   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45701   Dali::Rect< int > *arg2 = 0 ;
45702   bool result;
45703
45704   arg1 = (Dali::Rect< int > *)jarg1;
45705   arg2 = (Dali::Rect< int > *)jarg2;
45706   if (!arg2) {
45707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45708     return 0;
45709   }
45710   {
45711     try {
45712       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45713     } catch (std::out_of_range& e) {
45714       {
45715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45716       };
45717     } catch (std::exception& e) {
45718       {
45719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45720       };
45721     } catch (...) {
45722       {
45723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45724       };
45725     }
45726   }
45727   jresult = result;
45728   return jresult;
45729 }
45730
45731
45732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45733   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45734   int arg2 ;
45735
45736   arg1 = (Dali::Rect< int > *)jarg1;
45737   arg2 = (int)jarg2;
45738   if (arg1) (arg1)->x = arg2;
45739 }
45740
45741
45742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45743   int jresult ;
45744   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45745   int result;
45746
45747   arg1 = (Dali::Rect< int > *)jarg1;
45748   result = (int) ((arg1)->x);
45749   jresult = result;
45750   return jresult;
45751 }
45752
45753
45754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45755   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45756   int arg2 ;
45757
45758   arg1 = (Dali::Rect< int > *)jarg1;
45759   arg2 = (int)jarg2;
45760   if (arg1) (arg1)->left = arg2;
45761 }
45762
45763
45764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
45765   int jresult ;
45766   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45767   int result;
45768
45769   arg1 = (Dali::Rect< int > *)jarg1;
45770   result = (int) ((arg1)->left);
45771   jresult = result;
45772   return jresult;
45773 }
45774
45775
45776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
45777   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45778   int arg2 ;
45779
45780   arg1 = (Dali::Rect< int > *)jarg1;
45781   arg2 = (int)jarg2;
45782   if (arg1) (arg1)->y = arg2;
45783 }
45784
45785
45786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
45787   int jresult ;
45788   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45789   int result;
45790
45791   arg1 = (Dali::Rect< int > *)jarg1;
45792   result = (int) ((arg1)->y);
45793   jresult = result;
45794   return jresult;
45795 }
45796
45797
45798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
45799   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45800   int arg2 ;
45801
45802   arg1 = (Dali::Rect< int > *)jarg1;
45803   arg2 = (int)jarg2;
45804   if (arg1) (arg1)->right = arg2;
45805 }
45806
45807
45808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
45809   int jresult ;
45810   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45811   int result;
45812
45813   arg1 = (Dali::Rect< int > *)jarg1;
45814   result = (int) ((arg1)->right);
45815   jresult = result;
45816   return jresult;
45817 }
45818
45819
45820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
45821   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45822   int arg2 ;
45823
45824   arg1 = (Dali::Rect< int > *)jarg1;
45825   arg2 = (int)jarg2;
45826   if (arg1) (arg1)->width = arg2;
45827 }
45828
45829
45830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
45831   int jresult ;
45832   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45833   int result;
45834
45835   arg1 = (Dali::Rect< int > *)jarg1;
45836   result = (int) ((arg1)->width);
45837   jresult = result;
45838   return jresult;
45839 }
45840
45841
45842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
45843   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45844   int arg2 ;
45845
45846   arg1 = (Dali::Rect< int > *)jarg1;
45847   arg2 = (int)jarg2;
45848   if (arg1) (arg1)->bottom = arg2;
45849 }
45850
45851
45852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
45853   int jresult ;
45854   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45855   int result;
45856
45857   arg1 = (Dali::Rect< int > *)jarg1;
45858   result = (int) ((arg1)->bottom);
45859   jresult = result;
45860   return jresult;
45861 }
45862
45863
45864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
45865   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45866   int arg2 ;
45867
45868   arg1 = (Dali::Rect< int > *)jarg1;
45869   arg2 = (int)jarg2;
45870   if (arg1) (arg1)->height = arg2;
45871 }
45872
45873
45874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
45875   int jresult ;
45876   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45877   int result;
45878
45879   arg1 = (Dali::Rect< int > *)jarg1;
45880   result = (int) ((arg1)->height);
45881   jresult = result;
45882   return jresult;
45883 }
45884
45885
45886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
45887   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45888   int arg2 ;
45889
45890   arg1 = (Dali::Rect< int > *)jarg1;
45891   arg2 = (int)jarg2;
45892   if (arg1) (arg1)->top = arg2;
45893 }
45894
45895
45896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
45897   int jresult ;
45898   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45899   int result;
45900
45901   arg1 = (Dali::Rect< int > *)jarg1;
45902   result = (int) ((arg1)->top);
45903   jresult = result;
45904   return jresult;
45905 }
45906
45907
45908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
45909   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45910
45911   arg1 = (Dali::Rect< int > *)jarg1;
45912   {
45913     try {
45914       delete arg1;
45915     } catch (std::out_of_range& e) {
45916       {
45917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45918       };
45919     } catch (std::exception& e) {
45920       {
45921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45922       };
45923     } catch (...) {
45924       {
45925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45926       };
45927     }
45928   }
45929 }
45930
45931
45932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
45933   void * jresult ;
45934   Dali::Rect< float > *result = 0 ;
45935
45936   {
45937     try {
45938       result = (Dali::Rect< float > *)new Dali::Rect< float >();
45939     } catch (std::out_of_range& e) {
45940       {
45941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45942       };
45943     } catch (std::exception& e) {
45944       {
45945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45946       };
45947     } catch (...) {
45948       {
45949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45950       };
45951     }
45952   }
45953   jresult = (void *)result;
45954   return jresult;
45955 }
45956
45957
45958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
45959   void * jresult ;
45960   float arg1 ;
45961   float arg2 ;
45962   float arg3 ;
45963   float arg4 ;
45964   Dali::Rect< float > *result = 0 ;
45965
45966   arg1 = (float)jarg1;
45967   arg2 = (float)jarg2;
45968   arg3 = (float)jarg3;
45969   arg4 = (float)jarg4;
45970   {
45971     try {
45972       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
45973     } catch (std::out_of_range& e) {
45974       {
45975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45976       };
45977     } catch (std::exception& e) {
45978       {
45979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45980       };
45981     } catch (...) {
45982       {
45983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45984       };
45985     }
45986   }
45987   jresult = (void *)result;
45988   return jresult;
45989 }
45990
45991
45992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
45993   void * jresult ;
45994   Dali::Rect< float > *arg1 = 0 ;
45995   Dali::Rect< float > *result = 0 ;
45996
45997   arg1 = (Dali::Rect< float > *)jarg1;
45998   if (!arg1) {
45999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46000     return 0;
46001   }
46002   {
46003     try {
46004       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46005     } catch (std::out_of_range& e) {
46006       {
46007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46008       };
46009     } catch (std::exception& e) {
46010       {
46011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46012       };
46013     } catch (...) {
46014       {
46015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46016       };
46017     }
46018   }
46019   jresult = (void *)result;
46020   return jresult;
46021 }
46022
46023
46024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46025   void * jresult ;
46026   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46027   Dali::Rect< float > *arg2 = 0 ;
46028   Dali::Rect< float > *result = 0 ;
46029
46030   arg1 = (Dali::Rect< float > *)jarg1;
46031   arg2 = (Dali::Rect< float > *)jarg2;
46032   if (!arg2) {
46033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46034     return 0;
46035   }
46036   {
46037     try {
46038       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46039     } catch (std::out_of_range& e) {
46040       {
46041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46042       };
46043     } catch (std::exception& e) {
46044       {
46045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46046       };
46047     } catch (...) {
46048       {
46049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46050       };
46051     }
46052   }
46053   jresult = (void *)result;
46054   return jresult;
46055 }
46056
46057
46058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46059   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46060   float arg2 ;
46061   float arg3 ;
46062   float arg4 ;
46063   float arg5 ;
46064
46065   arg1 = (Dali::Rect< float > *)jarg1;
46066   arg2 = (float)jarg2;
46067   arg3 = (float)jarg3;
46068   arg4 = (float)jarg4;
46069   arg5 = (float)jarg5;
46070   {
46071     try {
46072       (arg1)->Set(arg2,arg3,arg4,arg5);
46073     } catch (std::out_of_range& e) {
46074       {
46075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46076       };
46077     } catch (std::exception& e) {
46078       {
46079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46080       };
46081     } catch (...) {
46082       {
46083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46084       };
46085     }
46086   }
46087 }
46088
46089
46090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46091   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46092   float arg2 ;
46093
46094   arg1 = (Dali::Rect< float > *)jarg1;
46095   arg2 = (float)jarg2;
46096   if (arg1) (arg1)->x = arg2;
46097 }
46098
46099
46100 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46101   float jresult ;
46102   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46103   float result;
46104
46105   arg1 = (Dali::Rect< float > *)jarg1;
46106   result = (float) ((arg1)->x);
46107   jresult = result;
46108   return jresult;
46109 }
46110
46111
46112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46113   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46114   float arg2 ;
46115
46116   arg1 = (Dali::Rect< float > *)jarg1;
46117   arg2 = (float)jarg2;
46118   if (arg1) (arg1)->left = arg2;
46119 }
46120
46121
46122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46123   float jresult ;
46124   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46125   float result;
46126
46127   arg1 = (Dali::Rect< float > *)jarg1;
46128   result = (float) ((arg1)->left);
46129   jresult = result;
46130   return jresult;
46131 }
46132
46133
46134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46135   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46136   float arg2 ;
46137
46138   arg1 = (Dali::Rect< float > *)jarg1;
46139   arg2 = (float)jarg2;
46140   if (arg1) (arg1)->y = arg2;
46141 }
46142
46143
46144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46145   float jresult ;
46146   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46147   float result;
46148
46149   arg1 = (Dali::Rect< float > *)jarg1;
46150   result = (float) ((arg1)->y);
46151   jresult = result;
46152   return jresult;
46153 }
46154
46155
46156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46157   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46158   float arg2 ;
46159
46160   arg1 = (Dali::Rect< float > *)jarg1;
46161   arg2 = (float)jarg2;
46162   if (arg1) (arg1)->right = arg2;
46163 }
46164
46165
46166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46167   float jresult ;
46168   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46169   float result;
46170
46171   arg1 = (Dali::Rect< float > *)jarg1;
46172   result = (float) ((arg1)->right);
46173   jresult = result;
46174   return jresult;
46175 }
46176
46177
46178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46179   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46180   float arg2 ;
46181
46182   arg1 = (Dali::Rect< float > *)jarg1;
46183   arg2 = (float)jarg2;
46184   if (arg1) (arg1)->width = arg2;
46185 }
46186
46187
46188 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46189   float jresult ;
46190   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46191   float result;
46192
46193   arg1 = (Dali::Rect< float > *)jarg1;
46194   result = (float) ((arg1)->width);
46195   jresult = result;
46196   return jresult;
46197 }
46198
46199
46200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46201   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46202   float arg2 ;
46203
46204   arg1 = (Dali::Rect< float > *)jarg1;
46205   arg2 = (float)jarg2;
46206   if (arg1) (arg1)->bottom = arg2;
46207 }
46208
46209
46210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46211   float jresult ;
46212   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46213   float result;
46214
46215   arg1 = (Dali::Rect< float > *)jarg1;
46216   result = (float) ((arg1)->bottom);
46217   jresult = result;
46218   return jresult;
46219 }
46220
46221
46222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46223   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46224   float arg2 ;
46225
46226   arg1 = (Dali::Rect< float > *)jarg1;
46227   arg2 = (float)jarg2;
46228   if (arg1) (arg1)->height = arg2;
46229 }
46230
46231
46232 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46233   float jresult ;
46234   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46235   float result;
46236
46237   arg1 = (Dali::Rect< float > *)jarg1;
46238   result = (float) ((arg1)->height);
46239   jresult = result;
46240   return jresult;
46241 }
46242
46243
46244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46245   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46246   float arg2 ;
46247
46248   arg1 = (Dali::Rect< float > *)jarg1;
46249   arg2 = (float)jarg2;
46250   if (arg1) (arg1)->top = arg2;
46251 }
46252
46253
46254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46255   float jresult ;
46256   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46257   float result;
46258
46259   arg1 = (Dali::Rect< float > *)jarg1;
46260   result = (float) ((arg1)->top);
46261   jresult = result;
46262   return jresult;
46263 }
46264
46265
46266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46267   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46268
46269   arg1 = (Dali::Rect< float > *)jarg1;
46270   {
46271     try {
46272       delete arg1;
46273     } catch (std::out_of_range& e) {
46274       {
46275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46276       };
46277     } catch (std::exception& e) {
46278       {
46279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46280       };
46281     } catch (...) {
46282       {
46283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46284       };
46285     }
46286   }
46287 }
46288
46289
46290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46291   int jresult ;
46292   int result;
46293
46294   result = (int)Dali::Vector< int >::BaseType;
46295   jresult = (int)result;
46296   return jresult;
46297 }
46298
46299
46300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46301   void * jresult ;
46302   Dali::Vector< int > *result = 0 ;
46303
46304   {
46305     try {
46306       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46307     } catch (std::out_of_range& e) {
46308       {
46309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46310       };
46311     } catch (std::exception& e) {
46312       {
46313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46314       };
46315     } catch (...) {
46316       {
46317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46318       };
46319     }
46320   }
46321   jresult = (void *)result;
46322   return jresult;
46323 }
46324
46325
46326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46327   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46328
46329   arg1 = (Dali::Vector< int > *)jarg1;
46330   {
46331     try {
46332       delete arg1;
46333     } catch (std::out_of_range& e) {
46334       {
46335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46336       };
46337     } catch (std::exception& e) {
46338       {
46339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46340       };
46341     } catch (...) {
46342       {
46343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46344       };
46345     }
46346   }
46347 }
46348
46349
46350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46351   void * jresult ;
46352   Dali::Vector< int > *arg1 = 0 ;
46353   Dali::Vector< int > *result = 0 ;
46354
46355   arg1 = (Dali::Vector< int > *)jarg1;
46356   if (!arg1) {
46357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46358     return 0;
46359   }
46360   {
46361     try {
46362       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46363     } catch (std::out_of_range& e) {
46364       {
46365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46366       };
46367     } catch (std::exception& e) {
46368       {
46369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46370       };
46371     } catch (...) {
46372       {
46373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46374       };
46375     }
46376   }
46377   jresult = (void *)result;
46378   return jresult;
46379 }
46380
46381
46382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46383   void * jresult ;
46384   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46385   Dali::Vector< int > *arg2 = 0 ;
46386   Dali::Vector< int > *result = 0 ;
46387
46388   arg1 = (Dali::Vector< int > *)jarg1;
46389   arg2 = (Dali::Vector< int > *)jarg2;
46390   if (!arg2) {
46391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46392     return 0;
46393   }
46394   {
46395     try {
46396       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46397     } catch (std::out_of_range& e) {
46398       {
46399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46400       };
46401     } catch (std::exception& e) {
46402       {
46403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46404       };
46405     } catch (...) {
46406       {
46407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46408       };
46409     }
46410   }
46411   jresult = (void *)result;
46412   return jresult;
46413 }
46414
46415
46416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46417   void * jresult ;
46418   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46419   Dali::Vector< int >::Iterator result;
46420
46421   arg1 = (Dali::Vector< int > *)jarg1;
46422   {
46423     try {
46424       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46425     } catch (std::out_of_range& e) {
46426       {
46427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46428       };
46429     } catch (std::exception& e) {
46430       {
46431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46432       };
46433     } catch (...) {
46434       {
46435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46436       };
46437     }
46438   }
46439   jresult = (void *)result;
46440   return jresult;
46441 }
46442
46443
46444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46445   void * jresult ;
46446   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46447   Dali::Vector< int >::Iterator result;
46448
46449   arg1 = (Dali::Vector< int > *)jarg1;
46450   {
46451     try {
46452       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46453     } catch (std::out_of_range& e) {
46454       {
46455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46456       };
46457     } catch (std::exception& e) {
46458       {
46459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46460       };
46461     } catch (...) {
46462       {
46463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46464       };
46465     }
46466   }
46467   jresult = (void *)result;
46468   return jresult;
46469 }
46470
46471
46472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46473   void * jresult ;
46474   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46475   Dali::Vector< int >::SizeType arg2 ;
46476   Dali::Vector< int >::ItemType *result = 0 ;
46477
46478   arg1 = (Dali::Vector< int > *)jarg1;
46479   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46480   {
46481     try {
46482       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46483     } catch (std::out_of_range& e) {
46484       {
46485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46486       };
46487     } catch (std::exception& e) {
46488       {
46489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46490       };
46491     } catch (...) {
46492       {
46493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46494       };
46495     }
46496   }
46497   jresult = (void *)result;
46498   return jresult;
46499 }
46500
46501
46502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46503   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46504   Dali::Vector< int >::ItemType *arg2 = 0 ;
46505   Dali::Vector< int >::ItemType temp2 ;
46506
46507   arg1 = (Dali::Vector< int > *)jarg1;
46508   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46509   arg2 = &temp2;
46510   {
46511     try {
46512       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46513     } catch (std::out_of_range& e) {
46514       {
46515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46516       };
46517     } catch (std::exception& e) {
46518       {
46519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46520       };
46521     } catch (...) {
46522       {
46523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46524       };
46525     }
46526   }
46527 }
46528
46529
46530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46531   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46532   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46533   Dali::Vector< int >::ItemType *arg3 = 0 ;
46534   Dali::Vector< int >::ItemType temp3 ;
46535
46536   arg1 = (Dali::Vector< int > *)jarg1;
46537   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46538   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46539   arg3 = &temp3;
46540   {
46541     try {
46542       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46543     } catch (std::out_of_range& e) {
46544       {
46545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46546       };
46547     } catch (std::exception& e) {
46548       {
46549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46550       };
46551     } catch (...) {
46552       {
46553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46554       };
46555     }
46556   }
46557 }
46558
46559
46560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46561   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46562   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46563   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46564   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46565
46566   arg1 = (Dali::Vector< int > *)jarg1;
46567   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46568   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46569   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46570   {
46571     try {
46572       (arg1)->Insert(arg2,arg3,arg4);
46573     } catch (std::out_of_range& e) {
46574       {
46575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46576       };
46577     } catch (std::exception& e) {
46578       {
46579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46580       };
46581     } catch (...) {
46582       {
46583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46584       };
46585     }
46586   }
46587 }
46588
46589
46590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46591   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46592   Dali::Vector< int >::SizeType arg2 ;
46593
46594   arg1 = (Dali::Vector< int > *)jarg1;
46595   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46596   {
46597     try {
46598       (arg1)->Reserve(arg2);
46599     } catch (std::out_of_range& e) {
46600       {
46601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46602       };
46603     } catch (std::exception& e) {
46604       {
46605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46606       };
46607     } catch (...) {
46608       {
46609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46610       };
46611     }
46612   }
46613 }
46614
46615
46616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46617   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46618   Dali::Vector< int >::SizeType arg2 ;
46619
46620   arg1 = (Dali::Vector< int > *)jarg1;
46621   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46622   {
46623     try {
46624       (arg1)->Resize(arg2);
46625     } catch (std::out_of_range& e) {
46626       {
46627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46628       };
46629     } catch (std::exception& e) {
46630       {
46631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46632       };
46633     } catch (...) {
46634       {
46635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46636       };
46637     }
46638   }
46639 }
46640
46641
46642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46643   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46644   Dali::Vector< int >::SizeType arg2 ;
46645   Dali::Vector< int >::ItemType *arg3 = 0 ;
46646   Dali::Vector< int >::ItemType temp3 ;
46647
46648   arg1 = (Dali::Vector< int > *)jarg1;
46649   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46650   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46651   arg3 = &temp3;
46652   {
46653     try {
46654       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46655     } catch (std::out_of_range& e) {
46656       {
46657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46658       };
46659     } catch (std::exception& e) {
46660       {
46661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46662       };
46663     } catch (...) {
46664       {
46665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46666       };
46667     }
46668   }
46669 }
46670
46671
46672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46673   void * jresult ;
46674   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46675   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46676   Dali::Vector< int >::Iterator result;
46677
46678   arg1 = (Dali::Vector< int > *)jarg1;
46679   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46680   {
46681     try {
46682       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46683     } catch (std::out_of_range& e) {
46684       {
46685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46686       };
46687     } catch (std::exception& e) {
46688       {
46689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46690       };
46691     } catch (...) {
46692       {
46693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46694       };
46695     }
46696   }
46697   jresult = (void *)result;
46698   return jresult;
46699 }
46700
46701
46702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46703   void * jresult ;
46704   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46705   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46706   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46707   Dali::Vector< int >::Iterator result;
46708
46709   arg1 = (Dali::Vector< int > *)jarg1;
46710   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46711   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46712   {
46713     try {
46714       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46715     } catch (std::out_of_range& e) {
46716       {
46717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46718       };
46719     } catch (std::exception& e) {
46720       {
46721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46722       };
46723     } catch (...) {
46724       {
46725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46726       };
46727     }
46728   }
46729   jresult = (void *)result;
46730   return jresult;
46731 }
46732
46733
46734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46735   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46736   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46737
46738   arg1 = (Dali::Vector< int > *)jarg1;
46739   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46740   {
46741     try {
46742       (arg1)->Remove(arg2);
46743     } catch (std::out_of_range& e) {
46744       {
46745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46746       };
46747     } catch (std::exception& e) {
46748       {
46749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46750       };
46751     } catch (...) {
46752       {
46753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46754       };
46755     }
46756   }
46757 }
46758
46759
46760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
46761   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46762   Dali::Vector< int > *arg2 = 0 ;
46763
46764   arg1 = (Dali::Vector< int > *)jarg1;
46765   arg2 = (Dali::Vector< int > *)jarg2;
46766   if (!arg2) {
46767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
46768     return ;
46769   }
46770   {
46771     try {
46772       (arg1)->Swap(*arg2);
46773     } catch (std::out_of_range& e) {
46774       {
46775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46776       };
46777     } catch (std::exception& e) {
46778       {
46779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46780       };
46781     } catch (...) {
46782       {
46783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46784       };
46785     }
46786   }
46787 }
46788
46789
46790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
46791   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46792
46793   arg1 = (Dali::Vector< int > *)jarg1;
46794   {
46795     try {
46796       (arg1)->Clear();
46797     } catch (std::out_of_range& e) {
46798       {
46799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46800       };
46801     } catch (std::exception& e) {
46802       {
46803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46804       };
46805     } catch (...) {
46806       {
46807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46808       };
46809     }
46810   }
46811 }
46812
46813
46814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
46815   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46816
46817   arg1 = (Dali::Vector< int > *)jarg1;
46818   {
46819     try {
46820       (arg1)->Release();
46821     } catch (std::out_of_range& e) {
46822       {
46823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46824       };
46825     } catch (std::exception& e) {
46826       {
46827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46828       };
46829     } catch (...) {
46830       {
46831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46832       };
46833     }
46834   }
46835 }
46836
46837
46838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
46839   int jresult ;
46840   int result;
46841
46842   result = (int)Dali::Vector< float >::BaseType;
46843   jresult = (int)result;
46844   return jresult;
46845 }
46846
46847
46848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
46849   void * jresult ;
46850   Dali::Vector< float > *result = 0 ;
46851
46852   {
46853     try {
46854       result = (Dali::Vector< float > *)new Dali::Vector< float >();
46855     } catch (std::out_of_range& e) {
46856       {
46857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46858       };
46859     } catch (std::exception& e) {
46860       {
46861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46862       };
46863     } catch (...) {
46864       {
46865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46866       };
46867     }
46868   }
46869   jresult = (void *)result;
46870   return jresult;
46871 }
46872
46873
46874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
46875   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46876
46877   arg1 = (Dali::Vector< float > *)jarg1;
46878   {
46879     try {
46880       delete arg1;
46881     } catch (std::out_of_range& e) {
46882       {
46883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46884       };
46885     } catch (std::exception& e) {
46886       {
46887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46888       };
46889     } catch (...) {
46890       {
46891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46892       };
46893     }
46894   }
46895 }
46896
46897
46898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
46899   void * jresult ;
46900   Dali::Vector< float > *arg1 = 0 ;
46901   Dali::Vector< float > *result = 0 ;
46902
46903   arg1 = (Dali::Vector< float > *)jarg1;
46904   if (!arg1) {
46905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
46906     return 0;
46907   }
46908   {
46909     try {
46910       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
46911     } catch (std::out_of_range& e) {
46912       {
46913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46914       };
46915     } catch (std::exception& e) {
46916       {
46917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46918       };
46919     } catch (...) {
46920       {
46921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46922       };
46923     }
46924   }
46925   jresult = (void *)result;
46926   return jresult;
46927 }
46928
46929
46930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
46931   void * jresult ;
46932   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46933   Dali::Vector< float > *arg2 = 0 ;
46934   Dali::Vector< float > *result = 0 ;
46935
46936   arg1 = (Dali::Vector< float > *)jarg1;
46937   arg2 = (Dali::Vector< float > *)jarg2;
46938   if (!arg2) {
46939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
46940     return 0;
46941   }
46942   {
46943     try {
46944       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
46945     } catch (std::out_of_range& e) {
46946       {
46947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46948       };
46949     } catch (std::exception& e) {
46950       {
46951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46952       };
46953     } catch (...) {
46954       {
46955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46956       };
46957     }
46958   }
46959   jresult = (void *)result;
46960   return jresult;
46961 }
46962
46963
46964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
46965   void * jresult ;
46966   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46967   Dali::Vector< float >::Iterator result;
46968
46969   arg1 = (Dali::Vector< float > *)jarg1;
46970   {
46971     try {
46972       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
46973     } catch (std::out_of_range& e) {
46974       {
46975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46976       };
46977     } catch (std::exception& e) {
46978       {
46979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46980       };
46981     } catch (...) {
46982       {
46983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46984       };
46985     }
46986   }
46987   jresult = (void *)result;
46988   return jresult;
46989 }
46990
46991
46992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
46993   void * jresult ;
46994   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46995   Dali::Vector< float >::Iterator result;
46996
46997   arg1 = (Dali::Vector< float > *)jarg1;
46998   {
46999     try {
47000       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47001     } catch (std::out_of_range& e) {
47002       {
47003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47004       };
47005     } catch (std::exception& e) {
47006       {
47007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47008       };
47009     } catch (...) {
47010       {
47011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47012       };
47013     }
47014   }
47015   jresult = (void *)result;
47016   return jresult;
47017 }
47018
47019
47020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47021   void * jresult ;
47022   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47023   Dali::Vector< float >::SizeType arg2 ;
47024   Dali::Vector< float >::ItemType *result = 0 ;
47025
47026   arg1 = (Dali::Vector< float > *)jarg1;
47027   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47028   {
47029     try {
47030       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47031     } catch (std::out_of_range& e) {
47032       {
47033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47034       };
47035     } catch (std::exception& e) {
47036       {
47037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47038       };
47039     } catch (...) {
47040       {
47041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47042       };
47043     }
47044   }
47045   jresult = (void *)result;
47046   return jresult;
47047 }
47048
47049
47050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47051   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47052   Dali::Vector< float >::ItemType *arg2 = 0 ;
47053   Dali::Vector< float >::ItemType temp2 ;
47054
47055   arg1 = (Dali::Vector< float > *)jarg1;
47056   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47057   arg2 = &temp2;
47058   {
47059     try {
47060       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47061     } catch (std::out_of_range& e) {
47062       {
47063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47064       };
47065     } catch (std::exception& e) {
47066       {
47067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47068       };
47069     } catch (...) {
47070       {
47071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47072       };
47073     }
47074   }
47075 }
47076
47077
47078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47079   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47080   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47081   Dali::Vector< float >::ItemType *arg3 = 0 ;
47082   Dali::Vector< float >::ItemType temp3 ;
47083
47084   arg1 = (Dali::Vector< float > *)jarg1;
47085   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47086   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47087   arg3 = &temp3;
47088   {
47089     try {
47090       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47091     } catch (std::out_of_range& e) {
47092       {
47093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47094       };
47095     } catch (std::exception& e) {
47096       {
47097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47098       };
47099     } catch (...) {
47100       {
47101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47102       };
47103     }
47104   }
47105 }
47106
47107
47108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47109   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47110   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47111   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47112   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47113
47114   arg1 = (Dali::Vector< float > *)jarg1;
47115   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47116   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47117   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47118   {
47119     try {
47120       (arg1)->Insert(arg2,arg3,arg4);
47121     } catch (std::out_of_range& e) {
47122       {
47123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47124       };
47125     } catch (std::exception& e) {
47126       {
47127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47128       };
47129     } catch (...) {
47130       {
47131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47132       };
47133     }
47134   }
47135 }
47136
47137
47138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47139   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47140   Dali::Vector< float >::SizeType arg2 ;
47141
47142   arg1 = (Dali::Vector< float > *)jarg1;
47143   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47144   {
47145     try {
47146       (arg1)->Reserve(arg2);
47147     } catch (std::out_of_range& e) {
47148       {
47149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47150       };
47151     } catch (std::exception& e) {
47152       {
47153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47154       };
47155     } catch (...) {
47156       {
47157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47158       };
47159     }
47160   }
47161 }
47162
47163
47164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47165   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47166   Dali::Vector< float >::SizeType arg2 ;
47167
47168   arg1 = (Dali::Vector< float > *)jarg1;
47169   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47170   {
47171     try {
47172       (arg1)->Resize(arg2);
47173     } catch (std::out_of_range& e) {
47174       {
47175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47176       };
47177     } catch (std::exception& e) {
47178       {
47179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47180       };
47181     } catch (...) {
47182       {
47183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47184       };
47185     }
47186   }
47187 }
47188
47189
47190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47191   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47192   Dali::Vector< float >::SizeType arg2 ;
47193   Dali::Vector< float >::ItemType *arg3 = 0 ;
47194   Dali::Vector< float >::ItemType temp3 ;
47195
47196   arg1 = (Dali::Vector< float > *)jarg1;
47197   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47198   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47199   arg3 = &temp3;
47200   {
47201     try {
47202       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47203     } catch (std::out_of_range& e) {
47204       {
47205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47206       };
47207     } catch (std::exception& e) {
47208       {
47209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47210       };
47211     } catch (...) {
47212       {
47213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47214       };
47215     }
47216   }
47217 }
47218
47219
47220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47221   void * jresult ;
47222   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47223   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47224   Dali::Vector< float >::Iterator result;
47225
47226   arg1 = (Dali::Vector< float > *)jarg1;
47227   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47228   {
47229     try {
47230       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47231     } catch (std::out_of_range& e) {
47232       {
47233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47234       };
47235     } catch (std::exception& e) {
47236       {
47237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47238       };
47239     } catch (...) {
47240       {
47241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47242       };
47243     }
47244   }
47245   jresult = (void *)result;
47246   return jresult;
47247 }
47248
47249
47250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47251   void * jresult ;
47252   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47253   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47254   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47255   Dali::Vector< float >::Iterator result;
47256
47257   arg1 = (Dali::Vector< float > *)jarg1;
47258   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47259   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47260   {
47261     try {
47262       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47263     } catch (std::out_of_range& e) {
47264       {
47265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47266       };
47267     } catch (std::exception& e) {
47268       {
47269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47270       };
47271     } catch (...) {
47272       {
47273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47274       };
47275     }
47276   }
47277   jresult = (void *)result;
47278   return jresult;
47279 }
47280
47281
47282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47283   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47284   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47285
47286   arg1 = (Dali::Vector< float > *)jarg1;
47287   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47288   {
47289     try {
47290       (arg1)->Remove(arg2);
47291     } catch (std::out_of_range& e) {
47292       {
47293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47294       };
47295     } catch (std::exception& e) {
47296       {
47297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47298       };
47299     } catch (...) {
47300       {
47301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47302       };
47303     }
47304   }
47305 }
47306
47307
47308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47309   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47310   Dali::Vector< float > *arg2 = 0 ;
47311
47312   arg1 = (Dali::Vector< float > *)jarg1;
47313   arg2 = (Dali::Vector< float > *)jarg2;
47314   if (!arg2) {
47315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47316     return ;
47317   }
47318   {
47319     try {
47320       (arg1)->Swap(*arg2);
47321     } catch (std::out_of_range& e) {
47322       {
47323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47324       };
47325     } catch (std::exception& e) {
47326       {
47327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47328       };
47329     } catch (...) {
47330       {
47331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47332       };
47333     }
47334   }
47335 }
47336
47337
47338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47339   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47340
47341   arg1 = (Dali::Vector< float > *)jarg1;
47342   {
47343     try {
47344       (arg1)->Clear();
47345     } catch (std::out_of_range& e) {
47346       {
47347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47348       };
47349     } catch (std::exception& e) {
47350       {
47351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47352       };
47353     } catch (...) {
47354       {
47355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47356       };
47357     }
47358   }
47359 }
47360
47361
47362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47363   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47364
47365   arg1 = (Dali::Vector< float > *)jarg1;
47366   {
47367     try {
47368       (arg1)->Release();
47369     } catch (std::out_of_range& e) {
47370       {
47371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47372       };
47373     } catch (std::exception& e) {
47374       {
47375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47376       };
47377     } catch (...) {
47378       {
47379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47380       };
47381     }
47382   }
47383 }
47384
47385
47386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47387   int jresult ;
47388   int result;
47389
47390   result = (int)Dali::Vector< unsigned char >::BaseType;
47391   jresult = (int)result;
47392   return jresult;
47393 }
47394
47395
47396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47397   void * jresult ;
47398   Dali::Vector< unsigned char > *result = 0 ;
47399
47400   {
47401     try {
47402       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47403     } catch (std::out_of_range& e) {
47404       {
47405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47406       };
47407     } catch (std::exception& e) {
47408       {
47409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47410       };
47411     } catch (...) {
47412       {
47413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47414       };
47415     }
47416   }
47417   jresult = (void *)result;
47418   return jresult;
47419 }
47420
47421
47422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47423   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47424
47425   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47426   {
47427     try {
47428       delete arg1;
47429     } catch (std::out_of_range& e) {
47430       {
47431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47432       };
47433     } catch (std::exception& e) {
47434       {
47435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47436       };
47437     } catch (...) {
47438       {
47439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47440       };
47441     }
47442   }
47443 }
47444
47445
47446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47447   void * jresult ;
47448   Dali::Vector< unsigned char > *arg1 = 0 ;
47449   Dali::Vector< unsigned char > *result = 0 ;
47450
47451   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47452   if (!arg1) {
47453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47454     return 0;
47455   }
47456   {
47457     try {
47458       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47459     } catch (std::out_of_range& e) {
47460       {
47461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47462       };
47463     } catch (std::exception& e) {
47464       {
47465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47466       };
47467     } catch (...) {
47468       {
47469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47470       };
47471     }
47472   }
47473   jresult = (void *)result;
47474   return jresult;
47475 }
47476
47477
47478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47479   void * jresult ;
47480   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47481   Dali::Vector< unsigned char > *arg2 = 0 ;
47482   Dali::Vector< unsigned char > *result = 0 ;
47483
47484   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47485   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47486   if (!arg2) {
47487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47488     return 0;
47489   }
47490   {
47491     try {
47492       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47493     } catch (std::out_of_range& e) {
47494       {
47495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47496       };
47497     } catch (std::exception& e) {
47498       {
47499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47500       };
47501     } catch (...) {
47502       {
47503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47504       };
47505     }
47506   }
47507   jresult = (void *)result;
47508   return jresult;
47509 }
47510
47511
47512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47513   void * jresult ;
47514   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47515   Dali::Vector< unsigned char >::Iterator result;
47516
47517   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47518   {
47519     try {
47520       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47521     } catch (std::out_of_range& e) {
47522       {
47523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47524       };
47525     } catch (std::exception& e) {
47526       {
47527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47528       };
47529     } catch (...) {
47530       {
47531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47532       };
47533     }
47534   }
47535   jresult = (void *)result;
47536   return jresult;
47537 }
47538
47539
47540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47541   void * jresult ;
47542   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47543   Dali::Vector< unsigned char >::Iterator result;
47544
47545   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47546   {
47547     try {
47548       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47549     } catch (std::out_of_range& e) {
47550       {
47551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47552       };
47553     } catch (std::exception& e) {
47554       {
47555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47556       };
47557     } catch (...) {
47558       {
47559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47560       };
47561     }
47562   }
47563   jresult = (void *)result;
47564   return jresult;
47565 }
47566
47567
47568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47569   void * jresult ;
47570   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47571   Dali::Vector< unsigned char >::SizeType arg2 ;
47572   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47573
47574   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47575   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47576   {
47577     try {
47578       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47579     } catch (std::out_of_range& e) {
47580       {
47581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47582       };
47583     } catch (std::exception& e) {
47584       {
47585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47586       };
47587     } catch (...) {
47588       {
47589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47590       };
47591     }
47592   }
47593   jresult = (void *)result;
47594   return jresult;
47595 }
47596
47597
47598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47599   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47600   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47601   Dali::Vector< unsigned char >::ItemType temp2 ;
47602
47603   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47604   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47605   arg2 = &temp2;
47606   {
47607     try {
47608       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47609     } catch (std::out_of_range& e) {
47610       {
47611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47612       };
47613     } catch (std::exception& e) {
47614       {
47615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47616       };
47617     } catch (...) {
47618       {
47619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47620       };
47621     }
47622   }
47623 }
47624
47625
47626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47627   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47628   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47629   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47630   Dali::Vector< unsigned char >::ItemType temp3 ;
47631
47632   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47633   arg2 = jarg2;
47634   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47635   arg3 = &temp3;
47636   {
47637     try {
47638       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47639     } catch (std::out_of_range& e) {
47640       {
47641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47642       };
47643     } catch (std::exception& e) {
47644       {
47645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47646       };
47647     } catch (...) {
47648       {
47649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47650       };
47651     }
47652   }
47653
47654
47655 }
47656
47657
47658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47659   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47660   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47661   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47662   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47663
47664   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47665   arg2 = jarg2;
47666   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47667   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47668   {
47669     try {
47670       (arg1)->Insert(arg2,arg3,arg4);
47671     } catch (std::out_of_range& e) {
47672       {
47673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47674       };
47675     } catch (std::exception& e) {
47676       {
47677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47678       };
47679     } catch (...) {
47680       {
47681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47682       };
47683     }
47684   }
47685
47686
47687 }
47688
47689
47690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47691   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47692   Dali::Vector< unsigned char >::SizeType arg2 ;
47693
47694   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47695   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47696   {
47697     try {
47698       (arg1)->Reserve(arg2);
47699     } catch (std::out_of_range& e) {
47700       {
47701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47702       };
47703     } catch (std::exception& e) {
47704       {
47705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47706       };
47707     } catch (...) {
47708       {
47709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47710       };
47711     }
47712   }
47713 }
47714
47715
47716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47717   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47718   Dali::Vector< unsigned char >::SizeType arg2 ;
47719
47720   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47721   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47722   {
47723     try {
47724       (arg1)->Resize(arg2);
47725     } catch (std::out_of_range& e) {
47726       {
47727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47728       };
47729     } catch (std::exception& e) {
47730       {
47731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47732       };
47733     } catch (...) {
47734       {
47735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47736       };
47737     }
47738   }
47739 }
47740
47741
47742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47743   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47744   Dali::Vector< unsigned char >::SizeType arg2 ;
47745   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47746   Dali::Vector< unsigned char >::ItemType temp3 ;
47747
47748   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47749   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47750   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47751   arg3 = &temp3;
47752   {
47753     try {
47754       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47755     } catch (std::out_of_range& e) {
47756       {
47757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47758       };
47759     } catch (std::exception& e) {
47760       {
47761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47762       };
47763     } catch (...) {
47764       {
47765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47766       };
47767     }
47768   }
47769 }
47770
47771
47772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
47773   void * jresult ;
47774   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47775   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47776   Dali::Vector< unsigned char >::Iterator result;
47777
47778   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47779   arg2 = jarg2;
47780   {
47781     try {
47782       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
47783     } catch (std::out_of_range& e) {
47784       {
47785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47786       };
47787     } catch (std::exception& e) {
47788       {
47789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47790       };
47791     } catch (...) {
47792       {
47793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47794       };
47795     }
47796   }
47797   jresult = (void *)result;
47798
47799
47800   return jresult;
47801 }
47802
47803
47804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
47805   void * jresult ;
47806   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47807   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47808   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47809   Dali::Vector< unsigned char >::Iterator result;
47810
47811   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47812   arg2 = jarg2;
47813   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47814   {
47815     try {
47816       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
47817     } catch (std::out_of_range& e) {
47818       {
47819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47820       };
47821     } catch (std::exception& e) {
47822       {
47823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47824       };
47825     } catch (...) {
47826       {
47827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47828       };
47829     }
47830   }
47831   jresult = (void *)result;
47832
47833
47834   return jresult;
47835 }
47836
47837
47838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
47839   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47840   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47841
47842   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47843   arg2 = jarg2;
47844   {
47845     try {
47846       (arg1)->Remove(arg2);
47847     } catch (std::out_of_range& e) {
47848       {
47849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47850       };
47851     } catch (std::exception& e) {
47852       {
47853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47854       };
47855     } catch (...) {
47856       {
47857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47858       };
47859     }
47860   }
47861
47862
47863 }
47864
47865
47866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
47867   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47868   Dali::Vector< unsigned char > *arg2 = 0 ;
47869
47870   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47871   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47872   if (!arg2) {
47873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
47874     return ;
47875   }
47876   {
47877     try {
47878       (arg1)->Swap(*arg2);
47879     } catch (std::out_of_range& e) {
47880       {
47881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47882       };
47883     } catch (std::exception& e) {
47884       {
47885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47886       };
47887     } catch (...) {
47888       {
47889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47890       };
47891     }
47892   }
47893 }
47894
47895
47896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
47897   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47898
47899   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47900   {
47901     try {
47902       (arg1)->Clear();
47903     } catch (std::out_of_range& e) {
47904       {
47905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47906       };
47907     } catch (std::exception& e) {
47908       {
47909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47910       };
47911     } catch (...) {
47912       {
47913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47914       };
47915     }
47916   }
47917 }
47918
47919
47920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
47921   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47922
47923   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47924   {
47925     try {
47926       (arg1)->Release();
47927     } catch (std::out_of_range& e) {
47928       {
47929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47930       };
47931     } catch (std::exception& e) {
47932       {
47933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47934       };
47935     } catch (...) {
47936       {
47937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47938       };
47939     }
47940   }
47941 }
47942
47943
47944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
47945   int jresult ;
47946   int result;
47947
47948   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
47949   jresult = (int)result;
47950   return jresult;
47951 }
47952
47953
47954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
47955   void * jresult ;
47956   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
47957
47958   {
47959     try {
47960       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
47961     } catch (std::out_of_range& e) {
47962       {
47963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47964       };
47965     } catch (std::exception& e) {
47966       {
47967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47968       };
47969     } catch (...) {
47970       {
47971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47972       };
47973     }
47974   }
47975   jresult = (void *)result;
47976   return jresult;
47977 }
47978
47979
47980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
47981   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
47982
47983   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
47984   {
47985     try {
47986       delete arg1;
47987     } catch (std::out_of_range& e) {
47988       {
47989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47990       };
47991     } catch (std::exception& e) {
47992       {
47993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47994       };
47995     } catch (...) {
47996       {
47997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47998       };
47999     }
48000   }
48001 }
48002
48003
48004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48005   void * jresult ;
48006   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48007   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48008
48009   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48010   if (!arg1) {
48011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48012     return 0;
48013   }
48014   {
48015     try {
48016       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48017     } catch (std::out_of_range& e) {
48018       {
48019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48020       };
48021     } catch (std::exception& e) {
48022       {
48023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48024       };
48025     } catch (...) {
48026       {
48027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48028       };
48029     }
48030   }
48031   jresult = (void *)result;
48032   return jresult;
48033 }
48034
48035
48036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48037   void * jresult ;
48038   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48039   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48040   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48041
48042   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48043   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48044   if (!arg2) {
48045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48046     return 0;
48047   }
48048   {
48049     try {
48050       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48051     } catch (std::out_of_range& e) {
48052       {
48053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48054       };
48055     } catch (std::exception& e) {
48056       {
48057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48058       };
48059     } catch (...) {
48060       {
48061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48062       };
48063     }
48064   }
48065   jresult = (void *)result;
48066   return jresult;
48067 }
48068
48069
48070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48071   void * jresult ;
48072   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48073   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48074
48075   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48076   {
48077     try {
48078       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48079     } catch (std::out_of_range& e) {
48080       {
48081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48082       };
48083     } catch (std::exception& e) {
48084       {
48085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48086       };
48087     } catch (...) {
48088       {
48089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48090       };
48091     }
48092   }
48093   jresult = (void *)result;
48094   return jresult;
48095 }
48096
48097
48098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48099   void * jresult ;
48100   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48101   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48102
48103   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48104   {
48105     try {
48106       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48107     } catch (std::out_of_range& e) {
48108       {
48109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48110       };
48111     } catch (std::exception& e) {
48112       {
48113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48114       };
48115     } catch (...) {
48116       {
48117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48118       };
48119     }
48120   }
48121   jresult = (void *)result;
48122   return jresult;
48123 }
48124
48125
48126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48127   void * jresult ;
48128   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48129   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48130   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48131
48132   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48133   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48134   {
48135     try {
48136       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48137     } catch (std::out_of_range& e) {
48138       {
48139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48140       };
48141     } catch (std::exception& e) {
48142       {
48143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48144       };
48145     } catch (...) {
48146       {
48147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48148       };
48149     }
48150   }
48151   jresult = (void *)result;
48152   return jresult;
48153 }
48154
48155
48156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48157   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48158   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48159
48160   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48161   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48162   if (!arg2) {
48163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48164     return ;
48165   }
48166   {
48167     try {
48168       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48169     } catch (std::out_of_range& e) {
48170       {
48171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48172       };
48173     } catch (std::exception& e) {
48174       {
48175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48176       };
48177     } catch (...) {
48178       {
48179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48180       };
48181     }
48182   }
48183 }
48184
48185
48186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48187   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48188   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48189   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48190
48191   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48192   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48193   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48194   if (!arg3) {
48195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48196     return ;
48197   }
48198   {
48199     try {
48200       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48201     } catch (std::out_of_range& e) {
48202       {
48203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48204       };
48205     } catch (std::exception& e) {
48206       {
48207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48208       };
48209     } catch (...) {
48210       {
48211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48212       };
48213     }
48214   }
48215 }
48216
48217
48218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48219   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48220   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48221   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48222   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48223
48224   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48225   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48226   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48227   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48228   {
48229     try {
48230       (arg1)->Insert(arg2,arg3,arg4);
48231     } catch (std::out_of_range& e) {
48232       {
48233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48234       };
48235     } catch (std::exception& e) {
48236       {
48237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48238       };
48239     } catch (...) {
48240       {
48241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48242       };
48243     }
48244   }
48245 }
48246
48247
48248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48249   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48250   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48251
48252   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48253   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48254   {
48255     try {
48256       (arg1)->Reserve(arg2);
48257     } catch (std::out_of_range& e) {
48258       {
48259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48260       };
48261     } catch (std::exception& e) {
48262       {
48263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48264       };
48265     } catch (...) {
48266       {
48267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48268       };
48269     }
48270   }
48271 }
48272
48273
48274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48275   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48276   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48277
48278   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48279   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48280   {
48281     try {
48282       (arg1)->Resize(arg2);
48283     } catch (std::out_of_range& e) {
48284       {
48285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48286       };
48287     } catch (std::exception& e) {
48288       {
48289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48290       };
48291     } catch (...) {
48292       {
48293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48294       };
48295     }
48296   }
48297 }
48298
48299
48300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48301   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48302   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48303   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48304
48305   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48306   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48307   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48308   if (!arg3) {
48309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48310     return ;
48311   }
48312   {
48313     try {
48314       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48315     } catch (std::out_of_range& e) {
48316       {
48317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48318       };
48319     } catch (std::exception& e) {
48320       {
48321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48322       };
48323     } catch (...) {
48324       {
48325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48326       };
48327     }
48328   }
48329 }
48330
48331
48332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48333   void * jresult ;
48334   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48335   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48336   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48337
48338   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48339   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48340   {
48341     try {
48342       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48343     } catch (std::out_of_range& e) {
48344       {
48345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48346       };
48347     } catch (std::exception& e) {
48348       {
48349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48350       };
48351     } catch (...) {
48352       {
48353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48354       };
48355     }
48356   }
48357   jresult = (void *)result;
48358   return jresult;
48359 }
48360
48361
48362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48363   void * jresult ;
48364   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48365   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48366   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48367   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48368
48369   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48370   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48371   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48372   {
48373     try {
48374       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48375     } catch (std::out_of_range& e) {
48376       {
48377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48378       };
48379     } catch (std::exception& e) {
48380       {
48381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48382       };
48383     } catch (...) {
48384       {
48385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48386       };
48387     }
48388   }
48389   jresult = (void *)result;
48390   return jresult;
48391 }
48392
48393
48394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48395   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48396   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48397
48398   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48399   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48400   {
48401     try {
48402       (arg1)->Remove(arg2);
48403     } catch (std::out_of_range& e) {
48404       {
48405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48406       };
48407     } catch (std::exception& e) {
48408       {
48409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48410       };
48411     } catch (...) {
48412       {
48413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48414       };
48415     }
48416   }
48417 }
48418
48419
48420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48421   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48422   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48423
48424   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48425   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48426   if (!arg2) {
48427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48428     return ;
48429   }
48430   {
48431     try {
48432       (arg1)->Swap(*arg2);
48433     } catch (std::out_of_range& e) {
48434       {
48435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48436       };
48437     } catch (std::exception& e) {
48438       {
48439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48440       };
48441     } catch (...) {
48442       {
48443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48444       };
48445     }
48446   }
48447 }
48448
48449
48450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48451   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48452
48453   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48454   {
48455     try {
48456       (arg1)->Clear();
48457     } catch (std::out_of_range& e) {
48458       {
48459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48460       };
48461     } catch (std::exception& e) {
48462       {
48463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48464       };
48465     } catch (...) {
48466       {
48467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48468       };
48469     }
48470   }
48471 }
48472
48473
48474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48475   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48476
48477   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48478   {
48479     try {
48480       (arg1)->Release();
48481     } catch (std::out_of_range& e) {
48482       {
48483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48484       };
48485     } catch (std::exception& e) {
48486       {
48487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48488       };
48489     } catch (...) {
48490       {
48491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48492       };
48493     }
48494   }
48495 }
48496
48497
48498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48499   void * jresult ;
48500   Dali::Signal< void () > *result = 0 ;
48501
48502   {
48503     try {
48504       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48505     } catch (std::out_of_range& e) {
48506       {
48507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48508       };
48509     } catch (std::exception& e) {
48510       {
48511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48512       };
48513     } catch (...) {
48514       {
48515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48516       };
48517     }
48518   }
48519   jresult = (void *)result;
48520   return jresult;
48521 }
48522
48523
48524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48525   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48526
48527   arg1 = (Dali::Signal< void () > *)jarg1;
48528   {
48529     try {
48530       delete arg1;
48531     } catch (std::out_of_range& e) {
48532       {
48533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48534       };
48535     } catch (std::exception& e) {
48536       {
48537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48538       };
48539     } catch (...) {
48540       {
48541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48542       };
48543     }
48544   }
48545 }
48546
48547
48548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48549   unsigned int jresult ;
48550   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48551   bool result;
48552
48553   arg1 = (Dali::Signal< void () > *)jarg1;
48554   {
48555     try {
48556       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48557     } catch (std::out_of_range& e) {
48558       {
48559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48560       };
48561     } catch (std::exception& e) {
48562       {
48563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48564       };
48565     } catch (...) {
48566       {
48567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48568       };
48569     }
48570   }
48571   jresult = result;
48572   return jresult;
48573 }
48574
48575
48576 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48577   unsigned long jresult ;
48578   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48579   std::size_t result;
48580
48581   arg1 = (Dali::Signal< void () > *)jarg1;
48582   {
48583     try {
48584       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48585     } catch (std::out_of_range& e) {
48586       {
48587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48588       };
48589     } catch (std::exception& e) {
48590       {
48591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48592       };
48593     } catch (...) {
48594       {
48595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48596       };
48597     }
48598   }
48599   jresult = (unsigned long)result;
48600   return jresult;
48601 }
48602
48603
48604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48605   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48606   void (*arg2)() = (void (*)()) 0 ;
48607
48608   arg1 = (Dali::Signal< void () > *)jarg1;
48609   arg2 = (void (*)())jarg2;
48610   {
48611     try {
48612       (arg1)->Connect(arg2);
48613     } catch (std::out_of_range& e) {
48614       {
48615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48616       };
48617     } catch (std::exception& e) {
48618       {
48619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48620       };
48621     } catch (...) {
48622       {
48623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48624       };
48625     }
48626   }
48627 }
48628
48629
48630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48631   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48632   void (*arg2)() = (void (*)()) 0 ;
48633
48634   arg1 = (Dali::Signal< void () > *)jarg1;
48635   arg2 = (void (*)())jarg2;
48636   {
48637     try {
48638       (arg1)->Disconnect(arg2);
48639     } catch (std::out_of_range& e) {
48640       {
48641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48642       };
48643     } catch (std::exception& e) {
48644       {
48645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48646       };
48647     } catch (...) {
48648       {
48649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48650       };
48651     }
48652   }
48653 }
48654
48655
48656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48657   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48658   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48659   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48660
48661   arg1 = (Dali::Signal< void () > *)jarg1;
48662   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48663   arg3 = (Dali::FunctorDelegate *)jarg3;
48664   {
48665     try {
48666       (arg1)->Connect(arg2,arg3);
48667     } catch (std::out_of_range& e) {
48668       {
48669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48670       };
48671     } catch (std::exception& e) {
48672       {
48673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48674       };
48675     } catch (...) {
48676       {
48677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48678       };
48679     }
48680   }
48681 }
48682
48683
48684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48685   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48686
48687   arg1 = (Dali::Signal< void () > *)jarg1;
48688   {
48689     try {
48690       (arg1)->Emit();
48691     } catch (std::out_of_range& e) {
48692       {
48693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48694       };
48695     } catch (std::exception& e) {
48696       {
48697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48698       };
48699     } catch (...) {
48700       {
48701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48702       };
48703     }
48704   }
48705 }
48706
48707
48708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48709   unsigned int jresult ;
48710   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48711   bool result;
48712
48713   arg1 = (Dali::Signal< void (float) > *)jarg1;
48714   {
48715     try {
48716       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48717     } catch (std::out_of_range& e) {
48718       {
48719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48720       };
48721     } catch (std::exception& e) {
48722       {
48723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48724       };
48725     } catch (...) {
48726       {
48727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48728       };
48729     }
48730   }
48731   jresult = result;
48732   return jresult;
48733 }
48734
48735
48736 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48737   unsigned long jresult ;
48738   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48739   std::size_t result;
48740
48741   arg1 = (Dali::Signal< void (float) > *)jarg1;
48742   {
48743     try {
48744       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48745     } catch (std::out_of_range& e) {
48746       {
48747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48748       };
48749     } catch (std::exception& e) {
48750       {
48751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48752       };
48753     } catch (...) {
48754       {
48755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48756       };
48757     }
48758   }
48759   jresult = (unsigned long)result;
48760   return jresult;
48761 }
48762
48763
48764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
48765   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48766   void (*arg2)(float) = (void (*)(float)) 0 ;
48767
48768   arg1 = (Dali::Signal< void (float) > *)jarg1;
48769   arg2 = (void (*)(float))jarg2;
48770   {
48771     try {
48772       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
48773     } catch (std::out_of_range& e) {
48774       {
48775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48776       };
48777     } catch (std::exception& e) {
48778       {
48779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48780       };
48781     } catch (...) {
48782       {
48783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48784       };
48785     }
48786   }
48787 }
48788
48789
48790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
48791   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48792   void (*arg2)(float) = (void (*)(float)) 0 ;
48793
48794   arg1 = (Dali::Signal< void (float) > *)jarg1;
48795   arg2 = (void (*)(float))jarg2;
48796   {
48797     try {
48798       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
48799     } catch (std::out_of_range& e) {
48800       {
48801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48802       };
48803     } catch (std::exception& e) {
48804       {
48805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48806       };
48807     } catch (...) {
48808       {
48809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48810       };
48811     }
48812   }
48813 }
48814
48815
48816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
48817   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48818   float arg2 ;
48819
48820   arg1 = (Dali::Signal< void (float) > *)jarg1;
48821   arg2 = (float)jarg2;
48822   {
48823     try {
48824       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
48825     } catch (std::out_of_range& e) {
48826       {
48827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48828       };
48829     } catch (std::exception& e) {
48830       {
48831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48832       };
48833     } catch (...) {
48834       {
48835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48836       };
48837     }
48838   }
48839 }
48840
48841
48842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
48843   void * jresult ;
48844   Dali::Signal< void (float) > *result = 0 ;
48845
48846   {
48847     try {
48848       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
48849     } catch (std::out_of_range& e) {
48850       {
48851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48852       };
48853     } catch (std::exception& e) {
48854       {
48855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48856       };
48857     } catch (...) {
48858       {
48859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48860       };
48861     }
48862   }
48863   jresult = (void *)result;
48864   return jresult;
48865 }
48866
48867
48868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
48869   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48870
48871   arg1 = (Dali::Signal< void (float) > *)jarg1;
48872   {
48873     try {
48874       delete arg1;
48875     } catch (std::out_of_range& e) {
48876       {
48877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48878       };
48879     } catch (std::exception& e) {
48880       {
48881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48882       };
48883     } catch (...) {
48884       {
48885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48886       };
48887     }
48888   }
48889 }
48890
48891
48892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
48893   unsigned int jresult ;
48894   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48895   bool result;
48896
48897   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48898   {
48899     try {
48900       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48901     } catch (std::out_of_range& e) {
48902       {
48903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48904       };
48905     } catch (std::exception& e) {
48906       {
48907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48908       };
48909     } catch (...) {
48910       {
48911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48912       };
48913     }
48914   }
48915   jresult = result;
48916   return jresult;
48917 }
48918
48919
48920 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
48921   unsigned long jresult ;
48922   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48923   std::size_t result;
48924
48925   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48926   {
48927     try {
48928       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48929     } catch (std::out_of_range& e) {
48930       {
48931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48932       };
48933     } catch (std::exception& e) {
48934       {
48935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48936       };
48937     } catch (...) {
48938       {
48939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48940       };
48941     }
48942   }
48943   jresult = (unsigned long)result;
48944   return jresult;
48945 }
48946
48947
48948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
48949   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48950   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
48951
48952   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48953   arg2 = (void (*)(Dali::BaseHandle))jarg2;
48954   {
48955     try {
48956       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
48957     } catch (std::out_of_range& e) {
48958       {
48959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48960       };
48961     } catch (std::exception& e) {
48962       {
48963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48964       };
48965     } catch (...) {
48966       {
48967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48968       };
48969     }
48970   }
48971 }
48972
48973
48974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
48975   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48976   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
48977
48978   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48979   arg2 = (void (*)(Dali::BaseHandle))jarg2;
48980   {
48981     try {
48982       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
48983     } catch (std::out_of_range& e) {
48984       {
48985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48986       };
48987     } catch (std::exception& e) {
48988       {
48989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48990       };
48991     } catch (...) {
48992       {
48993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48994       };
48995     }
48996   }
48997 }
48998
48999
49000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49001   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49002   Dali::BaseHandle arg2 ;
49003   Dali::BaseHandle *argp2 ;
49004
49005   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49006   argp2 = (Dali::BaseHandle *)jarg2;
49007   if (!argp2) {
49008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49009     return ;
49010   }
49011   arg2 = *argp2;
49012   {
49013     try {
49014       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49015     } catch (std::out_of_range& e) {
49016       {
49017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49018       };
49019     } catch (std::exception& e) {
49020       {
49021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49022       };
49023     } catch (...) {
49024       {
49025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49026       };
49027     }
49028   }
49029 }
49030
49031
49032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49033   void * jresult ;
49034   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49035
49036   {
49037     try {
49038       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49039     } catch (std::out_of_range& e) {
49040       {
49041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49042       };
49043     } catch (std::exception& e) {
49044       {
49045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49046       };
49047     } catch (...) {
49048       {
49049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49050       };
49051     }
49052   }
49053   jresult = (void *)result;
49054   return jresult;
49055 }
49056
49057
49058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49059   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49060
49061   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49062   {
49063     try {
49064       delete arg1;
49065     } catch (std::out_of_range& e) {
49066       {
49067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49068       };
49069     } catch (std::exception& e) {
49070       {
49071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49072       };
49073     } catch (...) {
49074       {
49075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49076       };
49077     }
49078   }
49079 }
49080
49081
49082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49083   unsigned int jresult ;
49084   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49085   bool result;
49086
49087   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49088   {
49089     try {
49090       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49091     } catch (std::out_of_range& e) {
49092       {
49093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49094       };
49095     } catch (std::exception& e) {
49096       {
49097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49098       };
49099     } catch (...) {
49100       {
49101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49102       };
49103     }
49104   }
49105   jresult = result;
49106   return jresult;
49107 }
49108
49109
49110 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49111   unsigned long jresult ;
49112   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49113   std::size_t result;
49114
49115   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49116   {
49117     try {
49118       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49119     } catch (std::out_of_range& e) {
49120       {
49121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49122       };
49123     } catch (std::exception& e) {
49124       {
49125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49126       };
49127     } catch (...) {
49128       {
49129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49130       };
49131     }
49132   }
49133   jresult = (unsigned long)result;
49134   return jresult;
49135 }
49136
49137
49138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49139   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49140   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49141
49142   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49143   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49144   {
49145     try {
49146       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49147     } catch (std::out_of_range& e) {
49148       {
49149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49150       };
49151     } catch (std::exception& e) {
49152       {
49153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49154       };
49155     } catch (...) {
49156       {
49157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49158       };
49159     }
49160   }
49161 }
49162
49163
49164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49165   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49166   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49167
49168   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49169   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49170   {
49171     try {
49172       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49173     } catch (std::out_of_range& e) {
49174       {
49175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49176       };
49177     } catch (std::exception& e) {
49178       {
49179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49180       };
49181     } catch (...) {
49182       {
49183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49184       };
49185     }
49186   }
49187 }
49188
49189
49190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49191   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49192   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49193
49194   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49195   arg2 = (Dali::RefObject *)jarg2;
49196   {
49197     try {
49198       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49199     } catch (std::out_of_range& e) {
49200       {
49201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49202       };
49203     } catch (std::exception& e) {
49204       {
49205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49206       };
49207     } catch (...) {
49208       {
49209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49210       };
49211     }
49212   }
49213 }
49214
49215
49216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49217   void * jresult ;
49218   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49219
49220   {
49221     try {
49222       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49223     } catch (std::out_of_range& e) {
49224       {
49225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49226       };
49227     } catch (std::exception& e) {
49228       {
49229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49230       };
49231     } catch (...) {
49232       {
49233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49234       };
49235     }
49236   }
49237   jresult = (void *)result;
49238   return jresult;
49239 }
49240
49241
49242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49243   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49244
49245   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49246   {
49247     try {
49248       delete arg1;
49249     } catch (std::out_of_range& e) {
49250       {
49251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49252       };
49253     } catch (std::exception& e) {
49254       {
49255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49256       };
49257     } catch (...) {
49258       {
49259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49260       };
49261     }
49262   }
49263 }
49264
49265
49266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49267   unsigned int jresult ;
49268   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49269   bool result;
49270
49271   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49272   {
49273     try {
49274       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49275     } catch (std::out_of_range& e) {
49276       {
49277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49278       };
49279     } catch (std::exception& e) {
49280       {
49281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49282       };
49283     } catch (...) {
49284       {
49285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49286       };
49287     }
49288   }
49289   jresult = result;
49290   return jresult;
49291 }
49292
49293
49294 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49295   unsigned long jresult ;
49296   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49297   std::size_t result;
49298
49299   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49300   {
49301     try {
49302       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49303     } catch (std::out_of_range& e) {
49304       {
49305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49306       };
49307     } catch (std::exception& e) {
49308       {
49309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49310       };
49311     } catch (...) {
49312       {
49313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49314       };
49315     }
49316   }
49317   jresult = (unsigned long)result;
49318   return jresult;
49319 }
49320
49321
49322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49323   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49324   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49325
49326   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49327   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49328   {
49329     try {
49330       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49331     } catch (std::out_of_range& e) {
49332       {
49333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49334       };
49335     } catch (std::exception& e) {
49336       {
49337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49338       };
49339     } catch (...) {
49340       {
49341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49342       };
49343     }
49344   }
49345 }
49346
49347
49348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49349   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49350   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49351
49352   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49353   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49354   {
49355     try {
49356       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49357     } catch (std::out_of_range& e) {
49358       {
49359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49360       };
49361     } catch (std::exception& e) {
49362       {
49363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49364       };
49365     } catch (...) {
49366       {
49367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49368       };
49369     }
49370   }
49371 }
49372
49373
49374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49375   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49376   Dali::PropertyNotification *arg2 = 0 ;
49377
49378   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49379   arg2 = (Dali::PropertyNotification *)jarg2;
49380   if (!arg2) {
49381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49382     return ;
49383   }
49384   {
49385     try {
49386       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49387     } catch (std::out_of_range& e) {
49388       {
49389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49390       };
49391     } catch (std::exception& e) {
49392       {
49393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49394       };
49395     } catch (...) {
49396       {
49397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49398       };
49399     }
49400   }
49401 }
49402
49403
49404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49405   void * jresult ;
49406   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49407
49408   {
49409     try {
49410       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49411     } catch (std::out_of_range& e) {
49412       {
49413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49414       };
49415     } catch (std::exception& e) {
49416       {
49417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49418       };
49419     } catch (...) {
49420       {
49421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49422       };
49423     }
49424   }
49425   jresult = (void *)result;
49426   return jresult;
49427 }
49428
49429
49430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49431   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49432
49433   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49434   {
49435     try {
49436       delete arg1;
49437     } catch (std::out_of_range& e) {
49438       {
49439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49440       };
49441     } catch (std::exception& e) {
49442       {
49443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49444       };
49445     } catch (...) {
49446       {
49447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49448       };
49449     }
49450   }
49451 }
49452
49453
49454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49455   unsigned int jresult ;
49456   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49457   bool result;
49458
49459   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49460   {
49461     try {
49462       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49463     } catch (std::out_of_range& e) {
49464       {
49465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49466       };
49467     } catch (std::exception& e) {
49468       {
49469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49470       };
49471     } catch (...) {
49472       {
49473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49474       };
49475     }
49476   }
49477   jresult = result;
49478   return jresult;
49479 }
49480
49481
49482 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49483   unsigned long jresult ;
49484   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49485   std::size_t result;
49486
49487   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49488   {
49489     try {
49490       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49491     } catch (std::out_of_range& e) {
49492       {
49493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49494       };
49495     } catch (std::exception& e) {
49496       {
49497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49498       };
49499     } catch (...) {
49500       {
49501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49502       };
49503     }
49504   }
49505   jresult = (unsigned long)result;
49506   return jresult;
49507 }
49508
49509
49510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49511   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49512   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49513
49514   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49515   arg2 = (void (*)(Dali::Image))jarg2;
49516   {
49517     try {
49518       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49519     } catch (std::out_of_range& e) {
49520       {
49521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49522       };
49523     } catch (std::exception& e) {
49524       {
49525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49526       };
49527     } catch (...) {
49528       {
49529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49530       };
49531     }
49532   }
49533 }
49534
49535
49536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49537   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49538   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49539
49540   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49541   arg2 = (void (*)(Dali::Image))jarg2;
49542   {
49543     try {
49544       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49545     } catch (std::out_of_range& e) {
49546       {
49547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49548       };
49549     } catch (std::exception& e) {
49550       {
49551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49552       };
49553     } catch (...) {
49554       {
49555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49556       };
49557     }
49558   }
49559 }
49560
49561
49562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49563   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49564   Dali::Image arg2 ;
49565   Dali::Image *argp2 ;
49566
49567   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49568   argp2 = (Dali::Image *)jarg2;
49569   if (!argp2) {
49570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49571     return ;
49572   }
49573   arg2 = *argp2;
49574   {
49575     try {
49576       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49577     } catch (std::out_of_range& e) {
49578       {
49579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49580       };
49581     } catch (std::exception& e) {
49582       {
49583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49584       };
49585     } catch (...) {
49586       {
49587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49588       };
49589     }
49590   }
49591 }
49592
49593
49594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49595   void * jresult ;
49596   Dali::Signal< void (Dali::Image) > *result = 0 ;
49597
49598   {
49599     try {
49600       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49601     } catch (std::out_of_range& e) {
49602       {
49603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49604       };
49605     } catch (std::exception& e) {
49606       {
49607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49608       };
49609     } catch (...) {
49610       {
49611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49612       };
49613     }
49614   }
49615   jresult = (void *)result;
49616   return jresult;
49617 }
49618
49619
49620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49621   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49622
49623   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49624   {
49625     try {
49626       delete arg1;
49627     } catch (std::out_of_range& e) {
49628       {
49629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49630       };
49631     } catch (std::exception& e) {
49632       {
49633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49634       };
49635     } catch (...) {
49636       {
49637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49638       };
49639     }
49640   }
49641 }
49642
49643
49644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49645   void * jresult ;
49646   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49647
49648   {
49649     try {
49650       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49651     } catch (std::out_of_range& e) {
49652       {
49653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49654       };
49655     } catch (std::exception& e) {
49656       {
49657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49658       };
49659     } catch (...) {
49660       {
49661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49662       };
49663     }
49664   }
49665   jresult = (void *)result;
49666   return jresult;
49667 }
49668
49669
49670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49671   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49672
49673   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49674   {
49675     try {
49676       delete arg1;
49677     } catch (std::out_of_range& e) {
49678       {
49679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49680       };
49681     } catch (std::exception& e) {
49682       {
49683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49684       };
49685     } catch (...) {
49686       {
49687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49688       };
49689     }
49690   }
49691 }
49692
49693
49694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49695   unsigned int jresult ;
49696   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49697   bool result;
49698
49699   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49700   {
49701     try {
49702       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);
49703     } catch (std::out_of_range& e) {
49704       {
49705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49706       };
49707     } catch (std::exception& e) {
49708       {
49709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49710       };
49711     } catch (...) {
49712       {
49713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49714       };
49715     }
49716   }
49717   jresult = result;
49718   return jresult;
49719 }
49720
49721
49722 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49723   unsigned long jresult ;
49724   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49725   std::size_t result;
49726
49727   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49728   {
49729     try {
49730       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);
49731     } catch (std::out_of_range& e) {
49732       {
49733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49734       };
49735     } catch (std::exception& e) {
49736       {
49737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49738       };
49739     } catch (...) {
49740       {
49741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49742       };
49743     }
49744   }
49745   jresult = (unsigned long)result;
49746   return jresult;
49747 }
49748
49749
49750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49751   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49752   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49753
49754   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49755   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49756   {
49757     try {
49758       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49759     } catch (std::out_of_range& e) {
49760       {
49761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49762       };
49763     } catch (std::exception& e) {
49764       {
49765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49766       };
49767     } catch (...) {
49768       {
49769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49770       };
49771     }
49772   }
49773 }
49774
49775
49776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49777   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49778   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49779
49780   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49781   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49782   {
49783     try {
49784       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49785     } catch (std::out_of_range& e) {
49786       {
49787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49788       };
49789     } catch (std::exception& e) {
49790       {
49791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49792       };
49793     } catch (...) {
49794       {
49795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49796       };
49797     }
49798   }
49799 }
49800
49801
49802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49803   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49804   Dali::Actor arg2 ;
49805   Dali::LongPressGesture *arg3 = 0 ;
49806   Dali::Actor *argp2 ;
49807
49808   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49809   argp2 = (Dali::Actor *)jarg2;
49810   if (!argp2) {
49811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49812     return ;
49813   }
49814   arg2 = *argp2;
49815   arg3 = (Dali::LongPressGesture *)jarg3;
49816   if (!arg3) {
49817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
49818     return ;
49819   }
49820   {
49821     try {
49822       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
49823     } catch (std::out_of_range& e) {
49824       {
49825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49826       };
49827     } catch (std::exception& e) {
49828       {
49829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49830       };
49831     } catch (...) {
49832       {
49833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49834       };
49835     }
49836   }
49837 }
49838
49839
49840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
49841   void * jresult ;
49842   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
49843
49844   {
49845     try {
49846       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
49847     } catch (std::out_of_range& e) {
49848       {
49849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49850       };
49851     } catch (std::exception& e) {
49852       {
49853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49854       };
49855     } catch (...) {
49856       {
49857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49858       };
49859     }
49860   }
49861   jresult = (void *)result;
49862   return jresult;
49863 }
49864
49865
49866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
49867   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49868
49869   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49870   {
49871     try {
49872       delete arg1;
49873     } catch (std::out_of_range& e) {
49874       {
49875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49876       };
49877     } catch (std::exception& e) {
49878       {
49879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49880       };
49881     } catch (...) {
49882       {
49883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49884       };
49885     }
49886   }
49887 }
49888
49889
49890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
49891   unsigned int jresult ;
49892   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49893   bool result;
49894
49895   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49896   {
49897     try {
49898       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);
49899     } catch (std::out_of_range& e) {
49900       {
49901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49902       };
49903     } catch (std::exception& e) {
49904       {
49905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49906       };
49907     } catch (...) {
49908       {
49909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49910       };
49911     }
49912   }
49913   jresult = result;
49914   return jresult;
49915 }
49916
49917
49918 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
49919   unsigned long jresult ;
49920   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49921   std::size_t result;
49922
49923   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49924   {
49925     try {
49926       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);
49927     } catch (std::out_of_range& e) {
49928       {
49929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49930       };
49931     } catch (std::exception& e) {
49932       {
49933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49934       };
49935     } catch (...) {
49936       {
49937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49938       };
49939     }
49940   }
49941   jresult = (unsigned long)result;
49942   return jresult;
49943 }
49944
49945
49946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
49947   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49948   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
49949
49950   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49951   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
49952   {
49953     try {
49954       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49955     } catch (std::out_of_range& e) {
49956       {
49957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49958       };
49959     } catch (std::exception& e) {
49960       {
49961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49962       };
49963     } catch (...) {
49964       {
49965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49966       };
49967     }
49968   }
49969 }
49970
49971
49972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
49973   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49974   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
49975
49976   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49977   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
49978   {
49979     try {
49980       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49981     } catch (std::out_of_range& e) {
49982       {
49983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49984       };
49985     } catch (std::exception& e) {
49986       {
49987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49988       };
49989     } catch (...) {
49990       {
49991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49992       };
49993     }
49994   }
49995 }
49996
49997
49998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49999   unsigned int jresult ;
50000   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50001   Dali::Actor arg2 ;
50002   Dali::TouchData *arg3 = 0 ;
50003   Dali::Actor *argp2 ;
50004   bool result;
50005
50006   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50007   argp2 = (Dali::Actor *)jarg2;
50008   if (!argp2) {
50009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50010     return 0;
50011   }
50012   arg2 = *argp2;
50013   arg3 = (Dali::TouchData *)jarg3;
50014   if (!arg3) {
50015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50016     return 0;
50017   }
50018   {
50019     try {
50020       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50021     } catch (std::out_of_range& e) {
50022       {
50023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50024       };
50025     } catch (std::exception& e) {
50026       {
50027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50028       };
50029     } catch (...) {
50030       {
50031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50032       };
50033     }
50034   }
50035   jresult = result;
50036   return jresult;
50037 }
50038
50039
50040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50041   void * jresult ;
50042   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50043
50044   {
50045     try {
50046       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50047     } catch (std::out_of_range& e) {
50048       {
50049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50050       };
50051     } catch (std::exception& e) {
50052       {
50053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50054       };
50055     } catch (...) {
50056       {
50057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50058       };
50059     }
50060   }
50061   jresult = (void *)result;
50062   return jresult;
50063 }
50064
50065
50066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50067   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50068
50069   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50070   {
50071     try {
50072       delete arg1;
50073     } catch (std::out_of_range& e) {
50074       {
50075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50076       };
50077     } catch (std::exception& e) {
50078       {
50079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50080       };
50081     } catch (...) {
50082       {
50083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50084       };
50085     }
50086   }
50087 }
50088
50089
50090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50091   unsigned int jresult ;
50092   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50093   bool result;
50094
50095   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50096   {
50097     try {
50098       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);
50099     } catch (std::out_of_range& e) {
50100       {
50101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50102       };
50103     } catch (std::exception& e) {
50104       {
50105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50106       };
50107     } catch (...) {
50108       {
50109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50110       };
50111     }
50112   }
50113   jresult = result;
50114   return jresult;
50115 }
50116
50117
50118 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50119   unsigned long jresult ;
50120   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50121   std::size_t result;
50122
50123   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50124   {
50125     try {
50126       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);
50127     } catch (std::out_of_range& e) {
50128       {
50129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50130       };
50131     } catch (std::exception& e) {
50132       {
50133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50134       };
50135     } catch (...) {
50136       {
50137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50138       };
50139     }
50140   }
50141   jresult = (unsigned long)result;
50142   return jresult;
50143 }
50144
50145
50146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50147   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50148   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50149
50150   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50151   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50152   {
50153     try {
50154       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50155     } catch (std::out_of_range& e) {
50156       {
50157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50158       };
50159     } catch (std::exception& e) {
50160       {
50161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50162       };
50163     } catch (...) {
50164       {
50165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50166       };
50167     }
50168   }
50169 }
50170
50171
50172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50173   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50174   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50175
50176   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50177   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50178   {
50179     try {
50180       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50181     } catch (std::out_of_range& e) {
50182       {
50183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50184       };
50185     } catch (std::exception& e) {
50186       {
50187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50188       };
50189     } catch (...) {
50190       {
50191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50192       };
50193     }
50194   }
50195 }
50196
50197
50198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50199   unsigned int jresult ;
50200   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50201   Dali::Actor arg2 ;
50202   Dali::HoverEvent *arg3 = 0 ;
50203   Dali::Actor *argp2 ;
50204   bool result;
50205
50206   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50207   argp2 = (Dali::Actor *)jarg2;
50208   if (!argp2) {
50209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50210     return 0;
50211   }
50212   arg2 = *argp2;
50213   arg3 = (Dali::HoverEvent *)jarg3;
50214   if (!arg3) {
50215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50216     return 0;
50217   }
50218   {
50219     try {
50220       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50221     } catch (std::out_of_range& e) {
50222       {
50223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50224       };
50225     } catch (std::exception& e) {
50226       {
50227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50228       };
50229     } catch (...) {
50230       {
50231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50232       };
50233     }
50234   }
50235   jresult = result;
50236   return jresult;
50237 }
50238
50239
50240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50241   void * jresult ;
50242   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50243
50244   {
50245     try {
50246       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50247     } catch (std::out_of_range& e) {
50248       {
50249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50250       };
50251     } catch (std::exception& e) {
50252       {
50253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50254       };
50255     } catch (...) {
50256       {
50257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50258       };
50259     }
50260   }
50261   jresult = (void *)result;
50262   return jresult;
50263 }
50264
50265
50266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50267   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50268
50269   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50270   {
50271     try {
50272       delete arg1;
50273     } catch (std::out_of_range& e) {
50274       {
50275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50276       };
50277     } catch (std::exception& e) {
50278       {
50279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50280       };
50281     } catch (...) {
50282       {
50283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50284       };
50285     }
50286   }
50287 }
50288
50289
50290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50291   unsigned int jresult ;
50292   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50293   bool result;
50294
50295   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50296   {
50297     try {
50298       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);
50299     } catch (std::out_of_range& e) {
50300       {
50301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50302       };
50303     } catch (std::exception& e) {
50304       {
50305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50306       };
50307     } catch (...) {
50308       {
50309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50310       };
50311     }
50312   }
50313   jresult = result;
50314   return jresult;
50315 }
50316
50317
50318 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50319   unsigned long jresult ;
50320   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50321   std::size_t result;
50322
50323   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50324   {
50325     try {
50326       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);
50327     } catch (std::out_of_range& e) {
50328       {
50329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50330       };
50331     } catch (std::exception& e) {
50332       {
50333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50334       };
50335     } catch (...) {
50336       {
50337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50338       };
50339     }
50340   }
50341   jresult = (unsigned long)result;
50342   return jresult;
50343 }
50344
50345
50346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50347   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50348   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50349
50350   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50351   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50352   {
50353     try {
50354       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50355     } catch (std::out_of_range& e) {
50356       {
50357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50358       };
50359     } catch (std::exception& e) {
50360       {
50361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50362       };
50363     } catch (...) {
50364       {
50365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50366       };
50367     }
50368   }
50369 }
50370
50371
50372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50373   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50374   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50375
50376   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50377   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50378   {
50379     try {
50380       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50381     } catch (std::out_of_range& e) {
50382       {
50383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50384       };
50385     } catch (std::exception& e) {
50386       {
50387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50388       };
50389     } catch (...) {
50390       {
50391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50392       };
50393     }
50394   }
50395 }
50396
50397
50398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50399   unsigned int jresult ;
50400   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50401   Dali::Actor arg2 ;
50402   Dali::WheelEvent *arg3 = 0 ;
50403   Dali::Actor *argp2 ;
50404   bool result;
50405
50406   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50407   argp2 = (Dali::Actor *)jarg2;
50408   if (!argp2) {
50409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50410     return 0;
50411   }
50412   arg2 = *argp2;
50413   arg3 = (Dali::WheelEvent *)jarg3;
50414   if (!arg3) {
50415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50416     return 0;
50417   }
50418   {
50419     try {
50420       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50421     } catch (std::out_of_range& e) {
50422       {
50423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50424       };
50425     } catch (std::exception& e) {
50426       {
50427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50428       };
50429     } catch (...) {
50430       {
50431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50432       };
50433     }
50434   }
50435   jresult = result;
50436   return jresult;
50437 }
50438
50439
50440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50441   void * jresult ;
50442   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50443
50444   {
50445     try {
50446       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50447     } catch (std::out_of_range& e) {
50448       {
50449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50450       };
50451     } catch (std::exception& e) {
50452       {
50453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50454       };
50455     } catch (...) {
50456       {
50457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50458       };
50459     }
50460   }
50461   jresult = (void *)result;
50462   return jresult;
50463 }
50464
50465
50466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50467   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50468
50469   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50470   {
50471     try {
50472       delete arg1;
50473     } catch (std::out_of_range& e) {
50474       {
50475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50476       };
50477     } catch (std::exception& e) {
50478       {
50479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50480       };
50481     } catch (...) {
50482       {
50483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50484       };
50485     }
50486   }
50487 }
50488
50489
50490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50491   unsigned int jresult ;
50492   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50493   bool result;
50494
50495   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50496   {
50497     try {
50498       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50499     } catch (std::out_of_range& e) {
50500       {
50501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50502       };
50503     } catch (std::exception& e) {
50504       {
50505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50506       };
50507     } catch (...) {
50508       {
50509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50510       };
50511     }
50512   }
50513   jresult = result;
50514   return jresult;
50515 }
50516
50517
50518 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50519   unsigned long jresult ;
50520   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50521   std::size_t result;
50522
50523   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50524   {
50525     try {
50526       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50527     } catch (std::out_of_range& e) {
50528       {
50529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50530       };
50531     } catch (std::exception& e) {
50532       {
50533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50534       };
50535     } catch (...) {
50536       {
50537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50538       };
50539     }
50540   }
50541   jresult = (unsigned long)result;
50542   return jresult;
50543 }
50544
50545
50546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50547   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50548   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50549
50550   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50551   arg2 = (void (*)(Dali::Actor))jarg2;
50552   {
50553     try {
50554       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50555     } catch (std::out_of_range& e) {
50556       {
50557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50558       };
50559     } catch (std::exception& e) {
50560       {
50561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50562       };
50563     } catch (...) {
50564       {
50565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50566       };
50567     }
50568   }
50569 }
50570
50571
50572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50573   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50574   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50575
50576   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50577   arg2 = (void (*)(Dali::Actor))jarg2;
50578   {
50579     try {
50580       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50581     } catch (std::out_of_range& e) {
50582       {
50583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50584       };
50585     } catch (std::exception& e) {
50586       {
50587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50588       };
50589     } catch (...) {
50590       {
50591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50592       };
50593     }
50594   }
50595 }
50596
50597
50598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50599   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50600   Dali::Actor arg2 ;
50601   Dali::Actor *argp2 ;
50602
50603   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50604   argp2 = (Dali::Actor *)jarg2;
50605   if (!argp2) {
50606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50607     return ;
50608   }
50609   arg2 = *argp2;
50610   {
50611     try {
50612       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50613     } catch (std::out_of_range& e) {
50614       {
50615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50616       };
50617     } catch (std::exception& e) {
50618       {
50619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50620       };
50621     } catch (...) {
50622       {
50623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50624       };
50625     }
50626   }
50627 }
50628
50629
50630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50631   void * jresult ;
50632   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50633
50634   {
50635     try {
50636       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50637     } catch (std::out_of_range& e) {
50638       {
50639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50640       };
50641     } catch (std::exception& e) {
50642       {
50643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50644       };
50645     } catch (...) {
50646       {
50647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50648       };
50649     }
50650   }
50651   jresult = (void *)result;
50652   return jresult;
50653 }
50654
50655
50656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50657   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50658
50659   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50660   {
50661     try {
50662       delete arg1;
50663     } catch (std::out_of_range& e) {
50664       {
50665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50666       };
50667     } catch (std::exception& e) {
50668       {
50669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50670       };
50671     } catch (...) {
50672       {
50673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50674       };
50675     }
50676   }
50677 }
50678
50679
50680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50681   unsigned int jresult ;
50682   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50683   bool result;
50684
50685   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50686   {
50687     try {
50688       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50689     } catch (std::out_of_range& e) {
50690       {
50691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50692       };
50693     } catch (std::exception& e) {
50694       {
50695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50696       };
50697     } catch (...) {
50698       {
50699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50700       };
50701     }
50702   }
50703   jresult = result;
50704   return jresult;
50705 }
50706
50707
50708 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50709   unsigned long jresult ;
50710   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50711   std::size_t result;
50712
50713   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50714   {
50715     try {
50716       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50717     } catch (std::out_of_range& e) {
50718       {
50719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50720       };
50721     } catch (std::exception& e) {
50722       {
50723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50724       };
50725     } catch (...) {
50726       {
50727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50728       };
50729     }
50730   }
50731   jresult = (unsigned long)result;
50732   return jresult;
50733 }
50734
50735
50736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50737   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50738   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50739
50740   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50741   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50742   {
50743     try {
50744       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50745     } catch (std::out_of_range& e) {
50746       {
50747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50748       };
50749     } catch (std::exception& e) {
50750       {
50751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50752       };
50753     } catch (...) {
50754       {
50755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50756       };
50757     }
50758   }
50759 }
50760
50761
50762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
50763   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50764   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50765
50766   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50767   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50768   {
50769     try {
50770       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50771     } catch (std::out_of_range& e) {
50772       {
50773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50774       };
50775     } catch (std::exception& e) {
50776       {
50777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50778       };
50779     } catch (...) {
50780       {
50781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50782       };
50783     }
50784   }
50785 }
50786
50787
50788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
50789   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50790   Dali::KeyEvent *arg2 = 0 ;
50791
50792   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50793   arg2 = (Dali::KeyEvent *)jarg2;
50794   if (!arg2) {
50795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
50796     return ;
50797   }
50798   {
50799     try {
50800       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
50801     } catch (std::out_of_range& e) {
50802       {
50803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50804       };
50805     } catch (std::exception& e) {
50806       {
50807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50808       };
50809     } catch (...) {
50810       {
50811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50812       };
50813     }
50814   }
50815 }
50816
50817
50818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
50819   void * jresult ;
50820   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
50821
50822   {
50823     try {
50824       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
50825     } catch (std::out_of_range& e) {
50826       {
50827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50828       };
50829     } catch (std::exception& e) {
50830       {
50831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50832       };
50833     } catch (...) {
50834       {
50835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50836       };
50837     }
50838   }
50839   jresult = (void *)result;
50840   return jresult;
50841 }
50842
50843
50844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
50845   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50846
50847   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50848   {
50849     try {
50850       delete arg1;
50851     } catch (std::out_of_range& e) {
50852       {
50853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50854       };
50855     } catch (std::exception& e) {
50856       {
50857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50858       };
50859     } catch (...) {
50860       {
50861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50862       };
50863     }
50864   }
50865 }
50866
50867
50868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
50869   unsigned int jresult ;
50870   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50871   bool result;
50872
50873   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50874   {
50875     try {
50876       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50877     } catch (std::out_of_range& e) {
50878       {
50879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50880       };
50881     } catch (std::exception& e) {
50882       {
50883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50884       };
50885     } catch (...) {
50886       {
50887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50888       };
50889     }
50890   }
50891   jresult = result;
50892   return jresult;
50893 }
50894
50895
50896 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
50897   unsigned long jresult ;
50898   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50899   std::size_t result;
50900
50901   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50902   {
50903     try {
50904       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50905     } catch (std::out_of_range& e) {
50906       {
50907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50908       };
50909     } catch (std::exception& e) {
50910       {
50911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50912       };
50913     } catch (...) {
50914       {
50915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50916       };
50917     }
50918   }
50919   jresult = (unsigned long)result;
50920   return jresult;
50921 }
50922
50923
50924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
50925   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50926   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
50927
50928   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50929   arg2 = (void (*)(Dali::TouchData const &))jarg2;
50930   {
50931     try {
50932       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50933     } catch (std::out_of_range& e) {
50934       {
50935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50936       };
50937     } catch (std::exception& e) {
50938       {
50939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50940       };
50941     } catch (...) {
50942       {
50943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50944       };
50945     }
50946   }
50947 }
50948
50949
50950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
50951   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50952   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
50953
50954   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50955   arg2 = (void (*)(Dali::TouchData const &))jarg2;
50956   {
50957     try {
50958       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50959     } catch (std::out_of_range& e) {
50960       {
50961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50962       };
50963     } catch (std::exception& e) {
50964       {
50965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50966       };
50967     } catch (...) {
50968       {
50969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50970       };
50971     }
50972   }
50973 }
50974
50975
50976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
50977   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50978   Dali::TouchData *arg2 = 0 ;
50979
50980   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50981   arg2 = (Dali::TouchData *)jarg2;
50982   if (!arg2) {
50983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50984     return ;
50985   }
50986   {
50987     try {
50988       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
50989     } catch (std::out_of_range& e) {
50990       {
50991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50992       };
50993     } catch (std::exception& e) {
50994       {
50995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50996       };
50997     } catch (...) {
50998       {
50999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51000       };
51001     }
51002   }
51003 }
51004
51005
51006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51007   void * jresult ;
51008   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51009
51010   {
51011     try {
51012       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51013     } catch (std::out_of_range& e) {
51014       {
51015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51016       };
51017     } catch (std::exception& e) {
51018       {
51019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51020       };
51021     } catch (...) {
51022       {
51023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51024       };
51025     }
51026   }
51027   jresult = (void *)result;
51028   return jresult;
51029 }
51030
51031
51032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51033   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51034
51035   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51036   {
51037     try {
51038       delete arg1;
51039     } catch (std::out_of_range& e) {
51040       {
51041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51042       };
51043     } catch (std::exception& e) {
51044       {
51045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51046       };
51047     } catch (...) {
51048       {
51049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51050       };
51051     }
51052   }
51053 }
51054
51055
51056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51057   unsigned int jresult ;
51058   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51059   bool result;
51060
51061   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51062   {
51063     try {
51064       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51065     } catch (std::out_of_range& e) {
51066       {
51067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51068       };
51069     } catch (std::exception& e) {
51070       {
51071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51072       };
51073     } catch (...) {
51074       {
51075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51076       };
51077     }
51078   }
51079   jresult = result;
51080   return jresult;
51081 }
51082
51083
51084 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51085   unsigned long jresult ;
51086   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51087   std::size_t result;
51088
51089   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51090   {
51091     try {
51092       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51093     } catch (std::out_of_range& e) {
51094       {
51095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51096       };
51097     } catch (std::exception& e) {
51098       {
51099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51100       };
51101     } catch (...) {
51102       {
51103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51104       };
51105     }
51106   }
51107   jresult = (unsigned long)result;
51108   return jresult;
51109 }
51110
51111
51112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51113   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51114   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51115
51116   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51117   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51118   {
51119     try {
51120       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51121     } catch (std::out_of_range& e) {
51122       {
51123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51124       };
51125     } catch (std::exception& e) {
51126       {
51127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51128       };
51129     } catch (...) {
51130       {
51131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51132       };
51133     }
51134   }
51135 }
51136
51137
51138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51139   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51140   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51141
51142   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51143   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51144   {
51145     try {
51146       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51147     } catch (std::out_of_range& e) {
51148       {
51149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51150       };
51151     } catch (std::exception& e) {
51152       {
51153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51154       };
51155     } catch (...) {
51156       {
51157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51158       };
51159     }
51160   }
51161 }
51162
51163
51164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51165   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51166   Dali::WheelEvent *arg2 = 0 ;
51167
51168   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51169   arg2 = (Dali::WheelEvent *)jarg2;
51170   if (!arg2) {
51171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51172     return ;
51173   }
51174   {
51175     try {
51176       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51177     } catch (std::out_of_range& e) {
51178       {
51179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51180       };
51181     } catch (std::exception& e) {
51182       {
51183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51184       };
51185     } catch (...) {
51186       {
51187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51188       };
51189     }
51190   }
51191 }
51192
51193
51194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51195   void * jresult ;
51196   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51197
51198   {
51199     try {
51200       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51201     } catch (std::out_of_range& e) {
51202       {
51203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51204       };
51205     } catch (std::exception& e) {
51206       {
51207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51208       };
51209     } catch (...) {
51210       {
51211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51212       };
51213     }
51214   }
51215   jresult = (void *)result;
51216   return jresult;
51217 }
51218
51219
51220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51221   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51222
51223   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51224   {
51225     try {
51226       delete arg1;
51227     } catch (std::out_of_range& e) {
51228       {
51229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51230       };
51231     } catch (std::exception& e) {
51232       {
51233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51234       };
51235     } catch (...) {
51236       {
51237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51238       };
51239     }
51240   }
51241 }
51242
51243
51244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51245   void * jresult ;
51246   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51247
51248   {
51249     try {
51250       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51251     } catch (std::out_of_range& e) {
51252       {
51253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51254       };
51255     } catch (std::exception& e) {
51256       {
51257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51258       };
51259     } catch (...) {
51260       {
51261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51262       };
51263     }
51264   }
51265   jresult = (void *)result;
51266   return jresult;
51267 }
51268
51269
51270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51271   void * jresult ;
51272   Dali::Radian arg1 ;
51273   Dali::Radian arg2 ;
51274   Dali::Radian *argp1 ;
51275   Dali::Radian *argp2 ;
51276   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51277
51278   argp1 = (Dali::Radian *)jarg1;
51279   if (!argp1) {
51280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51281     return 0;
51282   }
51283   arg1 = *argp1;
51284   argp2 = (Dali::Radian *)jarg2;
51285   if (!argp2) {
51286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51287     return 0;
51288   }
51289   arg2 = *argp2;
51290   {
51291     try {
51292       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51293     } catch (std::out_of_range& e) {
51294       {
51295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51296       };
51297     } catch (std::exception& e) {
51298       {
51299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51300       };
51301     } catch (...) {
51302       {
51303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51304       };
51305     }
51306   }
51307   jresult = (void *)result;
51308   return jresult;
51309 }
51310
51311
51312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51313   void * jresult ;
51314   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51315   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51316
51317   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51318   if (!arg1) {
51319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51320     return 0;
51321   }
51322   {
51323     try {
51324       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51325     } catch (std::out_of_range& e) {
51326       {
51327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51328       };
51329     } catch (std::exception& e) {
51330       {
51331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51332       };
51333     } catch (...) {
51334       {
51335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51336       };
51337     }
51338   }
51339   jresult = (void *)result;
51340   return jresult;
51341 }
51342
51343
51344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51345   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51346   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51347
51348   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51349   arg2 = (Dali::Radian *)jarg2;
51350   if (arg1) (arg1)->first = *arg2;
51351 }
51352
51353
51354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51355   void * jresult ;
51356   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51357   Dali::Radian *result = 0 ;
51358
51359   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51360   result = (Dali::Radian *)& ((arg1)->first);
51361   jresult = (void *)result;
51362   return jresult;
51363 }
51364
51365
51366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51367   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51368   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51369
51370   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51371   arg2 = (Dali::Radian *)jarg2;
51372   if (arg1) (arg1)->second = *arg2;
51373 }
51374
51375
51376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51377   void * jresult ;
51378   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51379   Dali::Radian *result = 0 ;
51380
51381   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51382   result = (Dali::Radian *)& ((arg1)->second);
51383   jresult = (void *)result;
51384   return jresult;
51385 }
51386
51387
51388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51389   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51390
51391   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51392   {
51393     try {
51394       delete arg1;
51395     } catch (std::out_of_range& e) {
51396       {
51397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51398       };
51399     } catch (std::exception& e) {
51400       {
51401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51402       };
51403     } catch (...) {
51404       {
51405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51406       };
51407     }
51408   }
51409 }
51410
51411
51412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51413   unsigned int jresult ;
51414   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51415   bool result;
51416
51417   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51418   {
51419     try {
51420       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);
51421     } catch (std::out_of_range& e) {
51422       {
51423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51424       };
51425     } catch (std::exception& e) {
51426       {
51427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51428       };
51429     } catch (...) {
51430       {
51431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51432       };
51433     }
51434   }
51435   jresult = result;
51436   return jresult;
51437 }
51438
51439
51440 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51441   unsigned long jresult ;
51442   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51443   std::size_t result;
51444
51445   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51446   {
51447     try {
51448       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);
51449     } catch (std::out_of_range& e) {
51450       {
51451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51452       };
51453     } catch (std::exception& e) {
51454       {
51455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51456       };
51457     } catch (...) {
51458       {
51459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51460       };
51461     }
51462   }
51463   jresult = (unsigned long)result;
51464   return jresult;
51465 }
51466
51467
51468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51469   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51470   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51471
51472   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51473   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51474   {
51475     try {
51476       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51477     } catch (std::out_of_range& e) {
51478       {
51479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51480       };
51481     } catch (std::exception& e) {
51482       {
51483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51484       };
51485     } catch (...) {
51486       {
51487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51488       };
51489     }
51490   }
51491 }
51492
51493
51494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51495   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51496   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51497
51498   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51499   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51500   {
51501     try {
51502       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51503     } catch (std::out_of_range& e) {
51504       {
51505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51506       };
51507     } catch (std::exception& e) {
51508       {
51509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51510       };
51511     } catch (...) {
51512       {
51513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51514       };
51515     }
51516   }
51517 }
51518
51519
51520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51521   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51522   Dali::Actor arg2 ;
51523   Dali::PanGesture *arg3 = 0 ;
51524   Dali::Actor *argp2 ;
51525
51526   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51527   argp2 = (Dali::Actor *)jarg2;
51528   if (!argp2) {
51529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51530     return ;
51531   }
51532   arg2 = *argp2;
51533   arg3 = (Dali::PanGesture *)jarg3;
51534   if (!arg3) {
51535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51536     return ;
51537   }
51538   {
51539     try {
51540       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51541     } catch (std::out_of_range& e) {
51542       {
51543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51544       };
51545     } catch (std::exception& e) {
51546       {
51547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51548       };
51549     } catch (...) {
51550       {
51551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51552       };
51553     }
51554   }
51555 }
51556
51557
51558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51559   void * jresult ;
51560   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51561
51562   {
51563     try {
51564       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51565     } catch (std::out_of_range& e) {
51566       {
51567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51568       };
51569     } catch (std::exception& e) {
51570       {
51571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51572       };
51573     } catch (...) {
51574       {
51575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51576       };
51577     }
51578   }
51579   jresult = (void *)result;
51580   return jresult;
51581 }
51582
51583
51584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51585   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51586
51587   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51588   {
51589     try {
51590       delete arg1;
51591     } catch (std::out_of_range& e) {
51592       {
51593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51594       };
51595     } catch (std::exception& e) {
51596       {
51597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51598       };
51599     } catch (...) {
51600       {
51601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51602       };
51603     }
51604   }
51605 }
51606
51607
51608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51609   unsigned int jresult ;
51610   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51611   bool result;
51612
51613   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51614   {
51615     try {
51616       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);
51617     } catch (std::out_of_range& e) {
51618       {
51619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51620       };
51621     } catch (std::exception& e) {
51622       {
51623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51624       };
51625     } catch (...) {
51626       {
51627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51628       };
51629     }
51630   }
51631   jresult = result;
51632   return jresult;
51633 }
51634
51635
51636 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51637   unsigned long jresult ;
51638   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51639   std::size_t result;
51640
51641   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51642   {
51643     try {
51644       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);
51645     } catch (std::out_of_range& e) {
51646       {
51647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51648       };
51649     } catch (std::exception& e) {
51650       {
51651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51652       };
51653     } catch (...) {
51654       {
51655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51656       };
51657     }
51658   }
51659   jresult = (unsigned long)result;
51660   return jresult;
51661 }
51662
51663
51664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51665   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51666   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51667
51668   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51669   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51670   {
51671     try {
51672       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51673     } catch (std::out_of_range& e) {
51674       {
51675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51676       };
51677     } catch (std::exception& e) {
51678       {
51679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51680       };
51681     } catch (...) {
51682       {
51683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51684       };
51685     }
51686   }
51687 }
51688
51689
51690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51691   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51692   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51693
51694   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51695   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51696   {
51697     try {
51698       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51699     } catch (std::out_of_range& e) {
51700       {
51701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51702       };
51703     } catch (std::exception& e) {
51704       {
51705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51706       };
51707     } catch (...) {
51708       {
51709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51710       };
51711     }
51712   }
51713 }
51714
51715
51716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51717   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51718   Dali::Actor arg2 ;
51719   Dali::PinchGesture *arg3 = 0 ;
51720   Dali::Actor *argp2 ;
51721
51722   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51723   argp2 = (Dali::Actor *)jarg2;
51724   if (!argp2) {
51725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51726     return ;
51727   }
51728   arg2 = *argp2;
51729   arg3 = (Dali::PinchGesture *)jarg3;
51730   if (!arg3) {
51731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51732     return ;
51733   }
51734   {
51735     try {
51736       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51737     } catch (std::out_of_range& e) {
51738       {
51739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51740       };
51741     } catch (std::exception& e) {
51742       {
51743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51744       };
51745     } catch (...) {
51746       {
51747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51748       };
51749     }
51750   }
51751 }
51752
51753
51754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51755   void * jresult ;
51756   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51757
51758   {
51759     try {
51760       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
51761     } catch (std::out_of_range& e) {
51762       {
51763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51764       };
51765     } catch (std::exception& e) {
51766       {
51767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51768       };
51769     } catch (...) {
51770       {
51771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51772       };
51773     }
51774   }
51775   jresult = (void *)result;
51776   return jresult;
51777 }
51778
51779
51780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
51781   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51782
51783   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51784   {
51785     try {
51786       delete arg1;
51787     } catch (std::out_of_range& e) {
51788       {
51789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51790       };
51791     } catch (std::exception& e) {
51792       {
51793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51794       };
51795     } catch (...) {
51796       {
51797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51798       };
51799     }
51800   }
51801 }
51802
51803
51804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
51805   unsigned int jresult ;
51806   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51807   bool result;
51808
51809   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51810   {
51811     try {
51812       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);
51813     } catch (std::out_of_range& e) {
51814       {
51815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51816       };
51817     } catch (std::exception& e) {
51818       {
51819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51820       };
51821     } catch (...) {
51822       {
51823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51824       };
51825     }
51826   }
51827   jresult = result;
51828   return jresult;
51829 }
51830
51831
51832 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51833   unsigned long jresult ;
51834   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51835   std::size_t result;
51836
51837   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51838   {
51839     try {
51840       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);
51841     } catch (std::out_of_range& e) {
51842       {
51843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51844       };
51845     } catch (std::exception& e) {
51846       {
51847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51848       };
51849     } catch (...) {
51850       {
51851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51852       };
51853     }
51854   }
51855   jresult = (unsigned long)result;
51856   return jresult;
51857 }
51858
51859
51860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51861   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51862   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51863
51864   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51865   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51866   {
51867     try {
51868       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51869     } catch (std::out_of_range& e) {
51870       {
51871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51872       };
51873     } catch (std::exception& e) {
51874       {
51875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51876       };
51877     } catch (...) {
51878       {
51879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51880       };
51881     }
51882   }
51883 }
51884
51885
51886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51887   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51888   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51889
51890   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51891   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51892   {
51893     try {
51894       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51895     } catch (std::out_of_range& e) {
51896       {
51897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51898       };
51899     } catch (std::exception& e) {
51900       {
51901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51902       };
51903     } catch (...) {
51904       {
51905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51906       };
51907     }
51908   }
51909 }
51910
51911
51912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51913   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51914   Dali::Actor arg2 ;
51915   Dali::TapGesture *arg3 = 0 ;
51916   Dali::Actor *argp2 ;
51917
51918   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51919   argp2 = (Dali::Actor *)jarg2;
51920   if (!argp2) {
51921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51922     return ;
51923   }
51924   arg2 = *argp2;
51925   arg3 = (Dali::TapGesture *)jarg3;
51926   if (!arg3) {
51927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
51928     return ;
51929   }
51930   {
51931     try {
51932       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
51933     } catch (std::out_of_range& e) {
51934       {
51935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51936       };
51937     } catch (std::exception& e) {
51938       {
51939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51940       };
51941     } catch (...) {
51942       {
51943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51944       };
51945     }
51946   }
51947 }
51948
51949
51950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
51951   void * jresult ;
51952   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
51953
51954   {
51955     try {
51956       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
51957     } catch (std::out_of_range& e) {
51958       {
51959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51960       };
51961     } catch (std::exception& e) {
51962       {
51963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51964       };
51965     } catch (...) {
51966       {
51967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51968       };
51969     }
51970   }
51971   jresult = (void *)result;
51972   return jresult;
51973 }
51974
51975
51976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
51977   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51978
51979   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51980   {
51981     try {
51982       delete arg1;
51983     } catch (std::out_of_range& e) {
51984       {
51985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51986       };
51987     } catch (std::exception& e) {
51988       {
51989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51990       };
51991     } catch (...) {
51992       {
51993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51994       };
51995     }
51996   }
51997 }
51998
51999
52000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52001   unsigned int jresult ;
52002   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52003   bool result;
52004
52005   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52006   {
52007     try {
52008       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52009     } catch (std::out_of_range& e) {
52010       {
52011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52012       };
52013     } catch (std::exception& e) {
52014       {
52015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52016       };
52017     } catch (...) {
52018       {
52019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52020       };
52021     }
52022   }
52023   jresult = result;
52024   return jresult;
52025 }
52026
52027
52028 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52029   unsigned long jresult ;
52030   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52031   std::size_t result;
52032
52033   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52034   {
52035     try {
52036       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52037     } catch (std::out_of_range& e) {
52038       {
52039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52040       };
52041     } catch (std::exception& e) {
52042       {
52043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52044       };
52045     } catch (...) {
52046       {
52047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52048       };
52049     }
52050   }
52051   jresult = (unsigned long)result;
52052   return jresult;
52053 }
52054
52055
52056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52057   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52058   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52059
52060   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52061   arg2 = (void (*)(Dali::Animation &))jarg2;
52062   {
52063     try {
52064       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52065     } catch (std::out_of_range& e) {
52066       {
52067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52068       };
52069     } catch (std::exception& e) {
52070       {
52071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52072       };
52073     } catch (...) {
52074       {
52075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52076       };
52077     }
52078   }
52079 }
52080
52081
52082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52083   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52084   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52085
52086   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52087   arg2 = (void (*)(Dali::Animation &))jarg2;
52088   {
52089     try {
52090       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52091     } catch (std::out_of_range& e) {
52092       {
52093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52094       };
52095     } catch (std::exception& e) {
52096       {
52097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52098       };
52099     } catch (...) {
52100       {
52101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52102       };
52103     }
52104   }
52105 }
52106
52107
52108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52109   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52110   Dali::Animation *arg2 = 0 ;
52111
52112   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52113   arg2 = (Dali::Animation *)jarg2;
52114   if (!arg2) {
52115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52116     return ;
52117   }
52118   {
52119     try {
52120       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52121     } catch (std::out_of_range& e) {
52122       {
52123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52124       };
52125     } catch (std::exception& e) {
52126       {
52127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52128       };
52129     } catch (...) {
52130       {
52131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52132       };
52133     }
52134   }
52135 }
52136
52137
52138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52139   void * jresult ;
52140   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52141
52142   {
52143     try {
52144       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52145     } catch (std::out_of_range& e) {
52146       {
52147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52148       };
52149     } catch (std::exception& e) {
52150       {
52151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52152       };
52153     } catch (...) {
52154       {
52155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52156       };
52157     }
52158   }
52159   jresult = (void *)result;
52160   return jresult;
52161 }
52162
52163
52164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52165   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52166
52167   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52168   {
52169     try {
52170       delete arg1;
52171     } catch (std::out_of_range& e) {
52172       {
52173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52174       };
52175     } catch (std::exception& e) {
52176       {
52177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52178       };
52179     } catch (...) {
52180       {
52181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52182       };
52183     }
52184   }
52185 }
52186
52187
52188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52189   unsigned int jresult ;
52190   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52191   bool result;
52192
52193   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52194   {
52195     try {
52196       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52197     } catch (std::out_of_range& e) {
52198       {
52199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52200       };
52201     } catch (std::exception& e) {
52202       {
52203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52204       };
52205     } catch (...) {
52206       {
52207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52208       };
52209     }
52210   }
52211   jresult = result;
52212   return jresult;
52213 }
52214
52215
52216 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52217   unsigned long jresult ;
52218   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52219   std::size_t result;
52220
52221   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52222   {
52223     try {
52224       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52225     } catch (std::out_of_range& e) {
52226       {
52227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52228       };
52229     } catch (std::exception& e) {
52230       {
52231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52232       };
52233     } catch (...) {
52234       {
52235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52236       };
52237     }
52238   }
52239   jresult = (unsigned long)result;
52240   return jresult;
52241 }
52242
52243
52244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52245   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52246   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52247
52248   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52249   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52250   {
52251     try {
52252       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52253     } catch (std::out_of_range& e) {
52254       {
52255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52256       };
52257     } catch (std::exception& e) {
52258       {
52259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52260       };
52261     } catch (...) {
52262       {
52263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52264       };
52265     }
52266   }
52267 }
52268
52269
52270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52271   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52272   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52273
52274   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52275   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52276   {
52277     try {
52278       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52279     } catch (std::out_of_range& e) {
52280       {
52281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52282       };
52283     } catch (std::exception& e) {
52284       {
52285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52286       };
52287     } catch (...) {
52288       {
52289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52290       };
52291     }
52292   }
52293 }
52294
52295
52296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52297   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52298   Dali::ResourceImage arg2 ;
52299   Dali::ResourceImage *argp2 ;
52300
52301   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52302   argp2 = (Dali::ResourceImage *)jarg2;
52303   if (!argp2) {
52304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52305     return ;
52306   }
52307   arg2 = *argp2;
52308   {
52309     try {
52310       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52311     } catch (std::out_of_range& e) {
52312       {
52313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52314       };
52315     } catch (std::exception& e) {
52316       {
52317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52318       };
52319     } catch (...) {
52320       {
52321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52322       };
52323     }
52324   }
52325 }
52326
52327
52328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52329   void * jresult ;
52330   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52331
52332   {
52333     try {
52334       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52335     } catch (std::out_of_range& e) {
52336       {
52337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52338       };
52339     } catch (std::exception& e) {
52340       {
52341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52342       };
52343     } catch (...) {
52344       {
52345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52346       };
52347     }
52348   }
52349   jresult = (void *)result;
52350   return jresult;
52351 }
52352
52353
52354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52355   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52356
52357   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52358   {
52359     try {
52360       delete arg1;
52361     } catch (std::out_of_range& e) {
52362       {
52363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52364       };
52365     } catch (std::exception& e) {
52366       {
52367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52368       };
52369     } catch (...) {
52370       {
52371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52372       };
52373     }
52374   }
52375 }
52376
52377
52378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52379   void * jresult ;
52380   Dali::Timer *result = 0 ;
52381
52382   {
52383     try {
52384       result = (Dali::Timer *)new Dali::Timer();
52385     } catch (std::out_of_range& e) {
52386       {
52387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52388       };
52389     } catch (std::exception& e) {
52390       {
52391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52392       };
52393     } catch (...) {
52394       {
52395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52396       };
52397     }
52398   }
52399   jresult = (void *)result;
52400   return jresult;
52401 }
52402
52403
52404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52405   void * jresult ;
52406   unsigned int arg1 ;
52407   Dali::Timer result;
52408
52409   arg1 = (unsigned int)jarg1;
52410   {
52411     try {
52412       result = Dali::Timer::New(arg1);
52413     } catch (std::out_of_range& e) {
52414       {
52415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52416       };
52417     } catch (std::exception& e) {
52418       {
52419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52420       };
52421     } catch (...) {
52422       {
52423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52424       };
52425     }
52426   }
52427   jresult = new Dali::Timer((const Dali::Timer &)result);
52428   return jresult;
52429 }
52430
52431
52432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52433   void * jresult ;
52434   Dali::Timer *arg1 = 0 ;
52435   Dali::Timer *result = 0 ;
52436
52437   arg1 = (Dali::Timer *)jarg1;
52438   if (!arg1) {
52439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52440     return 0;
52441   }
52442   {
52443     try {
52444       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52445     } catch (std::out_of_range& e) {
52446       {
52447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52448       };
52449     } catch (std::exception& e) {
52450       {
52451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52452       };
52453     } catch (...) {
52454       {
52455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52456       };
52457     }
52458   }
52459   jresult = (void *)result;
52460   return jresult;
52461 }
52462
52463
52464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52465   void * jresult ;
52466   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52467   Dali::Timer *arg2 = 0 ;
52468   Dali::Timer *result = 0 ;
52469
52470   arg1 = (Dali::Timer *)jarg1;
52471   arg2 = (Dali::Timer *)jarg2;
52472   if (!arg2) {
52473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52474     return 0;
52475   }
52476   {
52477     try {
52478       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52479     } catch (std::out_of_range& e) {
52480       {
52481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52482       };
52483     } catch (std::exception& e) {
52484       {
52485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52486       };
52487     } catch (...) {
52488       {
52489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52490       };
52491     }
52492   }
52493   jresult = (void *)result;
52494   return jresult;
52495 }
52496
52497
52498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52499   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52500
52501   arg1 = (Dali::Timer *)jarg1;
52502   {
52503     try {
52504       delete arg1;
52505     } catch (std::out_of_range& e) {
52506       {
52507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52508       };
52509     } catch (std::exception& e) {
52510       {
52511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52512       };
52513     } catch (...) {
52514       {
52515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52516       };
52517     }
52518   }
52519 }
52520
52521
52522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52523   void * jresult ;
52524   Dali::BaseHandle arg1 ;
52525   Dali::BaseHandle *argp1 ;
52526   Dali::Timer result;
52527
52528   argp1 = (Dali::BaseHandle *)jarg1;
52529   if (!argp1) {
52530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52531     return 0;
52532   }
52533   arg1 = *argp1;
52534   {
52535     try {
52536       result = Dali::Timer::DownCast(arg1);
52537     } catch (std::out_of_range& e) {
52538       {
52539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52540       };
52541     } catch (std::exception& e) {
52542       {
52543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52544       };
52545     } catch (...) {
52546       {
52547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52548       };
52549     }
52550   }
52551   jresult = new Dali::Timer((const Dali::Timer &)result);
52552   return jresult;
52553 }
52554
52555
52556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52557   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52558
52559   arg1 = (Dali::Timer *)jarg1;
52560   {
52561     try {
52562       (arg1)->Start();
52563     } catch (std::out_of_range& e) {
52564       {
52565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52566       };
52567     } catch (std::exception& e) {
52568       {
52569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52570       };
52571     } catch (...) {
52572       {
52573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52574       };
52575     }
52576   }
52577 }
52578
52579
52580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
52581   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52582
52583   arg1 = (Dali::Timer *)jarg1;
52584   {
52585     try {
52586       (arg1)->Stop();
52587     } catch (std::out_of_range& e) {
52588       {
52589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52590       };
52591     } catch (std::exception& e) {
52592       {
52593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52594       };
52595     } catch (...) {
52596       {
52597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52598       };
52599     }
52600   }
52601 }
52602
52603
52604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
52605   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52606   unsigned int arg2 ;
52607
52608   arg1 = (Dali::Timer *)jarg1;
52609   arg2 = (unsigned int)jarg2;
52610   {
52611     try {
52612       (arg1)->SetInterval(arg2);
52613     } catch (std::out_of_range& e) {
52614       {
52615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52616       };
52617     } catch (std::exception& e) {
52618       {
52619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52620       };
52621     } catch (...) {
52622       {
52623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52624       };
52625     }
52626   }
52627 }
52628
52629
52630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
52631   unsigned int jresult ;
52632   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52633   unsigned int result;
52634
52635   arg1 = (Dali::Timer *)jarg1;
52636   {
52637     try {
52638       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
52639     } catch (std::out_of_range& e) {
52640       {
52641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52642       };
52643     } catch (std::exception& e) {
52644       {
52645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52646       };
52647     } catch (...) {
52648       {
52649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52650       };
52651     }
52652   }
52653   jresult = result;
52654   return jresult;
52655 }
52656
52657
52658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
52659   unsigned int jresult ;
52660   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52661   bool result;
52662
52663   arg1 = (Dali::Timer *)jarg1;
52664   {
52665     try {
52666       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
52667     } catch (std::out_of_range& e) {
52668       {
52669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52670       };
52671     } catch (std::exception& e) {
52672       {
52673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52674       };
52675     } catch (...) {
52676       {
52677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52678       };
52679     }
52680   }
52681   jresult = result;
52682   return jresult;
52683 }
52684
52685
52686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
52687   void * jresult ;
52688   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52689   Dali::Timer::TimerSignalType *result = 0 ;
52690
52691   arg1 = (Dali::Timer *)jarg1;
52692   {
52693     try {
52694       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
52695     } catch (std::out_of_range& e) {
52696       {
52697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52698       };
52699     } catch (std::exception& e) {
52700       {
52701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52702       };
52703     } catch (...) {
52704       {
52705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52706       };
52707     }
52708   }
52709   jresult = (void *)result;
52710   return jresult;
52711 }
52712
52713
52714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
52715   void * jresult ;
52716   Dali::DragAndDropDetector *result = 0 ;
52717
52718   {
52719     try {
52720       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
52721     } catch (std::out_of_range& e) {
52722       {
52723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52724       };
52725     } catch (std::exception& e) {
52726       {
52727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52728       };
52729     } catch (...) {
52730       {
52731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52732       };
52733     }
52734   }
52735   jresult = (void *)result;
52736   return jresult;
52737 }
52738
52739
52740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
52741   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52742
52743   arg1 = (Dali::DragAndDropDetector *)jarg1;
52744   {
52745     try {
52746       delete arg1;
52747     } catch (std::out_of_range& e) {
52748       {
52749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52750       };
52751     } catch (std::exception& e) {
52752       {
52753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52754       };
52755     } catch (...) {
52756       {
52757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52758       };
52759     }
52760   }
52761 }
52762
52763
52764 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
52765   char * jresult ;
52766   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52767   std::string *result = 0 ;
52768
52769   arg1 = (Dali::DragAndDropDetector *)jarg1;
52770   {
52771     try {
52772       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
52773     } catch (std::out_of_range& e) {
52774       {
52775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52776       };
52777     } catch (std::exception& e) {
52778       {
52779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52780       };
52781     } catch (...) {
52782       {
52783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52784       };
52785     }
52786   }
52787   jresult = SWIG_csharp_string_callback(result->c_str());
52788   return jresult;
52789 }
52790
52791
52792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
52793   void * jresult ;
52794   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52795   Dali::Vector2 result;
52796
52797   arg1 = (Dali::DragAndDropDetector *)jarg1;
52798   {
52799     try {
52800       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
52801     } catch (std::out_of_range& e) {
52802       {
52803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52804       };
52805     } catch (std::exception& e) {
52806       {
52807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52808       };
52809     } catch (...) {
52810       {
52811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52812       };
52813     }
52814   }
52815   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
52816   return jresult;
52817 }
52818
52819
52820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
52821   void * jresult ;
52822   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52823   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52824
52825   arg1 = (Dali::DragAndDropDetector *)jarg1;
52826   {
52827     try {
52828       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
52829     } catch (std::out_of_range& e) {
52830       {
52831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52832       };
52833     } catch (std::exception& e) {
52834       {
52835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52836       };
52837     } catch (...) {
52838       {
52839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52840       };
52841     }
52842   }
52843   jresult = (void *)result;
52844   return jresult;
52845 }
52846
52847
52848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
52849   void * jresult ;
52850   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52851   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52852
52853   arg1 = (Dali::DragAndDropDetector *)jarg1;
52854   {
52855     try {
52856       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
52857     } catch (std::out_of_range& e) {
52858       {
52859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52860       };
52861     } catch (std::exception& e) {
52862       {
52863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52864       };
52865     } catch (...) {
52866       {
52867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52868       };
52869     }
52870   }
52871   jresult = (void *)result;
52872   return jresult;
52873 }
52874
52875
52876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
52877   void * jresult ;
52878   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52879   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52880
52881   arg1 = (Dali::DragAndDropDetector *)jarg1;
52882   {
52883     try {
52884       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
52885     } catch (std::out_of_range& e) {
52886       {
52887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52888       };
52889     } catch (std::exception& e) {
52890       {
52891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52892       };
52893     } catch (...) {
52894       {
52895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52896       };
52897     }
52898   }
52899   jresult = (void *)result;
52900   return jresult;
52901 }
52902
52903
52904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
52905   void * jresult ;
52906   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52907   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52908
52909   arg1 = (Dali::DragAndDropDetector *)jarg1;
52910   {
52911     try {
52912       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
52913     } catch (std::out_of_range& e) {
52914       {
52915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52916       };
52917     } catch (std::exception& e) {
52918       {
52919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52920       };
52921     } catch (...) {
52922       {
52923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52924       };
52925     }
52926   }
52927   jresult = (void *)result;
52928   return jresult;
52929 }
52930
52931
52932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
52933   void * jresult ;
52934   Dali::ApplicationExtensions *result = 0 ;
52935
52936   {
52937     try {
52938       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
52939     } catch (std::out_of_range& e) {
52940       {
52941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52942       };
52943     } catch (std::exception& e) {
52944       {
52945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52946       };
52947     } catch (...) {
52948       {
52949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52950       };
52951     }
52952   }
52953   jresult = (void *)result;
52954   return jresult;
52955 }
52956
52957
52958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
52959   void * jresult ;
52960   Dali::Application *arg1 = (Dali::Application *) 0 ;
52961   Dali::ApplicationExtensions *result = 0 ;
52962
52963   arg1 = (Dali::Application *)jarg1;
52964   {
52965     try {
52966       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
52967     } catch (std::out_of_range& e) {
52968       {
52969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52970       };
52971     } catch (std::exception& e) {
52972       {
52973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52974       };
52975     } catch (...) {
52976       {
52977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52978       };
52979     }
52980   }
52981   jresult = (void *)result;
52982   return jresult;
52983 }
52984
52985
52986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
52987   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
52988
52989   arg1 = (Dali::ApplicationExtensions *)jarg1;
52990   {
52991     try {
52992       delete arg1;
52993     } catch (std::out_of_range& e) {
52994       {
52995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52996       };
52997     } catch (std::exception& e) {
52998       {
52999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53000       };
53001     } catch (...) {
53002       {
53003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53004       };
53005     }
53006   }
53007 }
53008
53009
53010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53011   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53012
53013   arg1 = (Dali::ApplicationExtensions *)jarg1;
53014   {
53015     try {
53016       (arg1)->Init();
53017     } catch (std::out_of_range& e) {
53018       {
53019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53020       };
53021     } catch (std::exception& e) {
53022       {
53023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53024       };
53025     } catch (...) {
53026       {
53027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53028       };
53029     }
53030   }
53031 }
53032
53033
53034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53035   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53036
53037   arg1 = (Dali::ApplicationExtensions *)jarg1;
53038   {
53039     try {
53040       (arg1)->Terminate();
53041     } catch (std::out_of_range& e) {
53042       {
53043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53044       };
53045     } catch (std::exception& e) {
53046       {
53047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53048       };
53049     } catch (...) {
53050       {
53051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53052       };
53053     }
53054   }
53055 }
53056
53057
53058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53059   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53060
53061   arg1 = (Dali::ApplicationExtensions *)jarg1;
53062   {
53063     try {
53064       (arg1)->Pause();
53065     } catch (std::out_of_range& e) {
53066       {
53067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53068       };
53069     } catch (std::exception& e) {
53070       {
53071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53072       };
53073     } catch (...) {
53074       {
53075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53076       };
53077     }
53078   }
53079 }
53080
53081
53082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53083   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53084
53085   arg1 = (Dali::ApplicationExtensions *)jarg1;
53086   {
53087     try {
53088       (arg1)->Resume();
53089     } catch (std::out_of_range& e) {
53090       {
53091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53092       };
53093     } catch (std::exception& e) {
53094       {
53095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53096       };
53097     } catch (...) {
53098       {
53099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53100       };
53101     }
53102   }
53103 }
53104
53105
53106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53107   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53108
53109   arg1 = (Dali::ApplicationExtensions *)jarg1;
53110   {
53111     try {
53112       (arg1)->LanguageChange();
53113     } catch (std::out_of_range& e) {
53114       {
53115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53116       };
53117     } catch (std::exception& e) {
53118       {
53119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53120       };
53121     } catch (...) {
53122       {
53123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53124       };
53125     }
53126   }
53127 }
53128
53129
53130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53131   void * jresult ;
53132   Dali::PositionSize arg1 ;
53133   std::string *arg2 = 0 ;
53134   bool arg3 ;
53135   Dali::PositionSize *argp1 ;
53136   Dali::Window result;
53137
53138   argp1 = (Dali::PositionSize *)jarg1;
53139   if (!argp1) {
53140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53141     return 0;
53142   }
53143   arg1 = *argp1;
53144   if (!jarg2) {
53145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53146     return 0;
53147   }
53148   std::string arg2_str(jarg2);
53149   arg2 = &arg2_str;
53150   arg3 = jarg3 ? true : false;
53151   {
53152     try {
53153       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53154     } catch (std::out_of_range& e) {
53155       {
53156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53157       };
53158     } catch (std::exception& e) {
53159       {
53160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53161       };
53162     } catch (...) {
53163       {
53164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53165       };
53166     }
53167   }
53168   jresult = new Dali::Window((const Dali::Window &)result);
53169
53170   //argout typemap for const std::string&
53171
53172   return jresult;
53173 }
53174
53175
53176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53177   void * jresult ;
53178   Dali::PositionSize arg1 ;
53179   std::string *arg2 = 0 ;
53180   Dali::PositionSize *argp1 ;
53181   Dali::Window result;
53182
53183   argp1 = (Dali::PositionSize *)jarg1;
53184   if (!argp1) {
53185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53186     return 0;
53187   }
53188   arg1 = *argp1;
53189   if (!jarg2) {
53190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53191     return 0;
53192   }
53193   std::string arg2_str(jarg2);
53194   arg2 = &arg2_str;
53195   {
53196     try {
53197       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53198     } catch (std::out_of_range& e) {
53199       {
53200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53201       };
53202     } catch (std::exception& e) {
53203       {
53204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53205       };
53206     } catch (...) {
53207       {
53208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53209       };
53210     }
53211   }
53212   jresult = new Dali::Window((const Dali::Window &)result);
53213
53214   //argout typemap for const std::string&
53215
53216   return jresult;
53217 }
53218
53219
53220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53221   void * jresult ;
53222   Dali::PositionSize arg1 ;
53223   std::string *arg2 = 0 ;
53224   std::string *arg3 = 0 ;
53225   bool arg4 ;
53226   Dali::PositionSize *argp1 ;
53227   Dali::Window result;
53228
53229   argp1 = (Dali::PositionSize *)jarg1;
53230   if (!argp1) {
53231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53232     return 0;
53233   }
53234   arg1 = *argp1;
53235   if (!jarg2) {
53236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53237     return 0;
53238   }
53239   std::string arg2_str(jarg2);
53240   arg2 = &arg2_str;
53241   if (!jarg3) {
53242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53243     return 0;
53244   }
53245   std::string arg3_str(jarg3);
53246   arg3 = &arg3_str;
53247   arg4 = jarg4 ? true : false;
53248   {
53249     try {
53250       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53251     } catch (std::out_of_range& e) {
53252       {
53253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53254       };
53255     } catch (std::exception& e) {
53256       {
53257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53258       };
53259     } catch (...) {
53260       {
53261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53262       };
53263     }
53264   }
53265   jresult = new Dali::Window((const Dali::Window &)result);
53266
53267   //argout typemap for const std::string&
53268
53269
53270   //argout typemap for const std::string&
53271
53272   return jresult;
53273 }
53274
53275
53276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53277   void * jresult ;
53278   Dali::PositionSize arg1 ;
53279   std::string *arg2 = 0 ;
53280   std::string *arg3 = 0 ;
53281   Dali::PositionSize *argp1 ;
53282   Dali::Window result;
53283
53284   argp1 = (Dali::PositionSize *)jarg1;
53285   if (!argp1) {
53286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53287     return 0;
53288   }
53289   arg1 = *argp1;
53290   if (!jarg2) {
53291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53292     return 0;
53293   }
53294   std::string arg2_str(jarg2);
53295   arg2 = &arg2_str;
53296   if (!jarg3) {
53297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53298     return 0;
53299   }
53300   std::string arg3_str(jarg3);
53301   arg3 = &arg3_str;
53302   {
53303     try {
53304       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53305     } catch (std::out_of_range& e) {
53306       {
53307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53308       };
53309     } catch (std::exception& e) {
53310       {
53311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53312       };
53313     } catch (...) {
53314       {
53315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53316       };
53317     }
53318   }
53319   jresult = new Dali::Window((const Dali::Window &)result);
53320
53321   //argout typemap for const std::string&
53322
53323
53324   //argout typemap for const std::string&
53325
53326   return jresult;
53327 }
53328
53329
53330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53331   void * jresult ;
53332   Dali::Window *result = 0 ;
53333
53334   {
53335     try {
53336       result = (Dali::Window *)new Dali::Window();
53337     } catch (std::out_of_range& e) {
53338       {
53339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53340       };
53341     } catch (std::exception& e) {
53342       {
53343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53344       };
53345     } catch (...) {
53346       {
53347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53348       };
53349     }
53350   }
53351   jresult = (void *)result;
53352   return jresult;
53353 }
53354
53355
53356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53357   Dali::Window *arg1 = (Dali::Window *) 0 ;
53358
53359   arg1 = (Dali::Window *)jarg1;
53360   {
53361     try {
53362       delete arg1;
53363     } catch (std::out_of_range& e) {
53364       {
53365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53366       };
53367     } catch (std::exception& e) {
53368       {
53369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53370       };
53371     } catch (...) {
53372       {
53373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53374       };
53375     }
53376   }
53377 }
53378
53379
53380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53381   void * jresult ;
53382   Dali::Window *arg1 = 0 ;
53383   Dali::Window *result = 0 ;
53384
53385   arg1 = (Dali::Window *)jarg1;
53386   if (!arg1) {
53387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53388     return 0;
53389   }
53390   {
53391     try {
53392       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53393     } catch (std::out_of_range& e) {
53394       {
53395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53396       };
53397     } catch (std::exception& e) {
53398       {
53399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53400       };
53401     } catch (...) {
53402       {
53403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53404       };
53405     }
53406   }
53407   jresult = (void *)result;
53408   return jresult;
53409 }
53410
53411
53412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53413   void * jresult ;
53414   Dali::Window *arg1 = (Dali::Window *) 0 ;
53415   Dali::Window *arg2 = 0 ;
53416   Dali::Window *result = 0 ;
53417
53418   arg1 = (Dali::Window *)jarg1;
53419   arg2 = (Dali::Window *)jarg2;
53420   if (!arg2) {
53421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53422     return 0;
53423   }
53424   {
53425     try {
53426       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53427     } catch (std::out_of_range& e) {
53428       {
53429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53430       };
53431     } catch (std::exception& e) {
53432       {
53433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53434       };
53435     } catch (...) {
53436       {
53437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53438       };
53439     }
53440   }
53441   jresult = (void *)result;
53442   return jresult;
53443 }
53444
53445
53446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53447   Dali::Window *arg1 = (Dali::Window *) 0 ;
53448   Dali::Window::IndicatorVisibleMode arg2 ;
53449
53450   arg1 = (Dali::Window *)jarg1;
53451   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53452   {
53453     try {
53454       (arg1)->ShowIndicator(arg2);
53455     } catch (std::out_of_range& e) {
53456       {
53457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53458       };
53459     } catch (std::exception& e) {
53460       {
53461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53462       };
53463     } catch (...) {
53464       {
53465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53466       };
53467     }
53468   }
53469 }
53470
53471
53472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53473   Dali::Window *arg1 = (Dali::Window *) 0 ;
53474   Dali::Window::IndicatorBgOpacity arg2 ;
53475
53476   arg1 = (Dali::Window *)jarg1;
53477   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53478   {
53479     try {
53480       (arg1)->SetIndicatorBgOpacity(arg2);
53481     } catch (std::out_of_range& e) {
53482       {
53483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53484       };
53485     } catch (std::exception& e) {
53486       {
53487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53488       };
53489     } catch (...) {
53490       {
53491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53492       };
53493     }
53494   }
53495 }
53496
53497
53498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
53499   Dali::Window *arg1 = (Dali::Window *) 0 ;
53500   Dali::Window::WindowOrientation arg2 ;
53501
53502   arg1 = (Dali::Window *)jarg1;
53503   arg2 = (Dali::Window::WindowOrientation)jarg2;
53504   {
53505     try {
53506       (arg1)->RotateIndicator(arg2);
53507     } catch (std::out_of_range& e) {
53508       {
53509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53510       };
53511     } catch (std::exception& e) {
53512       {
53513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53514       };
53515     } catch (...) {
53516       {
53517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53518       };
53519     }
53520   }
53521 }
53522
53523
53524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
53525   Dali::Window *arg1 = (Dali::Window *) 0 ;
53526   std::string arg2 ;
53527   std::string arg3 ;
53528
53529   arg1 = (Dali::Window *)jarg1;
53530   if (!jarg2) {
53531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53532     return ;
53533   }
53534   (&arg2)->assign(jarg2);
53535   if (!jarg3) {
53536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53537     return ;
53538   }
53539   (&arg3)->assign(jarg3);
53540   {
53541     try {
53542       (arg1)->SetClass(arg2,arg3);
53543     } catch (std::out_of_range& e) {
53544       {
53545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53546       };
53547     } catch (std::exception& e) {
53548       {
53549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53550       };
53551     } catch (...) {
53552       {
53553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53554       };
53555     }
53556   }
53557 }
53558
53559
53560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
53561   Dali::Window *arg1 = (Dali::Window *) 0 ;
53562
53563   arg1 = (Dali::Window *)jarg1;
53564   {
53565     try {
53566       (arg1)->Raise();
53567     } catch (std::out_of_range& e) {
53568       {
53569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53570       };
53571     } catch (std::exception& e) {
53572       {
53573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53574       };
53575     } catch (...) {
53576       {
53577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53578       };
53579     }
53580   }
53581 }
53582
53583
53584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
53585   Dali::Window *arg1 = (Dali::Window *) 0 ;
53586
53587   arg1 = (Dali::Window *)jarg1;
53588   {
53589     try {
53590       (arg1)->Lower();
53591     } catch (std::out_of_range& e) {
53592       {
53593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53594       };
53595     } catch (std::exception& e) {
53596       {
53597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53598       };
53599     } catch (...) {
53600       {
53601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53602       };
53603     }
53604   }
53605 }
53606
53607
53608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
53609   Dali::Window *arg1 = (Dali::Window *) 0 ;
53610
53611   arg1 = (Dali::Window *)jarg1;
53612   {
53613     try {
53614       (arg1)->Activate();
53615     } catch (std::out_of_range& e) {
53616       {
53617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53618       };
53619     } catch (std::exception& e) {
53620       {
53621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53622       };
53623     } catch (...) {
53624       {
53625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53626       };
53627     }
53628   }
53629 }
53630
53631
53632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
53633   Dali::Window *arg1 = (Dali::Window *) 0 ;
53634   Dali::Window::WindowOrientation arg2 ;
53635
53636   arg1 = (Dali::Window *)jarg1;
53637   arg2 = (Dali::Window::WindowOrientation)jarg2;
53638   {
53639     try {
53640       (arg1)->AddAvailableOrientation(arg2);
53641     } catch (std::out_of_range& e) {
53642       {
53643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53644       };
53645     } catch (std::exception& e) {
53646       {
53647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53648       };
53649     } catch (...) {
53650       {
53651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53652       };
53653     }
53654   }
53655 }
53656
53657
53658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
53659   Dali::Window *arg1 = (Dali::Window *) 0 ;
53660   Dali::Window::WindowOrientation arg2 ;
53661
53662   arg1 = (Dali::Window *)jarg1;
53663   arg2 = (Dali::Window::WindowOrientation)jarg2;
53664   {
53665     try {
53666       (arg1)->RemoveAvailableOrientation(arg2);
53667     } catch (std::out_of_range& e) {
53668       {
53669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53670       };
53671     } catch (std::exception& e) {
53672       {
53673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53674       };
53675     } catch (...) {
53676       {
53677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53678       };
53679     }
53680   }
53681 }
53682
53683
53684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
53685   Dali::Window *arg1 = (Dali::Window *) 0 ;
53686   Dali::Window::WindowOrientation arg2 ;
53687
53688   arg1 = (Dali::Window *)jarg1;
53689   arg2 = (Dali::Window::WindowOrientation)jarg2;
53690   {
53691     try {
53692       (arg1)->SetPreferredOrientation(arg2);
53693     } catch (std::out_of_range& e) {
53694       {
53695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53696       };
53697     } catch (std::exception& e) {
53698       {
53699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53700       };
53701     } catch (...) {
53702       {
53703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53704       };
53705     }
53706   }
53707 }
53708
53709
53710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
53711   int jresult ;
53712   Dali::Window *arg1 = (Dali::Window *) 0 ;
53713   Dali::Window::WindowOrientation result;
53714
53715   arg1 = (Dali::Window *)jarg1;
53716   {
53717     try {
53718       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
53719     } catch (std::out_of_range& e) {
53720       {
53721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53722       };
53723     } catch (std::exception& e) {
53724       {
53725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53726       };
53727     } catch (...) {
53728       {
53729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53730       };
53731     }
53732   }
53733   jresult = (int)result;
53734   return jresult;
53735 }
53736
53737
53738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
53739   void * jresult ;
53740   Dali::Window *arg1 = (Dali::Window *) 0 ;
53741   Dali::DragAndDropDetector result;
53742
53743   arg1 = (Dali::Window *)jarg1;
53744   {
53745     try {
53746       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
53747     } catch (std::out_of_range& e) {
53748       {
53749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53750       };
53751     } catch (std::exception& e) {
53752       {
53753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53754       };
53755     } catch (...) {
53756       {
53757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53758       };
53759     }
53760   }
53761   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
53762   return jresult;
53763 }
53764
53765
53766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
53767   void * jresult ;
53768   Dali::Window *arg1 = (Dali::Window *) 0 ;
53769   Dali::Any result;
53770
53771   arg1 = (Dali::Window *)jarg1;
53772   {
53773     try {
53774       result = ((Dali::Window const *)arg1)->GetNativeHandle();
53775     } catch (std::out_of_range& e) {
53776       {
53777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53778       };
53779     } catch (std::exception& e) {
53780       {
53781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53782       };
53783     } catch (...) {
53784       {
53785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53786       };
53787     }
53788   }
53789   jresult = new Dali::Any((const Dali::Any &)result);
53790   return jresult;
53791 }
53792
53793
53794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_IndicatorVisibilityChangedSignal(void * jarg1) {
53795   void * jresult ;
53796   Dali::Window *arg1 = (Dali::Window *) 0 ;
53797   Dali::Window::IndicatorSignalType *result = 0 ;
53798
53799   arg1 = (Dali::Window *)jarg1;
53800   {
53801     try {
53802       result = (Dali::Window::IndicatorSignalType *) &(arg1)->IndicatorVisibilityChangedSignal();
53803     } catch (std::out_of_range& e) {
53804       {
53805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53806       };
53807     } catch (std::exception& e) {
53808       {
53809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53810       };
53811     } catch (...) {
53812       {
53813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53814       };
53815     }
53816   }
53817   jresult = (void *)result;
53818   return jresult;
53819 }
53820
53821
53822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
53823   void * jresult ;
53824   Dali::Application result;
53825
53826   {
53827     try {
53828       result = Dali::Application::New();
53829     } catch (std::out_of_range& e) {
53830       {
53831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53832       };
53833     } catch (std::exception& e) {
53834       {
53835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53836       };
53837     } catch (...) {
53838       {
53839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53840       };
53841     }
53842   }
53843   jresult = new Dali::Application((const Dali::Application &)result);
53844   return jresult;
53845 }
53846
53847
53848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
53849   void * jresult ;
53850   int *arg1 = (int *) 0 ;
53851   char ***arg2 ;
53852   Dali::Application result;
53853
53854   {
53855     // Todo generate argv data from the C# args
53856     char **array;         // two dimensional array
53857     int numStrings = 1;     // number of strings
53858     int stringLength = 30;      // max string length.
53859     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
53860     argV = array;
53861
53862     // allocate the string data
53863     for( int i=0; i < numStrings; i++)
53864     {
53865       array[i]=(char *)malloc( stringLength * sizeof(char *) );
53866     }
53867     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
53868
53869     strcpy( array[0], "dali-csharp-app");
53870
53871     arg1 = &argC;
53872     arg2 = &argV;
53873   }
53874   {
53875     try {
53876       result = Dali::Application::New(arg1,arg2);
53877     } catch (std::out_of_range& e) {
53878       {
53879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53880       };
53881     } catch (std::exception& e) {
53882       {
53883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53884       };
53885     } catch (...) {
53886       {
53887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53888       };
53889     }
53890   }
53891   jresult = new Dali::Application((const Dali::Application &)result);
53892   return jresult;
53893 }
53894
53895
53896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
53897   void * jresult ;
53898   int *arg1 = (int *) 0 ;
53899   char ***arg2 ;
53900   std::string *arg3 = 0 ;
53901   Dali::Application result;
53902
53903   {
53904     // Todo generate argv data from the C# args
53905     char **array;         // two dimensional array
53906     int numStrings = 1;     // number of strings
53907     int stringLength = 30;      // max string length.
53908     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
53909     argV = array;
53910
53911     // allocate the string data
53912     for( int i=0; i < numStrings; i++)
53913     {
53914       array[i]=(char *)malloc( stringLength * sizeof(char *) );
53915     }
53916     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
53917
53918     strcpy( array[0], "dali-csharp-app");
53919
53920     arg1 = &argC;
53921     arg2 = &argV;
53922   }
53923   if (!jarg3) {
53924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53925     return 0;
53926   }
53927   std::string arg3_str(jarg3);
53928   arg3 = &arg3_str;
53929   {
53930     try {
53931       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
53932     } catch (std::out_of_range& e) {
53933       {
53934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53935       };
53936     } catch (std::exception& e) {
53937       {
53938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53939       };
53940     } catch (...) {
53941       {
53942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53943       };
53944     }
53945   }
53946   jresult = new Dali::Application((const Dali::Application &)result);
53947
53948   //argout typemap for const std::string&
53949
53950   return jresult;
53951 }
53952
53953
53954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
53955   void * jresult ;
53956   int *arg1 = (int *) 0 ;
53957   char ***arg2 ;
53958   std::string *arg3 = 0 ;
53959   Dali::Application::WINDOW_MODE arg4 ;
53960   Dali::Application result;
53961
53962   {
53963     // Todo generate argv data from the C# args
53964     char **array;         // two dimensional array
53965     int numStrings = 1;     // number of strings
53966     int stringLength = 30;      // max string length.
53967     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
53968     argV = array;
53969
53970     // allocate the string data
53971     for( int i=0; i < numStrings; i++)
53972     {
53973       array[i]=(char *)malloc( stringLength * sizeof(char *) );
53974     }
53975     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
53976
53977     strcpy( array[0], "dali-csharp-app");
53978
53979     arg1 = &argC;
53980     arg2 = &argV;
53981   }
53982   if (!jarg3) {
53983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53984     return 0;
53985   }
53986   std::string arg3_str(jarg3);
53987   arg3 = &arg3_str;
53988   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
53989   {
53990     try {
53991       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
53992     } catch (std::out_of_range& e) {
53993       {
53994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53995       };
53996     } catch (std::exception& e) {
53997       {
53998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53999       };
54000     } catch (...) {
54001       {
54002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54003       };
54004     }
54005   }
54006   jresult = new Dali::Application((const Dali::Application &)result);
54007
54008   //argout typemap for const std::string&
54009
54010   return jresult;
54011 }
54012
54013
54014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
54015   void * jresult ;
54016   Dali::Application *result = 0 ;
54017
54018   {
54019     try {
54020       result = (Dali::Application *)new Dali::Application();
54021     } catch (std::out_of_range& e) {
54022       {
54023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54024       };
54025     } catch (std::exception& e) {
54026       {
54027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54028       };
54029     } catch (...) {
54030       {
54031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54032       };
54033     }
54034   }
54035   jresult = (void *)result;
54036   return jresult;
54037 }
54038
54039
54040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
54041   void * jresult ;
54042   Dali::Application *arg1 = 0 ;
54043   Dali::Application *result = 0 ;
54044
54045   arg1 = (Dali::Application *)jarg1;
54046   if (!arg1) {
54047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54048     return 0;
54049   }
54050   {
54051     try {
54052       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
54053     } catch (std::out_of_range& e) {
54054       {
54055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54056       };
54057     } catch (std::exception& e) {
54058       {
54059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54060       };
54061     } catch (...) {
54062       {
54063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54064       };
54065     }
54066   }
54067   jresult = (void *)result;
54068   return jresult;
54069 }
54070
54071
54072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
54073   void * jresult ;
54074   Dali::Application *arg1 = (Dali::Application *) 0 ;
54075   Dali::Application *arg2 = 0 ;
54076   Dali::Application *result = 0 ;
54077
54078   arg1 = (Dali::Application *)jarg1;
54079   arg2 = (Dali::Application *)jarg2;
54080   if (!arg2) {
54081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54082     return 0;
54083   }
54084   {
54085     try {
54086       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
54087     } catch (std::out_of_range& e) {
54088       {
54089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54090       };
54091     } catch (std::exception& e) {
54092       {
54093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54094       };
54095     } catch (...) {
54096       {
54097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54098       };
54099     }
54100   }
54101   jresult = (void *)result;
54102   return jresult;
54103 }
54104
54105
54106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
54107   Dali::Application *arg1 = (Dali::Application *) 0 ;
54108
54109   arg1 = (Dali::Application *)jarg1;
54110   {
54111     try {
54112       delete arg1;
54113     } catch (std::out_of_range& e) {
54114       {
54115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54116       };
54117     } catch (std::exception& e) {
54118       {
54119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54120       };
54121     } catch (...) {
54122       {
54123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54124       };
54125     }
54126   }
54127 }
54128
54129
54130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
54131   Dali::Application *arg1 = (Dali::Application *) 0 ;
54132
54133   arg1 = (Dali::Application *)jarg1;
54134   {
54135     try {
54136       (arg1)->MainLoop();
54137     } catch (std::out_of_range& e) {
54138       {
54139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54140       };
54141     } catch (std::exception& e) {
54142       {
54143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54144       };
54145     } catch (...) {
54146       {
54147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54148       };
54149     }
54150   }
54151 }
54152
54153
54154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
54155   Dali::Application *arg1 = (Dali::Application *) 0 ;
54156   Configuration::ContextLoss arg2 ;
54157   Configuration::ContextLoss *argp2 ;
54158
54159   arg1 = (Dali::Application *)jarg1;
54160   argp2 = (Configuration::ContextLoss *)jarg2;
54161   if (!argp2) {
54162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
54163     return ;
54164   }
54165   arg2 = *argp2;
54166   {
54167     try {
54168       (arg1)->MainLoop(arg2);
54169     } catch (std::out_of_range& e) {
54170       {
54171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54172       };
54173     } catch (std::exception& e) {
54174       {
54175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54176       };
54177     } catch (...) {
54178       {
54179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54180       };
54181     }
54182   }
54183 }
54184
54185
54186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
54187   Dali::Application *arg1 = (Dali::Application *) 0 ;
54188
54189   arg1 = (Dali::Application *)jarg1;
54190   {
54191     try {
54192       (arg1)->Lower();
54193     } catch (std::out_of_range& e) {
54194       {
54195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54196       };
54197     } catch (std::exception& e) {
54198       {
54199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54200       };
54201     } catch (...) {
54202       {
54203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54204       };
54205     }
54206   }
54207 }
54208
54209
54210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
54211   Dali::Application *arg1 = (Dali::Application *) 0 ;
54212
54213   arg1 = (Dali::Application *)jarg1;
54214   {
54215     try {
54216       (arg1)->Quit();
54217     } catch (std::out_of_range& e) {
54218       {
54219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54220       };
54221     } catch (std::exception& e) {
54222       {
54223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54224       };
54225     } catch (...) {
54226       {
54227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54228       };
54229     }
54230   }
54231 }
54232
54233
54234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
54235   unsigned int jresult ;
54236   Dali::Application *arg1 = (Dali::Application *) 0 ;
54237   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
54238   bool result;
54239
54240   arg1 = (Dali::Application *)jarg1;
54241   arg2 = (Dali::CallbackBase *)jarg2;
54242   {
54243     try {
54244       result = (bool)(arg1)->AddIdle(arg2);
54245     } catch (std::out_of_range& e) {
54246       {
54247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54248       };
54249     } catch (std::exception& e) {
54250       {
54251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54252       };
54253     } catch (...) {
54254       {
54255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54256       };
54257     }
54258   }
54259   jresult = result;
54260   return jresult;
54261 }
54262
54263
54264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
54265   void * jresult ;
54266   Dali::Application *arg1 = (Dali::Application *) 0 ;
54267   Dali::Window result;
54268
54269   arg1 = (Dali::Application *)jarg1;
54270   {
54271     try {
54272       result = (arg1)->GetWindow();
54273     } catch (std::out_of_range& e) {
54274       {
54275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54276       };
54277     } catch (std::exception& e) {
54278       {
54279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54280       };
54281     } catch (...) {
54282       {
54283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54284       };
54285     }
54286   }
54287   jresult = new Dali::Window((const Dali::Window &)result);
54288   return jresult;
54289 }
54290
54291
54292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
54293   Dali::Application *arg1 = (Dali::Application *) 0 ;
54294   Dali::PositionSize arg2 ;
54295   std::string *arg3 = 0 ;
54296   Dali::PositionSize *argp2 ;
54297
54298   arg1 = (Dali::Application *)jarg1;
54299   argp2 = (Dali::PositionSize *)jarg2;
54300   if (!argp2) {
54301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54302     return ;
54303   }
54304   arg2 = *argp2;
54305   if (!jarg3) {
54306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54307     return ;
54308   }
54309   std::string arg3_str(jarg3);
54310   arg3 = &arg3_str;
54311   {
54312     try {
54313       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
54314     } catch (std::out_of_range& e) {
54315       {
54316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54317       };
54318     } catch (std::exception& e) {
54319       {
54320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54321       };
54322     } catch (...) {
54323       {
54324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54325       };
54326     }
54327   }
54328
54329   //argout typemap for const std::string&
54330
54331 }
54332
54333
54334 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
54335   char * jresult ;
54336   std::string result;
54337
54338   {
54339     try {
54340       result = Dali::Application::GetResourcePath();
54341     } catch (std::out_of_range& e) {
54342       {
54343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54344       };
54345     } catch (std::exception& e) {
54346       {
54347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54348       };
54349     } catch (...) {
54350       {
54351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54352       };
54353     }
54354   }
54355   jresult = SWIG_csharp_string_callback((&result)->c_str());
54356   return jresult;
54357 }
54358
54359
54360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
54361   Dali::Application *arg1 = (Dali::Application *) 0 ;
54362   Dali::ViewMode arg2 ;
54363
54364   arg1 = (Dali::Application *)jarg1;
54365   arg2 = (Dali::ViewMode)jarg2;
54366   {
54367     try {
54368       (arg1)->SetViewMode(arg2);
54369     } catch (std::out_of_range& e) {
54370       {
54371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54372       };
54373     } catch (std::exception& e) {
54374       {
54375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54376       };
54377     } catch (...) {
54378       {
54379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54380       };
54381     }
54382   }
54383 }
54384
54385
54386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
54387   int jresult ;
54388   Dali::Application *arg1 = (Dali::Application *) 0 ;
54389   Dali::ViewMode result;
54390
54391   arg1 = (Dali::Application *)jarg1;
54392   {
54393     try {
54394       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
54395     } catch (std::out_of_range& e) {
54396       {
54397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54398       };
54399     } catch (std::exception& e) {
54400       {
54401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54402       };
54403     } catch (...) {
54404       {
54405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54406       };
54407     }
54408   }
54409   jresult = (int)result;
54410   return jresult;
54411 }
54412
54413
54414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
54415   Dali::Application *arg1 = (Dali::Application *) 0 ;
54416   float arg2 ;
54417
54418   arg1 = (Dali::Application *)jarg1;
54419   arg2 = (float)jarg2;
54420   {
54421     try {
54422       (arg1)->SetStereoBase(arg2);
54423     } catch (std::out_of_range& e) {
54424       {
54425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54426       };
54427     } catch (std::exception& e) {
54428       {
54429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54430       };
54431     } catch (...) {
54432       {
54433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54434       };
54435     }
54436   }
54437 }
54438
54439
54440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
54441   float jresult ;
54442   Dali::Application *arg1 = (Dali::Application *) 0 ;
54443   float result;
54444
54445   arg1 = (Dali::Application *)jarg1;
54446   {
54447     try {
54448       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
54449     } catch (std::out_of_range& e) {
54450       {
54451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54452       };
54453     } catch (std::exception& e) {
54454       {
54455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54456       };
54457     } catch (...) {
54458       {
54459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54460       };
54461     }
54462   }
54463   jresult = result;
54464   return jresult;
54465 }
54466
54467
54468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
54469   void * jresult ;
54470   Dali::Application *arg1 = (Dali::Application *) 0 ;
54471   Dali::Application::AppSignalType *result = 0 ;
54472
54473   arg1 = (Dali::Application *)jarg1;
54474   {
54475     try {
54476       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
54477     } catch (std::out_of_range& e) {
54478       {
54479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54480       };
54481     } catch (std::exception& e) {
54482       {
54483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54484       };
54485     } catch (...) {
54486       {
54487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54488       };
54489     }
54490   }
54491   jresult = (void *)result;
54492   return jresult;
54493 }
54494
54495
54496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
54497   void * jresult ;
54498   Dali::Application *arg1 = (Dali::Application *) 0 ;
54499   Dali::Application::AppSignalType *result = 0 ;
54500
54501   arg1 = (Dali::Application *)jarg1;
54502   {
54503     try {
54504       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
54505     } catch (std::out_of_range& e) {
54506       {
54507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54508       };
54509     } catch (std::exception& e) {
54510       {
54511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54512       };
54513     } catch (...) {
54514       {
54515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54516       };
54517     }
54518   }
54519   jresult = (void *)result;
54520   return jresult;
54521 }
54522
54523
54524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
54525   void * jresult ;
54526   Dali::Application *arg1 = (Dali::Application *) 0 ;
54527   Dali::Application::AppSignalType *result = 0 ;
54528
54529   arg1 = (Dali::Application *)jarg1;
54530   {
54531     try {
54532       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
54533     } catch (std::out_of_range& e) {
54534       {
54535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54536       };
54537     } catch (std::exception& e) {
54538       {
54539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54540       };
54541     } catch (...) {
54542       {
54543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54544       };
54545     }
54546   }
54547   jresult = (void *)result;
54548   return jresult;
54549 }
54550
54551
54552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
54553   void * jresult ;
54554   Dali::Application *arg1 = (Dali::Application *) 0 ;
54555   Dali::Application::AppSignalType *result = 0 ;
54556
54557   arg1 = (Dali::Application *)jarg1;
54558   {
54559     try {
54560       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
54561     } catch (std::out_of_range& e) {
54562       {
54563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54564       };
54565     } catch (std::exception& e) {
54566       {
54567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54568       };
54569     } catch (...) {
54570       {
54571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54572       };
54573     }
54574   }
54575   jresult = (void *)result;
54576   return jresult;
54577 }
54578
54579
54580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
54581   void * jresult ;
54582   Dali::Application *arg1 = (Dali::Application *) 0 ;
54583   Dali::Application::AppSignalType *result = 0 ;
54584
54585   arg1 = (Dali::Application *)jarg1;
54586   {
54587     try {
54588       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
54589     } catch (std::out_of_range& e) {
54590       {
54591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54592       };
54593     } catch (std::exception& e) {
54594       {
54595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54596       };
54597     } catch (...) {
54598       {
54599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54600       };
54601     }
54602   }
54603   jresult = (void *)result;
54604   return jresult;
54605 }
54606
54607
54608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
54609   void * jresult ;
54610   Dali::Application *arg1 = (Dali::Application *) 0 ;
54611   Dali::Application::AppSignalType *result = 0 ;
54612
54613   arg1 = (Dali::Application *)jarg1;
54614   {
54615     try {
54616       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
54617     } catch (std::out_of_range& e) {
54618       {
54619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54620       };
54621     } catch (std::exception& e) {
54622       {
54623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54624       };
54625     } catch (...) {
54626       {
54627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54628       };
54629     }
54630   }
54631   jresult = (void *)result;
54632   return jresult;
54633 }
54634
54635
54636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
54637   void * jresult ;
54638   Dali::Application *arg1 = (Dali::Application *) 0 ;
54639   Dali::Application::AppControlSignalType *result = 0 ;
54640
54641   arg1 = (Dali::Application *)jarg1;
54642   {
54643     try {
54644       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
54645     } catch (std::out_of_range& e) {
54646       {
54647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54648       };
54649     } catch (std::exception& e) {
54650       {
54651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54652       };
54653     } catch (...) {
54654       {
54655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54656       };
54657     }
54658   }
54659   jresult = (void *)result;
54660   return jresult;
54661 }
54662
54663
54664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
54665   void * jresult ;
54666   Dali::Application *arg1 = (Dali::Application *) 0 ;
54667   Dali::Application::AppSignalType *result = 0 ;
54668
54669   arg1 = (Dali::Application *)jarg1;
54670   {
54671     try {
54672       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
54673     } catch (std::out_of_range& e) {
54674       {
54675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54676       };
54677     } catch (std::exception& e) {
54678       {
54679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54680       };
54681     } catch (...) {
54682       {
54683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54684       };
54685     }
54686   }
54687   jresult = (void *)result;
54688   return jresult;
54689 }
54690
54691
54692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
54693   void * jresult ;
54694   Dali::Application *arg1 = (Dali::Application *) 0 ;
54695   Dali::Application::AppSignalType *result = 0 ;
54696
54697   arg1 = (Dali::Application *)jarg1;
54698   {
54699     try {
54700       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
54701     } catch (std::out_of_range& e) {
54702       {
54703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54704       };
54705     } catch (std::exception& e) {
54706       {
54707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54708       };
54709     } catch (...) {
54710       {
54711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54712       };
54713     }
54714   }
54715   jresult = (void *)result;
54716   return jresult;
54717 }
54718
54719
54720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
54721   void * jresult ;
54722   Dali::Application *arg1 = (Dali::Application *) 0 ;
54723   Dali::Application::AppSignalType *result = 0 ;
54724
54725   arg1 = (Dali::Application *)jarg1;
54726   {
54727     try {
54728       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
54729     } catch (std::out_of_range& e) {
54730       {
54731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54732       };
54733     } catch (std::exception& e) {
54734       {
54735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54736       };
54737     } catch (...) {
54738       {
54739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54740       };
54741     }
54742   }
54743   jresult = (void *)result;
54744   return jresult;
54745 }
54746
54747
54748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
54749   void * jresult ;
54750   Dali::Application *arg1 = (Dali::Application *) 0 ;
54751   Dali::Application::AppSignalType *result = 0 ;
54752
54753   arg1 = (Dali::Application *)jarg1;
54754   {
54755     try {
54756       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
54757     } catch (std::out_of_range& e) {
54758       {
54759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54760       };
54761     } catch (std::exception& e) {
54762       {
54763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54764       };
54765     } catch (...) {
54766       {
54767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54768       };
54769     }
54770   }
54771   jresult = (void *)result;
54772   return jresult;
54773 }
54774
54775
54776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
54777   unsigned int jresult ;
54778   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54779   bool result;
54780
54781   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54782   {
54783     try {
54784       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
54785     } catch (std::out_of_range& e) {
54786       {
54787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54788       };
54789     } catch (std::exception& e) {
54790       {
54791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54792       };
54793     } catch (...) {
54794       {
54795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54796       };
54797     }
54798   }
54799   jresult = result;
54800   return jresult;
54801 }
54802
54803
54804 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
54805   unsigned long jresult ;
54806   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54807   std::size_t result;
54808
54809   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54810   {
54811     try {
54812       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
54813     } catch (std::out_of_range& e) {
54814       {
54815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54816       };
54817     } catch (std::exception& e) {
54818       {
54819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54820       };
54821     } catch (...) {
54822       {
54823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54824       };
54825     }
54826   }
54827   jresult = (unsigned long)result;
54828   return jresult;
54829 }
54830
54831
54832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
54833   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54834   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
54835
54836   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54837   arg2 = (void (*)(Dali::Application &))jarg2;
54838   {
54839     try {
54840       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
54841     } catch (std::out_of_range& e) {
54842       {
54843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54844       };
54845     } catch (std::exception& e) {
54846       {
54847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54848       };
54849     } catch (...) {
54850       {
54851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54852       };
54853     }
54854   }
54855 }
54856
54857
54858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
54859   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54860   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
54861
54862   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54863   arg2 = (void (*)(Dali::Application &))jarg2;
54864   {
54865     try {
54866       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
54867     } catch (std::out_of_range& e) {
54868       {
54869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54870       };
54871     } catch (std::exception& e) {
54872       {
54873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54874       };
54875     } catch (...) {
54876       {
54877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54878       };
54879     }
54880   }
54881 }
54882
54883
54884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
54885   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54886   Dali::Application *arg2 = 0 ;
54887
54888   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54889   arg2 = (Dali::Application *)jarg2;
54890   if (!arg2) {
54891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
54892     return ;
54893   }
54894   {
54895     try {
54896       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
54897     } catch (std::out_of_range& e) {
54898       {
54899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54900       };
54901     } catch (std::exception& e) {
54902       {
54903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54904       };
54905     } catch (...) {
54906       {
54907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54908       };
54909     }
54910   }
54911 }
54912
54913
54914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
54915   void * jresult ;
54916   Dali::Signal< void (Dali::Application &) > *result = 0 ;
54917
54918   {
54919     try {
54920       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
54921     } catch (std::out_of_range& e) {
54922       {
54923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54924       };
54925     } catch (std::exception& e) {
54926       {
54927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54928       };
54929     } catch (...) {
54930       {
54931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54932       };
54933     }
54934   }
54935   jresult = (void *)result;
54936   return jresult;
54937 }
54938
54939
54940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
54941   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
54942
54943   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
54944   {
54945     try {
54946       delete arg1;
54947     } catch (std::out_of_range& e) {
54948       {
54949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54950       };
54951     } catch (std::exception& e) {
54952       {
54953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54954       };
54955     } catch (...) {
54956       {
54957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54958       };
54959     }
54960   }
54961 }
54962
54963
54964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
54965   unsigned int jresult ;
54966   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
54967   bool result;
54968
54969   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
54970   {
54971     try {
54972       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
54973     } catch (std::out_of_range& e) {
54974       {
54975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54976       };
54977     } catch (std::exception& e) {
54978       {
54979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54980       };
54981     } catch (...) {
54982       {
54983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54984       };
54985     }
54986   }
54987   jresult = result;
54988   return jresult;
54989 }
54990
54991
54992 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
54993   unsigned long jresult ;
54994   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
54995   std::size_t result;
54996
54997   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
54998   {
54999     try {
55000       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55001     } catch (std::out_of_range& e) {
55002       {
55003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55004       };
55005     } catch (std::exception& e) {
55006       {
55007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55008       };
55009     } catch (...) {
55010       {
55011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55012       };
55013     }
55014   }
55015   jresult = (unsigned long)result;
55016   return jresult;
55017 }
55018
55019
55020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
55021   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55022   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55023
55024   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55025   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55026   {
55027     try {
55028       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
55029     } catch (std::out_of_range& e) {
55030       {
55031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55032       };
55033     } catch (std::exception& e) {
55034       {
55035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55036       };
55037     } catch (...) {
55038       {
55039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55040       };
55041     }
55042   }
55043 }
55044
55045
55046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
55047   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55048   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55049
55050   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55051   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55052   {
55053     try {
55054       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
55055     } catch (std::out_of_range& e) {
55056       {
55057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55058       };
55059     } catch (std::exception& e) {
55060       {
55061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55062       };
55063     } catch (...) {
55064       {
55065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55066       };
55067     }
55068   }
55069 }
55070
55071
55072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55073   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55074   Dali::Application *arg2 = 0 ;
55075   void *arg3 = (void *) 0 ;
55076
55077   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55078   arg2 = (Dali::Application *)jarg2;
55079   if (!arg2) {
55080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55081     return ;
55082   }
55083   arg3 = jarg3;
55084   {
55085     try {
55086       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
55087     } catch (std::out_of_range& e) {
55088       {
55089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55090       };
55091     } catch (std::exception& e) {
55092       {
55093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55094       };
55095     } catch (...) {
55096       {
55097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55098       };
55099     }
55100   }
55101 }
55102
55103
55104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
55105   void * jresult ;
55106   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
55107
55108   {
55109     try {
55110       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
55111     } catch (std::out_of_range& e) {
55112       {
55113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55114       };
55115     } catch (std::exception& e) {
55116       {
55117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55118       };
55119     } catch (...) {
55120       {
55121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55122       };
55123     }
55124   }
55125   jresult = (void *)result;
55126   return jresult;
55127 }
55128
55129
55130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
55131   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55132
55133   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55134   {
55135     try {
55136       delete arg1;
55137     } catch (std::out_of_range& e) {
55138       {
55139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55140       };
55141     } catch (std::exception& e) {
55142       {
55143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55144       };
55145     } catch (...) {
55146       {
55147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55148       };
55149     }
55150   }
55151 }
55152
55153
55154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55155   unsigned int jresult ;
55156   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55157   bool result;
55158
55159   arg1 = (Dali::Signal< bool () > *)jarg1;
55160   {
55161     try {
55162       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55163     } catch (std::out_of_range& e) {
55164       {
55165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55166       };
55167     } catch (std::exception& e) {
55168       {
55169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55170       };
55171     } catch (...) {
55172       {
55173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55174       };
55175     }
55176   }
55177   jresult = result;
55178   return jresult;
55179 }
55180
55181
55182 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55183   unsigned long jresult ;
55184   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55185   std::size_t result;
55186
55187   arg1 = (Dali::Signal< bool () > *)jarg1;
55188   {
55189     try {
55190       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55191     } catch (std::out_of_range& e) {
55192       {
55193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55194       };
55195     } catch (std::exception& e) {
55196       {
55197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55198       };
55199     } catch (...) {
55200       {
55201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55202       };
55203     }
55204   }
55205   jresult = (unsigned long)result;
55206   return jresult;
55207 }
55208
55209
55210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55211   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55212   bool (*arg2)() = (bool (*)()) 0 ;
55213
55214   arg1 = (Dali::Signal< bool () > *)jarg1;
55215   arg2 = (bool (*)())jarg2;
55216   {
55217     try {
55218       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55219     } catch (std::out_of_range& e) {
55220       {
55221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55222       };
55223     } catch (std::exception& e) {
55224       {
55225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55226       };
55227     } catch (...) {
55228       {
55229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55230       };
55231     }
55232   }
55233 }
55234
55235
55236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55237   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55238   bool (*arg2)() = (bool (*)()) 0 ;
55239
55240   arg1 = (Dali::Signal< bool () > *)jarg1;
55241   arg2 = (bool (*)())jarg2;
55242   {
55243     try {
55244       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55245     } catch (std::out_of_range& e) {
55246       {
55247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55248       };
55249     } catch (std::exception& e) {
55250       {
55251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55252       };
55253     } catch (...) {
55254       {
55255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55256       };
55257     }
55258   }
55259 }
55260
55261
55262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55263   unsigned int jresult ;
55264   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55265   bool result;
55266
55267   arg1 = (Dali::Signal< bool () > *)jarg1;
55268   {
55269     try {
55270       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55271     } catch (std::out_of_range& e) {
55272       {
55273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55274       };
55275     } catch (std::exception& e) {
55276       {
55277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55278       };
55279     } catch (...) {
55280       {
55281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55282       };
55283     }
55284   }
55285   jresult = result;
55286   return jresult;
55287 }
55288
55289
55290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55291   void * jresult ;
55292   Dali::Signal< bool () > *result = 0 ;
55293
55294   {
55295     try {
55296       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55297     } catch (std::out_of_range& e) {
55298       {
55299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55300       };
55301     } catch (std::exception& e) {
55302       {
55303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55304       };
55305     } catch (...) {
55306       {
55307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55308       };
55309     }
55310   }
55311   jresult = (void *)result;
55312   return jresult;
55313 }
55314
55315
55316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55317   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55318
55319   arg1 = (Dali::Signal< bool () > *)jarg1;
55320   {
55321     try {
55322       delete arg1;
55323     } catch (std::out_of_range& e) {
55324       {
55325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55326       };
55327     } catch (std::exception& e) {
55328       {
55329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55330       };
55331     } catch (...) {
55332       {
55333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55334       };
55335     }
55336   }
55337 }
55338
55339
55340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55341   int jresult ;
55342   int result;
55343
55344   {
55345     try {
55346       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55347     } catch (std::out_of_range& e) {
55348       {
55349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55350       };
55351     } catch (std::exception& e) {
55352       {
55353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55354       };
55355     } catch (...) {
55356       {
55357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55358       };
55359     }
55360   }
55361   jresult = (int)result;
55362   return jresult;
55363 }
55364
55365
55366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55367   int jresult ;
55368   int result;
55369
55370   {
55371     try {
55372       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55373     } catch (std::out_of_range& e) {
55374       {
55375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55376       };
55377     } catch (std::exception& e) {
55378       {
55379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55380       };
55381     } catch (...) {
55382       {
55383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55384       };
55385     }
55386   }
55387   jresult = (int)result;
55388   return jresult;
55389 }
55390
55391
55392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55393   int jresult ;
55394   int result;
55395
55396   {
55397     try {
55398       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55399     } catch (std::out_of_range& e) {
55400       {
55401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55402       };
55403     } catch (std::exception& e) {
55404       {
55405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55406       };
55407     } catch (...) {
55408       {
55409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55410       };
55411     }
55412   }
55413   jresult = (int)result;
55414   return jresult;
55415 }
55416
55417
55418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55419   int jresult ;
55420   int result;
55421
55422   {
55423     try {
55424       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55425     } catch (std::out_of_range& e) {
55426       {
55427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55428       };
55429     } catch (std::exception& e) {
55430       {
55431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55432       };
55433     } catch (...) {
55434       {
55435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55436       };
55437     }
55438   }
55439   jresult = (int)result;
55440   return jresult;
55441 }
55442
55443
55444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55445   int jresult ;
55446   int result;
55447
55448   {
55449     try {
55450       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55451     } catch (std::out_of_range& e) {
55452       {
55453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55454       };
55455     } catch (std::exception& e) {
55456       {
55457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55458       };
55459     } catch (...) {
55460       {
55461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55462       };
55463     }
55464   }
55465   jresult = (int)result;
55466   return jresult;
55467 }
55468
55469
55470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55471   int jresult ;
55472   int result;
55473
55474   {
55475     try {
55476       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55477     } catch (std::out_of_range& e) {
55478       {
55479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55480       };
55481     } catch (std::exception& e) {
55482       {
55483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55484       };
55485     } catch (...) {
55486       {
55487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55488       };
55489     }
55490   }
55491   jresult = (int)result;
55492   return jresult;
55493 }
55494
55495
55496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55497   int jresult ;
55498   int result;
55499
55500   {
55501     try {
55502       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55503     } catch (std::out_of_range& e) {
55504       {
55505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55506       };
55507     } catch (std::exception& e) {
55508       {
55509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55510       };
55511     } catch (...) {
55512       {
55513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55514       };
55515     }
55516   }
55517   jresult = (int)result;
55518   return jresult;
55519 }
55520
55521
55522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55523   int jresult ;
55524   int result;
55525
55526   {
55527     try {
55528       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55529     } catch (std::out_of_range& e) {
55530       {
55531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55532       };
55533     } catch (std::exception& e) {
55534       {
55535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55536       };
55537     } catch (...) {
55538       {
55539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55540       };
55541     }
55542   }
55543   jresult = (int)result;
55544   return jresult;
55545 }
55546
55547
55548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55549   int jresult ;
55550   int result;
55551
55552   {
55553     try {
55554       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55555     } catch (std::out_of_range& e) {
55556       {
55557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55558       };
55559     } catch (std::exception& e) {
55560       {
55561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55562       };
55563     } catch (...) {
55564       {
55565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55566       };
55567     }
55568   }
55569   jresult = (int)result;
55570   return jresult;
55571 }
55572
55573
55574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55575   int jresult ;
55576   int result;
55577
55578   {
55579     try {
55580       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55581     } catch (std::out_of_range& e) {
55582       {
55583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55584       };
55585     } catch (std::exception& e) {
55586       {
55587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55588       };
55589     } catch (...) {
55590       {
55591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55592       };
55593     }
55594   }
55595   jresult = (int)result;
55596   return jresult;
55597 }
55598
55599
55600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55601   int jresult ;
55602   int result;
55603
55604   {
55605     try {
55606       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55607     } catch (std::out_of_range& e) {
55608       {
55609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55610       };
55611     } catch (std::exception& e) {
55612       {
55613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55614       };
55615     } catch (...) {
55616       {
55617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55618       };
55619     }
55620   }
55621   jresult = (int)result;
55622   return jresult;
55623 }
55624
55625
55626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55627   int jresult ;
55628   int result;
55629
55630   {
55631     try {
55632       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55633     } catch (std::out_of_range& e) {
55634       {
55635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55636       };
55637     } catch (std::exception& e) {
55638       {
55639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55640       };
55641     } catch (...) {
55642       {
55643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55644       };
55645     }
55646   }
55647   jresult = (int)result;
55648   return jresult;
55649 }
55650
55651
55652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55653   int jresult ;
55654   int result;
55655
55656   {
55657     try {
55658       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55659     } catch (std::out_of_range& e) {
55660       {
55661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55662       };
55663     } catch (std::exception& e) {
55664       {
55665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55666       };
55667     } catch (...) {
55668       {
55669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55670       };
55671     }
55672   }
55673   jresult = (int)result;
55674   return jresult;
55675 }
55676
55677
55678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55679   int jresult ;
55680   int result;
55681
55682   {
55683     try {
55684       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55685     } catch (std::out_of_range& e) {
55686       {
55687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55688       };
55689     } catch (std::exception& e) {
55690       {
55691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55692       };
55693     } catch (...) {
55694       {
55695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55696       };
55697     }
55698   }
55699   jresult = (int)result;
55700   return jresult;
55701 }
55702
55703
55704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
55705   int jresult ;
55706   int result;
55707
55708   {
55709     try {
55710       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55711     } catch (std::out_of_range& e) {
55712       {
55713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55714       };
55715     } catch (std::exception& e) {
55716       {
55717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55718       };
55719     } catch (...) {
55720       {
55721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55722       };
55723     }
55724   }
55725   jresult = (int)result;
55726   return jresult;
55727 }
55728
55729
55730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
55731   int jresult ;
55732   int result;
55733
55734   {
55735     try {
55736       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55737     } catch (std::out_of_range& e) {
55738       {
55739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55740       };
55741     } catch (std::exception& e) {
55742       {
55743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55744       };
55745     } catch (...) {
55746       {
55747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55748       };
55749     }
55750   }
55751   jresult = (int)result;
55752   return jresult;
55753 }
55754
55755
55756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
55757   int jresult ;
55758   int result;
55759
55760   {
55761     try {
55762       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
55763     } catch (std::out_of_range& e) {
55764       {
55765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55766       };
55767     } catch (std::exception& e) {
55768       {
55769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55770       };
55771     } catch (...) {
55772       {
55773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55774       };
55775     }
55776   }
55777   jresult = (int)result;
55778   return jresult;
55779 }
55780
55781
55782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
55783   int jresult ;
55784   int result;
55785
55786   {
55787     try {
55788       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
55789     } catch (std::out_of_range& e) {
55790       {
55791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55792       };
55793     } catch (std::exception& e) {
55794       {
55795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55796       };
55797     } catch (...) {
55798       {
55799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55800       };
55801     }
55802   }
55803   jresult = (int)result;
55804   return jresult;
55805 }
55806
55807
55808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
55809   int jresult ;
55810   int result;
55811
55812   {
55813     try {
55814       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
55815     } catch (std::out_of_range& e) {
55816       {
55817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55818       };
55819     } catch (std::exception& e) {
55820       {
55821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55822       };
55823     } catch (...) {
55824       {
55825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55826       };
55827     }
55828   }
55829   jresult = (int)result;
55830   return jresult;
55831 }
55832
55833
55834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
55835   int jresult ;
55836   int result;
55837
55838   {
55839     try {
55840       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
55841     } catch (std::out_of_range& e) {
55842       {
55843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55844       };
55845     } catch (std::exception& e) {
55846       {
55847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55848       };
55849     } catch (...) {
55850       {
55851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55852       };
55853     }
55854   }
55855   jresult = (int)result;
55856   return jresult;
55857 }
55858
55859
55860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
55861   int jresult ;
55862   int result;
55863
55864   {
55865     try {
55866       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
55867     } catch (std::out_of_range& e) {
55868       {
55869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55870       };
55871     } catch (std::exception& e) {
55872       {
55873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55874       };
55875     } catch (...) {
55876       {
55877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55878       };
55879     }
55880   }
55881   jresult = (int)result;
55882   return jresult;
55883 }
55884
55885
55886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
55887   int jresult ;
55888   int result;
55889
55890   {
55891     try {
55892       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
55893     } catch (std::out_of_range& e) {
55894       {
55895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55896       };
55897     } catch (std::exception& e) {
55898       {
55899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55900       };
55901     } catch (...) {
55902       {
55903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55904       };
55905     }
55906   }
55907   jresult = (int)result;
55908   return jresult;
55909 }
55910
55911
55912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
55913   int jresult ;
55914   int result;
55915
55916   {
55917     try {
55918       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
55919     } catch (std::out_of_range& e) {
55920       {
55921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55922       };
55923     } catch (std::exception& e) {
55924       {
55925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55926       };
55927     } catch (...) {
55928       {
55929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55930       };
55931     }
55932   }
55933   jresult = (int)result;
55934   return jresult;
55935 }
55936
55937
55938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
55939   int jresult ;
55940   int result;
55941
55942   {
55943     try {
55944       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
55945     } catch (std::out_of_range& e) {
55946       {
55947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55948       };
55949     } catch (std::exception& e) {
55950       {
55951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55952       };
55953     } catch (...) {
55954       {
55955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55956       };
55957     }
55958   }
55959   jresult = (int)result;
55960   return jresult;
55961 }
55962
55963
55964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
55965   int jresult ;
55966   int result;
55967
55968   {
55969     try {
55970       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
55971     } catch (std::out_of_range& e) {
55972       {
55973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55974       };
55975     } catch (std::exception& e) {
55976       {
55977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55978       };
55979     } catch (...) {
55980       {
55981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55982       };
55983     }
55984   }
55985   jresult = (int)result;
55986   return jresult;
55987 }
55988
55989
55990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
55991   int jresult ;
55992   int result;
55993
55994   {
55995     try {
55996       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
55997     } catch (std::out_of_range& e) {
55998       {
55999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56000       };
56001     } catch (std::exception& e) {
56002       {
56003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56004       };
56005     } catch (...) {
56006       {
56007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56008       };
56009     }
56010   }
56011   jresult = (int)result;
56012   return jresult;
56013 }
56014
56015
56016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56017   int jresult ;
56018   int result;
56019
56020   {
56021     try {
56022       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56023     } catch (std::out_of_range& e) {
56024       {
56025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56026       };
56027     } catch (std::exception& e) {
56028       {
56029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56030       };
56031     } catch (...) {
56032       {
56033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56034       };
56035     }
56036   }
56037   jresult = (int)result;
56038   return jresult;
56039 }
56040
56041
56042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56043   int jresult ;
56044   int result;
56045
56046   {
56047     try {
56048       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56049     } catch (std::out_of_range& e) {
56050       {
56051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56052       };
56053     } catch (std::exception& e) {
56054       {
56055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56056       };
56057     } catch (...) {
56058       {
56059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56060       };
56061     }
56062   }
56063   jresult = (int)result;
56064   return jresult;
56065 }
56066
56067
56068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56069   int jresult ;
56070   int result;
56071
56072   {
56073     try {
56074       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56075     } catch (std::out_of_range& e) {
56076       {
56077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56078       };
56079     } catch (std::exception& e) {
56080       {
56081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56082       };
56083     } catch (...) {
56084       {
56085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56086       };
56087     }
56088   }
56089   jresult = (int)result;
56090   return jresult;
56091 }
56092
56093
56094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56095   int jresult ;
56096   int result;
56097
56098   {
56099     try {
56100       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56101     } catch (std::out_of_range& e) {
56102       {
56103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56104       };
56105     } catch (std::exception& e) {
56106       {
56107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56108       };
56109     } catch (...) {
56110       {
56111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56112       };
56113     }
56114   }
56115   jresult = (int)result;
56116   return jresult;
56117 }
56118
56119
56120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56121   int jresult ;
56122   int result;
56123
56124   {
56125     try {
56126       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56127     } catch (std::out_of_range& e) {
56128       {
56129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56130       };
56131     } catch (std::exception& e) {
56132       {
56133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56134       };
56135     } catch (...) {
56136       {
56137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56138       };
56139     }
56140   }
56141   jresult = (int)result;
56142   return jresult;
56143 }
56144
56145
56146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56147   int jresult ;
56148   int result;
56149
56150   {
56151     try {
56152       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56153     } catch (std::out_of_range& e) {
56154       {
56155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56156       };
56157     } catch (std::exception& e) {
56158       {
56159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56160       };
56161     } catch (...) {
56162       {
56163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56164       };
56165     }
56166   }
56167   jresult = (int)result;
56168   return jresult;
56169 }
56170
56171
56172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56173   int jresult ;
56174   int result;
56175
56176   {
56177     try {
56178       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56179     } catch (std::out_of_range& e) {
56180       {
56181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56182       };
56183     } catch (std::exception& e) {
56184       {
56185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56186       };
56187     } catch (...) {
56188       {
56189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56190       };
56191     }
56192   }
56193   jresult = (int)result;
56194   return jresult;
56195 }
56196
56197
56198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56199   int jresult ;
56200   int result;
56201
56202   {
56203     try {
56204       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56205     } catch (std::out_of_range& e) {
56206       {
56207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56208       };
56209     } catch (std::exception& e) {
56210       {
56211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56212       };
56213     } catch (...) {
56214       {
56215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56216       };
56217     }
56218   }
56219   jresult = (int)result;
56220   return jresult;
56221 }
56222
56223
56224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56225   int jresult ;
56226   int result;
56227
56228   {
56229     try {
56230       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56231     } catch (std::out_of_range& e) {
56232       {
56233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56234       };
56235     } catch (std::exception& e) {
56236       {
56237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56238       };
56239     } catch (...) {
56240       {
56241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56242       };
56243     }
56244   }
56245   jresult = (int)result;
56246   return jresult;
56247 }
56248
56249
56250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56251   int jresult ;
56252   int result;
56253
56254   {
56255     try {
56256       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56257     } catch (std::out_of_range& e) {
56258       {
56259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56260       };
56261     } catch (std::exception& e) {
56262       {
56263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56264       };
56265     } catch (...) {
56266       {
56267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56268       };
56269     }
56270   }
56271   jresult = (int)result;
56272   return jresult;
56273 }
56274
56275
56276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56277   int jresult ;
56278   int result;
56279
56280   {
56281     try {
56282       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56283     } catch (std::out_of_range& e) {
56284       {
56285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56286       };
56287     } catch (std::exception& e) {
56288       {
56289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56290       };
56291     } catch (...) {
56292       {
56293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56294       };
56295     }
56296   }
56297   jresult = (int)result;
56298   return jresult;
56299 }
56300
56301
56302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56303   int jresult ;
56304   int result;
56305
56306   {
56307     try {
56308       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56309     } catch (std::out_of_range& e) {
56310       {
56311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56312       };
56313     } catch (std::exception& e) {
56314       {
56315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56316       };
56317     } catch (...) {
56318       {
56319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56320       };
56321     }
56322   }
56323   jresult = (int)result;
56324   return jresult;
56325 }
56326
56327
56328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56329   int jresult ;
56330   int result;
56331
56332   {
56333     try {
56334       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56335     } catch (std::out_of_range& e) {
56336       {
56337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56338       };
56339     } catch (std::exception& e) {
56340       {
56341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56342       };
56343     } catch (...) {
56344       {
56345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56346       };
56347     }
56348   }
56349   jresult = (int)result;
56350   return jresult;
56351 }
56352
56353
56354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56355   int jresult ;
56356   int result;
56357
56358   {
56359     try {
56360       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56361     } catch (std::out_of_range& e) {
56362       {
56363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56364       };
56365     } catch (std::exception& e) {
56366       {
56367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56368       };
56369     } catch (...) {
56370       {
56371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56372       };
56373     }
56374   }
56375   jresult = (int)result;
56376   return jresult;
56377 }
56378
56379
56380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56381   int jresult ;
56382   int result;
56383
56384   {
56385     try {
56386       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56387     } catch (std::out_of_range& e) {
56388       {
56389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56390       };
56391     } catch (std::exception& e) {
56392       {
56393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56394       };
56395     } catch (...) {
56396       {
56397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56398       };
56399     }
56400   }
56401   jresult = (int)result;
56402   return jresult;
56403 }
56404
56405
56406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56407   int jresult ;
56408   int result;
56409
56410   {
56411     try {
56412       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56413     } catch (std::out_of_range& e) {
56414       {
56415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56416       };
56417     } catch (std::exception& e) {
56418       {
56419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56420       };
56421     } catch (...) {
56422       {
56423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56424       };
56425     }
56426   }
56427   jresult = (int)result;
56428   return jresult;
56429 }
56430
56431
56432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56433   int jresult ;
56434   int result;
56435
56436   {
56437     try {
56438       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56439     } catch (std::out_of_range& e) {
56440       {
56441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56442       };
56443     } catch (std::exception& e) {
56444       {
56445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56446       };
56447     } catch (...) {
56448       {
56449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56450       };
56451     }
56452   }
56453   jresult = (int)result;
56454   return jresult;
56455 }
56456
56457
56458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56459   int jresult ;
56460   int result;
56461
56462   {
56463     try {
56464       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56465     } catch (std::out_of_range& e) {
56466       {
56467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56468       };
56469     } catch (std::exception& e) {
56470       {
56471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56472       };
56473     } catch (...) {
56474       {
56475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56476       };
56477     }
56478   }
56479   jresult = (int)result;
56480   return jresult;
56481 }
56482
56483
56484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56485   int jresult ;
56486   int result;
56487
56488   {
56489     try {
56490       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56491     } catch (std::out_of_range& e) {
56492       {
56493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56494       };
56495     } catch (std::exception& e) {
56496       {
56497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56498       };
56499     } catch (...) {
56500       {
56501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56502       };
56503     }
56504   }
56505   jresult = (int)result;
56506   return jresult;
56507 }
56508
56509
56510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56511   int jresult ;
56512   int result;
56513
56514   {
56515     try {
56516       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56517     } catch (std::out_of_range& e) {
56518       {
56519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56520       };
56521     } catch (std::exception& e) {
56522       {
56523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56524       };
56525     } catch (...) {
56526       {
56527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56528       };
56529     }
56530   }
56531   jresult = (int)result;
56532   return jresult;
56533 }
56534
56535
56536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56537   int jresult ;
56538   int result;
56539
56540   {
56541     try {
56542       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
56543     } catch (std::out_of_range& e) {
56544       {
56545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56546       };
56547     } catch (std::exception& e) {
56548       {
56549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56550       };
56551     } catch (...) {
56552       {
56553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56554       };
56555     }
56556   }
56557   jresult = (int)result;
56558   return jresult;
56559 }
56560
56561
56562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
56563   int jresult ;
56564   int result;
56565
56566   {
56567     try {
56568       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
56569     } catch (std::out_of_range& e) {
56570       {
56571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56572       };
56573     } catch (std::exception& e) {
56574       {
56575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56576       };
56577     } catch (...) {
56578       {
56579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56580       };
56581     }
56582   }
56583   jresult = (int)result;
56584   return jresult;
56585 }
56586
56587
56588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
56589   int jresult ;
56590   int result;
56591
56592   {
56593     try {
56594       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
56595     } catch (std::out_of_range& e) {
56596       {
56597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56598       };
56599     } catch (std::exception& e) {
56600       {
56601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56602       };
56603     } catch (...) {
56604       {
56605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56606       };
56607     }
56608   }
56609   jresult = (int)result;
56610   return jresult;
56611 }
56612
56613
56614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
56615   int jresult ;
56616   int result;
56617
56618   {
56619     try {
56620       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
56621     } catch (std::out_of_range& e) {
56622       {
56623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56624       };
56625     } catch (std::exception& e) {
56626       {
56627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56628       };
56629     } catch (...) {
56630       {
56631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56632       };
56633     }
56634   }
56635   jresult = (int)result;
56636   return jresult;
56637 }
56638
56639
56640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
56641   int jresult ;
56642   int result;
56643
56644   {
56645     try {
56646       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
56647     } catch (std::out_of_range& e) {
56648       {
56649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56650       };
56651     } catch (std::exception& e) {
56652       {
56653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56654       };
56655     } catch (...) {
56656       {
56657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56658       };
56659     }
56660   }
56661   jresult = (int)result;
56662   return jresult;
56663 }
56664
56665
56666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
56667   int jresult ;
56668   int result;
56669
56670   {
56671     try {
56672       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
56673     } catch (std::out_of_range& e) {
56674       {
56675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56676       };
56677     } catch (std::exception& e) {
56678       {
56679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56680       };
56681     } catch (...) {
56682       {
56683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56684       };
56685     }
56686   }
56687   jresult = (int)result;
56688   return jresult;
56689 }
56690
56691
56692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
56693   int jresult ;
56694   int result;
56695
56696   {
56697     try {
56698       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
56699     } catch (std::out_of_range& e) {
56700       {
56701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56702       };
56703     } catch (std::exception& e) {
56704       {
56705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56706       };
56707     } catch (...) {
56708       {
56709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56710       };
56711     }
56712   }
56713   jresult = (int)result;
56714   return jresult;
56715 }
56716
56717
56718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
56719   int jresult ;
56720   int result;
56721
56722   {
56723     try {
56724       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
56725     } catch (std::out_of_range& e) {
56726       {
56727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56728       };
56729     } catch (std::exception& e) {
56730       {
56731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56732       };
56733     } catch (...) {
56734       {
56735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56736       };
56737     }
56738   }
56739   jresult = (int)result;
56740   return jresult;
56741 }
56742
56743
56744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
56745   int jresult ;
56746   int result;
56747
56748   {
56749     try {
56750       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
56751     } catch (std::out_of_range& e) {
56752       {
56753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56754       };
56755     } catch (std::exception& e) {
56756       {
56757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56758       };
56759     } catch (...) {
56760       {
56761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56762       };
56763     }
56764   }
56765   jresult = (int)result;
56766   return jresult;
56767 }
56768
56769
56770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
56771   int jresult ;
56772   int result;
56773
56774   {
56775     try {
56776       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
56777     } catch (std::out_of_range& e) {
56778       {
56779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56780       };
56781     } catch (std::exception& e) {
56782       {
56783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56784       };
56785     } catch (...) {
56786       {
56787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56788       };
56789     }
56790   }
56791   jresult = (int)result;
56792   return jresult;
56793 }
56794
56795
56796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
56797   int jresult ;
56798   int result;
56799
56800   {
56801     try {
56802       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
56803     } catch (std::out_of_range& e) {
56804       {
56805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56806       };
56807     } catch (std::exception& e) {
56808       {
56809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56810       };
56811     } catch (...) {
56812       {
56813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56814       };
56815     }
56816   }
56817   jresult = (int)result;
56818   return jresult;
56819 }
56820
56821
56822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
56823   void * jresult ;
56824   Dali::Toolkit::Builder *result = 0 ;
56825
56826   {
56827     try {
56828       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
56829     } catch (std::out_of_range& e) {
56830       {
56831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56832       };
56833     } catch (std::exception& e) {
56834       {
56835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56836       };
56837     } catch (...) {
56838       {
56839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56840       };
56841     }
56842   }
56843   jresult = (void *)result;
56844   return jresult;
56845 }
56846
56847
56848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
56849   void * jresult ;
56850   Dali::Toolkit::Builder result;
56851
56852   {
56853     try {
56854       result = Dali::Toolkit::Builder::New();
56855     } catch (std::out_of_range& e) {
56856       {
56857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56858       };
56859     } catch (std::exception& e) {
56860       {
56861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56862       };
56863     } catch (...) {
56864       {
56865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56866       };
56867     }
56868   }
56869   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
56870   return jresult;
56871 }
56872
56873
56874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
56875   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56876
56877   arg1 = (Dali::Toolkit::Builder *)jarg1;
56878   {
56879     try {
56880       delete arg1;
56881     } catch (std::out_of_range& e) {
56882       {
56883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56884       };
56885     } catch (std::exception& e) {
56886       {
56887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56888       };
56889     } catch (...) {
56890       {
56891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56892       };
56893     }
56894   }
56895 }
56896
56897
56898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
56899   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56900   std::string *arg2 = 0 ;
56901   Dali::Toolkit::Builder::UIFormat arg3 ;
56902
56903   arg1 = (Dali::Toolkit::Builder *)jarg1;
56904   if (!jarg2) {
56905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56906     return ;
56907   }
56908   std::string arg2_str(jarg2);
56909   arg2 = &arg2_str;
56910   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
56911   {
56912     try {
56913       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
56914     } catch (std::out_of_range& e) {
56915       {
56916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56917       };
56918     } catch (std::exception& e) {
56919       {
56920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56921       };
56922     } catch (...) {
56923       {
56924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56925       };
56926     }
56927   }
56928
56929   //argout typemap for const std::string&
56930
56931 }
56932
56933
56934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
56935   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56936   std::string *arg2 = 0 ;
56937
56938   arg1 = (Dali::Toolkit::Builder *)jarg1;
56939   if (!jarg2) {
56940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
56941     return ;
56942   }
56943   std::string arg2_str(jarg2);
56944   arg2 = &arg2_str;
56945   {
56946     try {
56947       (arg1)->LoadFromString((std::string const &)*arg2);
56948     } catch (std::out_of_range& e) {
56949       {
56950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56951       };
56952     } catch (std::exception& e) {
56953       {
56954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56955       };
56956     } catch (...) {
56957       {
56958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56959       };
56960     }
56961   }
56962
56963   //argout typemap for const std::string&
56964
56965 }
56966
56967
56968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
56969   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
56970   Dali::Property::Map *arg2 = 0 ;
56971
56972   arg1 = (Dali::Toolkit::Builder *)jarg1;
56973   arg2 = (Dali::Property::Map *)jarg2;
56974   if (!arg2) {
56975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
56976     return ;
56977   }
56978   {
56979     try {
56980       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
56981     } catch (std::out_of_range& e) {
56982       {
56983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56984       };
56985     } catch (std::exception& e) {
56986       {
56987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56988       };
56989     } catch (...) {
56990       {
56991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56992       };
56993     }
56994   }
56995 }
56996
56997
56998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
56999   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57000   std::string *arg2 = 0 ;
57001   Dali::Property::Value *arg3 = 0 ;
57002
57003   arg1 = (Dali::Toolkit::Builder *)jarg1;
57004   if (!jarg2) {
57005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57006     return ;
57007   }
57008   std::string arg2_str(jarg2);
57009   arg2 = &arg2_str;
57010   arg3 = (Dali::Property::Value *)jarg3;
57011   if (!arg3) {
57012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57013     return ;
57014   }
57015   {
57016     try {
57017       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57018     } catch (std::out_of_range& e) {
57019       {
57020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57021       };
57022     } catch (std::exception& e) {
57023       {
57024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57025       };
57026     } catch (...) {
57027       {
57028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57029       };
57030     }
57031   }
57032
57033   //argout typemap for const std::string&
57034
57035 }
57036
57037
57038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57039   void * jresult ;
57040   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57041   Dali::Property::Map *result = 0 ;
57042
57043   arg1 = (Dali::Toolkit::Builder *)jarg1;
57044   {
57045     try {
57046       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57047     } catch (std::out_of_range& e) {
57048       {
57049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57050       };
57051     } catch (std::exception& e) {
57052       {
57053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57054       };
57055     } catch (...) {
57056       {
57057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57058       };
57059     }
57060   }
57061   jresult = (void *)result;
57062   return jresult;
57063 }
57064
57065
57066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57067   void * jresult ;
57068   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57069   std::string *arg2 = 0 ;
57070   Dali::Property::Value *result = 0 ;
57071
57072   arg1 = (Dali::Toolkit::Builder *)jarg1;
57073   if (!jarg2) {
57074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57075     return 0;
57076   }
57077   std::string arg2_str(jarg2);
57078   arg2 = &arg2_str;
57079   {
57080     try {
57081       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57082     } catch (std::out_of_range& e) {
57083       {
57084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57085       };
57086     } catch (std::exception& e) {
57087       {
57088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57089       };
57090     } catch (...) {
57091       {
57092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57093       };
57094     }
57095   }
57096   jresult = (void *)result;
57097
57098   //argout typemap for const std::string&
57099
57100   return jresult;
57101 }
57102
57103
57104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57105   void * jresult ;
57106   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57107   std::string *arg2 = 0 ;
57108   Dali::Animation result;
57109
57110   arg1 = (Dali::Toolkit::Builder *)jarg1;
57111   if (!jarg2) {
57112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57113     return 0;
57114   }
57115   std::string arg2_str(jarg2);
57116   arg2 = &arg2_str;
57117   {
57118     try {
57119       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57120     } catch (std::out_of_range& e) {
57121       {
57122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57123       };
57124     } catch (std::exception& e) {
57125       {
57126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57127       };
57128     } catch (...) {
57129       {
57130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57131       };
57132     }
57133   }
57134   jresult = new Dali::Animation((const Dali::Animation &)result);
57135
57136   //argout typemap for const std::string&
57137
57138   return jresult;
57139 }
57140
57141
57142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57143   void * jresult ;
57144   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57145   std::string *arg2 = 0 ;
57146   Dali::Property::Map *arg3 = 0 ;
57147   Dali::Animation result;
57148
57149   arg1 = (Dali::Toolkit::Builder *)jarg1;
57150   if (!jarg2) {
57151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57152     return 0;
57153   }
57154   std::string arg2_str(jarg2);
57155   arg2 = &arg2_str;
57156   arg3 = (Dali::Property::Map *)jarg3;
57157   if (!arg3) {
57158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57159     return 0;
57160   }
57161   {
57162     try {
57163       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57164     } catch (std::out_of_range& e) {
57165       {
57166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57167       };
57168     } catch (std::exception& e) {
57169       {
57170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57171       };
57172     } catch (...) {
57173       {
57174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57175       };
57176     }
57177   }
57178   jresult = new Dali::Animation((const Dali::Animation &)result);
57179
57180   //argout typemap for const std::string&
57181
57182   return jresult;
57183 }
57184
57185
57186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57187   void * jresult ;
57188   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57189   std::string *arg2 = 0 ;
57190   Dali::Actor arg3 ;
57191   Dali::Actor *argp3 ;
57192   Dali::Animation result;
57193
57194   arg1 = (Dali::Toolkit::Builder *)jarg1;
57195   if (!jarg2) {
57196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57197     return 0;
57198   }
57199   std::string arg2_str(jarg2);
57200   arg2 = &arg2_str;
57201   argp3 = (Dali::Actor *)jarg3;
57202   if (!argp3) {
57203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57204     return 0;
57205   }
57206   arg3 = *argp3;
57207   {
57208     try {
57209       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57210     } catch (std::out_of_range& e) {
57211       {
57212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57213       };
57214     } catch (std::exception& e) {
57215       {
57216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57217       };
57218     } catch (...) {
57219       {
57220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57221       };
57222     }
57223   }
57224   jresult = new Dali::Animation((const Dali::Animation &)result);
57225
57226   //argout typemap for const std::string&
57227
57228   return jresult;
57229 }
57230
57231
57232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57233   void * jresult ;
57234   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57235   std::string *arg2 = 0 ;
57236   Dali::Property::Map *arg3 = 0 ;
57237   Dali::Actor arg4 ;
57238   Dali::Actor *argp4 ;
57239   Dali::Animation result;
57240
57241   arg1 = (Dali::Toolkit::Builder *)jarg1;
57242   if (!jarg2) {
57243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57244     return 0;
57245   }
57246   std::string arg2_str(jarg2);
57247   arg2 = &arg2_str;
57248   arg3 = (Dali::Property::Map *)jarg3;
57249   if (!arg3) {
57250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57251     return 0;
57252   }
57253   argp4 = (Dali::Actor *)jarg4;
57254   if (!argp4) {
57255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57256     return 0;
57257   }
57258   arg4 = *argp4;
57259   {
57260     try {
57261       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57262     } catch (std::out_of_range& e) {
57263       {
57264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57265       };
57266     } catch (std::exception& e) {
57267       {
57268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57269       };
57270     } catch (...) {
57271       {
57272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57273       };
57274     }
57275   }
57276   jresult = new Dali::Animation((const Dali::Animation &)result);
57277
57278   //argout typemap for const std::string&
57279
57280   return jresult;
57281 }
57282
57283
57284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57285   void * jresult ;
57286   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57287   std::string *arg2 = 0 ;
57288   Dali::BaseHandle result;
57289
57290   arg1 = (Dali::Toolkit::Builder *)jarg1;
57291   if (!jarg2) {
57292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57293     return 0;
57294   }
57295   std::string arg2_str(jarg2);
57296   arg2 = &arg2_str;
57297   {
57298     try {
57299       result = (arg1)->Create((std::string const &)*arg2);
57300     } catch (std::out_of_range& e) {
57301       {
57302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57303       };
57304     } catch (std::exception& e) {
57305       {
57306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57307       };
57308     } catch (...) {
57309       {
57310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57311       };
57312     }
57313   }
57314   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57315
57316   //argout typemap for const std::string&
57317
57318   return jresult;
57319 }
57320
57321
57322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57323   void * jresult ;
57324   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57325   std::string *arg2 = 0 ;
57326   Dali::Property::Map *arg3 = 0 ;
57327   Dali::BaseHandle result;
57328
57329   arg1 = (Dali::Toolkit::Builder *)jarg1;
57330   if (!jarg2) {
57331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57332     return 0;
57333   }
57334   std::string arg2_str(jarg2);
57335   arg2 = &arg2_str;
57336   arg3 = (Dali::Property::Map *)jarg3;
57337   if (!arg3) {
57338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57339     return 0;
57340   }
57341   {
57342     try {
57343       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57344     } catch (std::out_of_range& e) {
57345       {
57346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57347       };
57348     } catch (std::exception& e) {
57349       {
57350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57351       };
57352     } catch (...) {
57353       {
57354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57355       };
57356     }
57357   }
57358   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57359
57360   //argout typemap for const std::string&
57361
57362   return jresult;
57363 }
57364
57365
57366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57367   void * jresult ;
57368   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57369   std::string *arg2 = 0 ;
57370   Dali::BaseHandle result;
57371
57372   arg1 = (Dali::Toolkit::Builder *)jarg1;
57373   if (!jarg2) {
57374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57375     return 0;
57376   }
57377   std::string arg2_str(jarg2);
57378   arg2 = &arg2_str;
57379   {
57380     try {
57381       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57382     } catch (std::out_of_range& e) {
57383       {
57384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57385       };
57386     } catch (std::exception& e) {
57387       {
57388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57389       };
57390     } catch (...) {
57391       {
57392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57393       };
57394     }
57395   }
57396   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57397
57398   //argout typemap for const std::string&
57399
57400   return jresult;
57401 }
57402
57403
57404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57405   unsigned int jresult ;
57406   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57407   std::string *arg2 = 0 ;
57408   Dali::Handle *arg3 = 0 ;
57409   bool result;
57410
57411   arg1 = (Dali::Toolkit::Builder *)jarg1;
57412   if (!jarg2) {
57413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57414     return 0;
57415   }
57416   std::string arg2_str(jarg2);
57417   arg2 = &arg2_str;
57418   arg3 = (Dali::Handle *)jarg3;
57419   if (!arg3) {
57420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57421     return 0;
57422   }
57423   {
57424     try {
57425       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
57426     } catch (std::out_of_range& e) {
57427       {
57428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57429       };
57430     } catch (std::exception& e) {
57431       {
57432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57433       };
57434     } catch (...) {
57435       {
57436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57437       };
57438     }
57439   }
57440   jresult = result;
57441
57442   //argout typemap for const std::string&
57443
57444   return jresult;
57445 }
57446
57447
57448 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
57449   unsigned int jresult ;
57450   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57451   Dali::Handle *arg2 = 0 ;
57452   std::string *arg3 = 0 ;
57453   bool result;
57454
57455   arg1 = (Dali::Toolkit::Builder *)jarg1;
57456   arg2 = (Dali::Handle *)jarg2;
57457   if (!arg2) {
57458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57459     return 0;
57460   }
57461   if (!jarg3) {
57462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57463     return 0;
57464   }
57465   std::string arg3_str(jarg3);
57466   arg3 = &arg3_str;
57467   {
57468     try {
57469       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
57470     } catch (std::out_of_range& e) {
57471       {
57472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57473       };
57474     } catch (std::exception& e) {
57475       {
57476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57477       };
57478     } catch (...) {
57479       {
57480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57481       };
57482     }
57483   }
57484   jresult = result;
57485
57486   //argout typemap for const std::string&
57487
57488   return jresult;
57489 }
57490
57491
57492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
57493   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57494   Dali::Actor arg2 ;
57495   Dali::Actor *argp2 ;
57496
57497   arg1 = (Dali::Toolkit::Builder *)jarg1;
57498   argp2 = (Dali::Actor *)jarg2;
57499   if (!argp2) {
57500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57501     return ;
57502   }
57503   arg2 = *argp2;
57504   {
57505     try {
57506       (arg1)->AddActors(arg2);
57507     } catch (std::out_of_range& e) {
57508       {
57509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57510       };
57511     } catch (std::exception& e) {
57512       {
57513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57514       };
57515     } catch (...) {
57516       {
57517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57518       };
57519     }
57520   }
57521 }
57522
57523
57524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57525   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57526   std::string *arg2 = 0 ;
57527   Dali::Actor arg3 ;
57528   Dali::Actor *argp3 ;
57529
57530   arg1 = (Dali::Toolkit::Builder *)jarg1;
57531   if (!jarg2) {
57532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57533     return ;
57534   }
57535   std::string arg2_str(jarg2);
57536   arg2 = &arg2_str;
57537   argp3 = (Dali::Actor *)jarg3;
57538   if (!argp3) {
57539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57540     return ;
57541   }
57542   arg3 = *argp3;
57543   {
57544     try {
57545       (arg1)->AddActors((std::string const &)*arg2,arg3);
57546     } catch (std::out_of_range& e) {
57547       {
57548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57549       };
57550     } catch (std::exception& e) {
57551       {
57552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57553       };
57554     } catch (...) {
57555       {
57556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57557       };
57558     }
57559   }
57560
57561   //argout typemap for const std::string&
57562
57563 }
57564
57565
57566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
57567   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57568   std::string *arg2 = 0 ;
57569
57570   arg1 = (Dali::Toolkit::Builder *)jarg1;
57571   if (!jarg2) {
57572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57573     return ;
57574   }
57575   std::string arg2_str(jarg2);
57576   arg2 = &arg2_str;
57577   {
57578     try {
57579       (arg1)->CreateRenderTask((std::string const &)*arg2);
57580     } catch (std::out_of_range& e) {
57581       {
57582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57583       };
57584     } catch (std::exception& e) {
57585       {
57586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57587       };
57588     } catch (...) {
57589       {
57590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57591       };
57592     }
57593   }
57594
57595   //argout typemap for const std::string&
57596
57597 }
57598
57599
57600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
57601   void * jresult ;
57602   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57603   std::string *arg2 = 0 ;
57604   Dali::FrameBufferImage result;
57605
57606   arg1 = (Dali::Toolkit::Builder *)jarg1;
57607   if (!jarg2) {
57608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57609     return 0;
57610   }
57611   std::string arg2_str(jarg2);
57612   arg2 = &arg2_str;
57613   {
57614     try {
57615       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
57616     } catch (std::out_of_range& e) {
57617       {
57618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57619       };
57620     } catch (std::exception& e) {
57621       {
57622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57623       };
57624     } catch (...) {
57625       {
57626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57627       };
57628     }
57629   }
57630   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
57631
57632   //argout typemap for const std::string&
57633
57634   return jresult;
57635 }
57636
57637
57638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
57639   void * jresult ;
57640   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57641   std::string *arg2 = 0 ;
57642   Dali::Path result;
57643
57644   arg1 = (Dali::Toolkit::Builder *)jarg1;
57645   if (!jarg2) {
57646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57647     return 0;
57648   }
57649   std::string arg2_str(jarg2);
57650   arg2 = &arg2_str;
57651   {
57652     try {
57653       result = (arg1)->GetPath((std::string const &)*arg2);
57654     } catch (std::out_of_range& e) {
57655       {
57656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57657       };
57658     } catch (std::exception& e) {
57659       {
57660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57661       };
57662     } catch (...) {
57663       {
57664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57665       };
57666     }
57667   }
57668   jresult = new Dali::Path((const Dali::Path &)result);
57669
57670   //argout typemap for const std::string&
57671
57672   return jresult;
57673 }
57674
57675
57676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
57677   void * jresult ;
57678   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57679   std::string *arg2 = 0 ;
57680   Dali::PathConstrainer result;
57681
57682   arg1 = (Dali::Toolkit::Builder *)jarg1;
57683   if (!jarg2) {
57684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57685     return 0;
57686   }
57687   std::string arg2_str(jarg2);
57688   arg2 = &arg2_str;
57689   {
57690     try {
57691       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
57692     } catch (std::out_of_range& e) {
57693       {
57694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57695       };
57696     } catch (std::exception& e) {
57697       {
57698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57699       };
57700     } catch (...) {
57701       {
57702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57703       };
57704     }
57705   }
57706   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
57707
57708   //argout typemap for const std::string&
57709
57710   return jresult;
57711 }
57712
57713
57714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
57715   void * jresult ;
57716   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57717   std::string *arg2 = 0 ;
57718   Dali::LinearConstrainer result;
57719
57720   arg1 = (Dali::Toolkit::Builder *)jarg1;
57721   if (!jarg2) {
57722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57723     return 0;
57724   }
57725   std::string arg2_str(jarg2);
57726   arg2 = &arg2_str;
57727   {
57728     try {
57729       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
57730     } catch (std::out_of_range& e) {
57731       {
57732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57733       };
57734     } catch (std::exception& e) {
57735       {
57736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57737       };
57738     } catch (...) {
57739       {
57740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57741       };
57742     }
57743   }
57744   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
57745
57746   //argout typemap for const std::string&
57747
57748   return jresult;
57749 }
57750
57751
57752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
57753   void * jresult ;
57754   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57755   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
57756
57757   arg1 = (Dali::Toolkit::Builder *)jarg1;
57758   {
57759     try {
57760       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
57761     } catch (std::out_of_range& e) {
57762       {
57763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57764       };
57765     } catch (std::exception& e) {
57766       {
57767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57768       };
57769     } catch (...) {
57770       {
57771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57772       };
57773     }
57774   }
57775   jresult = (void *)result;
57776   return jresult;
57777 }
57778
57779
57780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
57781   void * jresult ;
57782   Dali::Toolkit::TransitionData *result = 0 ;
57783
57784   {
57785     try {
57786       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
57787     } catch (std::out_of_range& e) {
57788       {
57789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57790       };
57791     } catch (std::exception& e) {
57792       {
57793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57794       };
57795     } catch (...) {
57796       {
57797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57798       };
57799     }
57800   }
57801   jresult = (void *)result;
57802   return jresult;
57803 }
57804
57805
57806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
57807   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
57808
57809   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
57810   {
57811     try {
57812       delete arg1;
57813     } catch (std::out_of_range& e) {
57814       {
57815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57816       };
57817     } catch (std::exception& e) {
57818       {
57819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57820       };
57821     } catch (...) {
57822       {
57823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57824       };
57825     }
57826   }
57827 }
57828
57829
57830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
57831   void * jresult ;
57832   Dali::Property::Map *arg1 = 0 ;
57833   Dali::Toolkit::TransitionData result;
57834
57835   arg1 = (Dali::Property::Map *)jarg1;
57836   if (!arg1) {
57837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57838     return 0;
57839   }
57840   {
57841     try {
57842       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
57843     } catch (std::out_of_range& e) {
57844       {
57845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57846       };
57847     } catch (std::exception& e) {
57848       {
57849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57850       };
57851     } catch (...) {
57852       {
57853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57854       };
57855     }
57856   }
57857   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
57858   return jresult;
57859 }
57860
57861
57862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
57863   void * jresult ;
57864   Dali::Property::Array *arg1 = 0 ;
57865   Dali::Toolkit::TransitionData result;
57866
57867   arg1 = (Dali::Property::Array *)jarg1;
57868   if (!arg1) {
57869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
57870     return 0;
57871   }
57872   {
57873     try {
57874       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
57875     } catch (std::out_of_range& e) {
57876       {
57877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57878       };
57879     } catch (std::exception& e) {
57880       {
57881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57882       };
57883     } catch (...) {
57884       {
57885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57886       };
57887     }
57888   }
57889   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
57890   return jresult;
57891 }
57892
57893
57894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
57895   void * jresult ;
57896   Dali::BaseHandle arg1 ;
57897   Dali::BaseHandle *argp1 ;
57898   Dali::Toolkit::TransitionData result;
57899
57900   argp1 = (Dali::BaseHandle *)jarg1;
57901   if (!argp1) {
57902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
57903     return 0;
57904   }
57905   arg1 = *argp1;
57906   {
57907     try {
57908       result = Dali::Toolkit::TransitionData::DownCast(arg1);
57909     } catch (std::out_of_range& e) {
57910       {
57911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57912       };
57913     } catch (std::exception& e) {
57914       {
57915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57916       };
57917     } catch (...) {
57918       {
57919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57920       };
57921     }
57922   }
57923   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
57924   return jresult;
57925 }
57926
57927
57928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
57929   void * jresult ;
57930   Dali::Toolkit::TransitionData *arg1 = 0 ;
57931   Dali::Toolkit::TransitionData *result = 0 ;
57932
57933   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
57934   if (!arg1) {
57935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
57936     return 0;
57937   }
57938   {
57939     try {
57940       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
57941     } catch (std::out_of_range& e) {
57942       {
57943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57944       };
57945     } catch (std::exception& e) {
57946       {
57947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57948       };
57949     } catch (...) {
57950       {
57951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57952       };
57953     }
57954   }
57955   jresult = (void *)result;
57956   return jresult;
57957 }
57958
57959
57960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
57961   void * jresult ;
57962   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
57963   Dali::Toolkit::TransitionData *arg2 = 0 ;
57964   Dali::Toolkit::TransitionData *result = 0 ;
57965
57966   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
57967   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
57968   if (!arg2) {
57969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
57970     return 0;
57971   }
57972   {
57973     try {
57974       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
57975     } catch (std::out_of_range& e) {
57976       {
57977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57978       };
57979     } catch (std::exception& e) {
57980       {
57981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57982       };
57983     } catch (...) {
57984       {
57985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57986       };
57987     }
57988   }
57989   jresult = (void *)result;
57990   return jresult;
57991 }
57992
57993
57994 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
57995   unsigned long jresult ;
57996   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
57997   size_t result;
57998
57999   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58000   {
58001     try {
58002       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58003     } catch (std::out_of_range& e) {
58004       {
58005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58006       };
58007     } catch (std::exception& e) {
58008       {
58009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58010       };
58011     } catch (...) {
58012       {
58013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58014       };
58015     }
58016   }
58017   jresult = (unsigned long)result;
58018   return jresult;
58019 }
58020
58021
58022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58023   void * jresult ;
58024   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58025   size_t arg2 ;
58026   Dali::Property::Map result;
58027
58028   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58029   arg2 = (size_t)jarg2;
58030   {
58031     try {
58032       result = (arg1)->GetAnimatorAt(arg2);
58033     } catch (std::out_of_range& e) {
58034       {
58035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58036       };
58037     } catch (std::exception& e) {
58038       {
58039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58040       };
58041     } catch (...) {
58042       {
58043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58044       };
58045     }
58046   }
58047   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58048   return jresult;
58049 }
58050
58051
58052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
58053   void * jresult ;
58054   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
58055   Dali::Toolkit::TransitionData *result = 0 ;
58056
58057   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
58058   {
58059     try {
58060       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
58061     } catch (std::out_of_range& e) {
58062       {
58063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58064       };
58065     } catch (std::exception& e) {
58066       {
58067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58068       };
58069     } catch (...) {
58070       {
58071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58072       };
58073     }
58074   }
58075   jresult = (void *)result;
58076   return jresult;
58077 }
58078
58079
58080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58081   int jresult ;
58082   int result;
58083
58084   {
58085     try {
58086       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58087     } catch (std::out_of_range& e) {
58088       {
58089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58090       };
58091     } catch (std::exception& e) {
58092       {
58093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58094       };
58095     } catch (...) {
58096       {
58097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58098       };
58099     }
58100   }
58101   jresult = (int)result;
58102   return jresult;
58103 }
58104
58105
58106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58107   int jresult ;
58108   int result;
58109
58110   {
58111     try {
58112       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58113     } catch (std::out_of_range& e) {
58114       {
58115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58116       };
58117     } catch (std::exception& e) {
58118       {
58119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58120       };
58121     } catch (...) {
58122       {
58123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58124       };
58125     }
58126   }
58127   jresult = (int)result;
58128   return jresult;
58129 }
58130
58131
58132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58133   int jresult ;
58134   int result;
58135
58136   {
58137     try {
58138       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58139     } catch (std::out_of_range& e) {
58140       {
58141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58142       };
58143     } catch (std::exception& e) {
58144       {
58145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58146       };
58147     } catch (...) {
58148       {
58149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58150       };
58151     }
58152   }
58153   jresult = (int)result;
58154   return jresult;
58155 }
58156
58157
58158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58159   int jresult ;
58160   int result;
58161
58162   {
58163     try {
58164       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58165     } catch (std::out_of_range& e) {
58166       {
58167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58168       };
58169     } catch (std::exception& e) {
58170       {
58171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58172       };
58173     } catch (...) {
58174       {
58175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58176       };
58177     }
58178   }
58179   jresult = (int)result;
58180   return jresult;
58181 }
58182
58183
58184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58185   int jresult ;
58186   int result;
58187
58188   {
58189     try {
58190       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58191     } catch (std::out_of_range& e) {
58192       {
58193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58194       };
58195     } catch (std::exception& e) {
58196       {
58197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58198       };
58199     } catch (...) {
58200       {
58201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58202       };
58203     }
58204   }
58205   jresult = (int)result;
58206   return jresult;
58207 }
58208
58209
58210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58211   int jresult ;
58212   int result;
58213
58214   {
58215     try {
58216       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58217     } catch (std::out_of_range& e) {
58218       {
58219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58220       };
58221     } catch (std::exception& e) {
58222       {
58223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58224       };
58225     } catch (...) {
58226       {
58227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58228       };
58229     }
58230   }
58231   jresult = (int)result;
58232   return jresult;
58233 }
58234
58235
58236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58237   int jresult ;
58238   int result;
58239
58240   {
58241     try {
58242       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58243     } catch (std::out_of_range& e) {
58244       {
58245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58246       };
58247     } catch (std::exception& e) {
58248       {
58249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58250       };
58251     } catch (...) {
58252       {
58253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58254       };
58255     }
58256   }
58257   jresult = (int)result;
58258   return jresult;
58259 }
58260
58261
58262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58263   int jresult ;
58264   int result;
58265
58266   {
58267     try {
58268       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58269     } catch (std::out_of_range& e) {
58270       {
58271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58272       };
58273     } catch (std::exception& e) {
58274       {
58275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58276       };
58277     } catch (...) {
58278       {
58279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58280       };
58281     }
58282   }
58283   jresult = (int)result;
58284   return jresult;
58285 }
58286
58287
58288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58289   int jresult ;
58290   int result;
58291
58292   {
58293     try {
58294       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58295     } catch (std::out_of_range& e) {
58296       {
58297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58298       };
58299     } catch (std::exception& e) {
58300       {
58301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58302       };
58303     } catch (...) {
58304       {
58305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58306       };
58307     }
58308   }
58309   jresult = (int)result;
58310   return jresult;
58311 }
58312
58313
58314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58315   int jresult ;
58316   int result;
58317
58318   {
58319     try {
58320       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58321     } catch (std::out_of_range& e) {
58322       {
58323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58324       };
58325     } catch (std::exception& e) {
58326       {
58327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58328       };
58329     } catch (...) {
58330       {
58331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58332       };
58333     }
58334   }
58335   jresult = (int)result;
58336   return jresult;
58337 }
58338
58339
58340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58341   int jresult ;
58342   int result;
58343
58344   {
58345     try {
58346       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
58347     } catch (std::out_of_range& e) {
58348       {
58349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58350       };
58351     } catch (std::exception& e) {
58352       {
58353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58354       };
58355     } catch (...) {
58356       {
58357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58358       };
58359     }
58360   }
58361   jresult = (int)result;
58362   return jresult;
58363 }
58364
58365
58366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
58367   int jresult ;
58368   int result;
58369
58370   {
58371     try {
58372       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
58373     } catch (std::out_of_range& e) {
58374       {
58375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58376       };
58377     } catch (std::exception& e) {
58378       {
58379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58380       };
58381     } catch (...) {
58382       {
58383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58384       };
58385     }
58386   }
58387   jresult = (int)result;
58388   return jresult;
58389 }
58390
58391
58392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
58393   int jresult ;
58394   int result;
58395
58396   {
58397     try {
58398       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
58399     } catch (std::out_of_range& e) {
58400       {
58401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58402       };
58403     } catch (std::exception& e) {
58404       {
58405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58406       };
58407     } catch (...) {
58408       {
58409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58410       };
58411     }
58412   }
58413   jresult = (int)result;
58414   return jresult;
58415 }
58416
58417
58418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
58419   int jresult ;
58420   int result;
58421
58422   {
58423     try {
58424       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
58425     } catch (std::out_of_range& e) {
58426       {
58427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58428       };
58429     } catch (std::exception& e) {
58430       {
58431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58432       };
58433     } catch (...) {
58434       {
58435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58436       };
58437     }
58438   }
58439   jresult = (int)result;
58440   return jresult;
58441 }
58442
58443
58444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
58445   void * jresult ;
58446   Dali::Toolkit::Control result;
58447
58448   {
58449     try {
58450       result = Dali::Toolkit::Internal::Control::New();
58451     } catch (std::out_of_range& e) {
58452       {
58453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58454       };
58455     } catch (std::exception& e) {
58456       {
58457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58458       };
58459     } catch (...) {
58460       {
58461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58462       };
58463     }
58464   }
58465   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58466   return jresult;
58467 }
58468
58469
58470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
58471   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58472   std::string *arg2 = 0 ;
58473
58474   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58475   if (!jarg2) {
58476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58477     return ;
58478   }
58479   std::string arg2_str(jarg2);
58480   arg2 = &arg2_str;
58481   {
58482     try {
58483       (arg1)->SetStyleName((std::string const &)*arg2);
58484     } catch (std::out_of_range& e) {
58485       {
58486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58487       };
58488     } catch (std::exception& e) {
58489       {
58490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58491       };
58492     } catch (...) {
58493       {
58494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58495       };
58496     }
58497   }
58498
58499   //argout typemap for const std::string&
58500
58501 }
58502
58503
58504 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
58505   char * jresult ;
58506   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58507   std::string *result = 0 ;
58508
58509   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58510   {
58511     try {
58512       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
58513     } catch (std::out_of_range& e) {
58514       {
58515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58516       };
58517     } catch (std::exception& e) {
58518       {
58519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58520       };
58521     } catch (...) {
58522       {
58523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58524       };
58525     }
58526   }
58527   jresult = SWIG_csharp_string_callback(result->c_str());
58528   return jresult;
58529 }
58530
58531
58532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
58533   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58534   Dali::Vector4 *arg2 = 0 ;
58535
58536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58537   arg2 = (Dali::Vector4 *)jarg2;
58538   if (!arg2) {
58539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58540     return ;
58541   }
58542   {
58543     try {
58544       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58545     } catch (std::out_of_range& e) {
58546       {
58547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58548       };
58549     } catch (std::exception& e) {
58550       {
58551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58552       };
58553     } catch (...) {
58554       {
58555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58556       };
58557     }
58558   }
58559 }
58560
58561
58562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
58563   void * jresult ;
58564   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58565   Dali::Vector4 result;
58566
58567   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58568   {
58569     try {
58570       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
58571     } catch (std::out_of_range& e) {
58572       {
58573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58574       };
58575     } catch (std::exception& e) {
58576       {
58577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58578       };
58579     } catch (...) {
58580       {
58581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58582       };
58583     }
58584   }
58585   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
58586   return jresult;
58587 }
58588
58589
58590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
58591   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58592   Dali::Image arg2 ;
58593   Dali::Image *argp2 ;
58594
58595   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58596   argp2 = (Dali::Image *)jarg2;
58597   if (!argp2) {
58598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
58599     return ;
58600   }
58601   arg2 = *argp2;
58602   {
58603     try {
58604       (arg1)->SetBackgroundImage(arg2);
58605     } catch (std::out_of_range& e) {
58606       {
58607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58608       };
58609     } catch (std::exception& e) {
58610       {
58611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58612       };
58613     } catch (...) {
58614       {
58615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58616       };
58617     }
58618   }
58619 }
58620
58621
58622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
58623   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58624   Dali::Property::Map *arg2 = 0 ;
58625
58626   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58627   arg2 = (Dali::Property::Map *)jarg2;
58628   if (!arg2) {
58629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58630     return ;
58631   }
58632   {
58633     try {
58634       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
58635     } catch (std::out_of_range& e) {
58636       {
58637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58638       };
58639     } catch (std::exception& e) {
58640       {
58641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58642       };
58643     } catch (...) {
58644       {
58645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58646       };
58647     }
58648   }
58649 }
58650
58651
58652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
58653   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58654
58655   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58656   {
58657     try {
58658       (arg1)->ClearBackground();
58659     } catch (std::out_of_range& e) {
58660       {
58661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58662       };
58663     } catch (std::exception& e) {
58664       {
58665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58666       };
58667     } catch (...) {
58668       {
58669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58670       };
58671     }
58672   }
58673 }
58674
58675
58676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
58677   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58678   Dali::Gesture::Type arg2 ;
58679
58680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58681   arg2 = (Dali::Gesture::Type)jarg2;
58682   {
58683     try {
58684       (arg1)->EnableGestureDetection(arg2);
58685     } catch (std::out_of_range& e) {
58686       {
58687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58688       };
58689     } catch (std::exception& e) {
58690       {
58691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58692       };
58693     } catch (...) {
58694       {
58695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58696       };
58697     }
58698   }
58699 }
58700
58701
58702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
58703   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58704   Dali::Gesture::Type arg2 ;
58705
58706   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58707   arg2 = (Dali::Gesture::Type)jarg2;
58708   {
58709     try {
58710       (arg1)->DisableGestureDetection(arg2);
58711     } catch (std::out_of_range& e) {
58712       {
58713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58714       };
58715     } catch (std::exception& e) {
58716       {
58717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58718       };
58719     } catch (...) {
58720       {
58721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58722       };
58723     }
58724   }
58725 }
58726
58727
58728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
58729   void * jresult ;
58730   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58731   Dali::PinchGestureDetector result;
58732
58733   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58734   {
58735     try {
58736       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
58737     } catch (std::out_of_range& e) {
58738       {
58739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58740       };
58741     } catch (std::exception& e) {
58742       {
58743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58744       };
58745     } catch (...) {
58746       {
58747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58748       };
58749     }
58750   }
58751   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
58752   return jresult;
58753 }
58754
58755
58756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
58757   void * jresult ;
58758   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58759   Dali::PanGestureDetector result;
58760
58761   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58762   {
58763     try {
58764       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
58765     } catch (std::out_of_range& e) {
58766       {
58767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58768       };
58769     } catch (std::exception& e) {
58770       {
58771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58772       };
58773     } catch (...) {
58774       {
58775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58776       };
58777     }
58778   }
58779   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
58780   return jresult;
58781 }
58782
58783
58784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
58785   void * jresult ;
58786   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58787   Dali::TapGestureDetector result;
58788
58789   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58790   {
58791     try {
58792       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
58793     } catch (std::out_of_range& e) {
58794       {
58795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58796       };
58797     } catch (std::exception& e) {
58798       {
58799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58800       };
58801     } catch (...) {
58802       {
58803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58804       };
58805     }
58806   }
58807   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
58808   return jresult;
58809 }
58810
58811
58812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
58813   void * jresult ;
58814   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58815   Dali::LongPressGestureDetector result;
58816
58817   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58818   {
58819     try {
58820       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
58821     } catch (std::out_of_range& e) {
58822       {
58823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58824       };
58825     } catch (std::exception& e) {
58826       {
58827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58828       };
58829     } catch (...) {
58830       {
58831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58832       };
58833     }
58834   }
58835   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
58836   return jresult;
58837 }
58838
58839
58840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
58841   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58842   bool arg2 ;
58843
58844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58845   arg2 = jarg2 ? true : false;
58846   {
58847     try {
58848       (arg1)->SetKeyboardNavigationSupport(arg2);
58849     } catch (std::out_of_range& e) {
58850       {
58851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58852       };
58853     } catch (std::exception& e) {
58854       {
58855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58856       };
58857     } catch (...) {
58858       {
58859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58860       };
58861     }
58862   }
58863 }
58864
58865
58866 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
58867   unsigned int jresult ;
58868   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58869   bool result;
58870
58871   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58872   {
58873     try {
58874       result = (bool)(arg1)->IsKeyboardNavigationSupported();
58875     } catch (std::out_of_range& e) {
58876       {
58877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58878       };
58879     } catch (std::exception& e) {
58880       {
58881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58882       };
58883     } catch (...) {
58884       {
58885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58886       };
58887     }
58888   }
58889   jresult = result;
58890   return jresult;
58891 }
58892
58893
58894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
58895   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58896
58897   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58898   {
58899     try {
58900       (arg1)->SetKeyInputFocus();
58901     } catch (std::out_of_range& e) {
58902       {
58903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58904       };
58905     } catch (std::exception& e) {
58906       {
58907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58908       };
58909     } catch (...) {
58910       {
58911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58912       };
58913     }
58914   }
58915 }
58916
58917
58918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
58919   unsigned int jresult ;
58920   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58921   bool result;
58922
58923   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58924   {
58925     try {
58926       result = (bool)(arg1)->HasKeyInputFocus();
58927     } catch (std::out_of_range& e) {
58928       {
58929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58930       };
58931     } catch (std::exception& e) {
58932       {
58933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58934       };
58935     } catch (...) {
58936       {
58937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58938       };
58939     }
58940   }
58941   jresult = result;
58942   return jresult;
58943 }
58944
58945
58946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
58947   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58948
58949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58950   {
58951     try {
58952       (arg1)->ClearKeyInputFocus();
58953     } catch (std::out_of_range& e) {
58954       {
58955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58956       };
58957     } catch (std::exception& e) {
58958       {
58959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58960       };
58961     } catch (...) {
58962       {
58963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58964       };
58965     }
58966   }
58967 }
58968
58969
58970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
58971   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58972   bool arg2 ;
58973
58974   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58975   arg2 = jarg2 ? true : false;
58976   {
58977     try {
58978       (arg1)->SetAsKeyboardFocusGroup(arg2);
58979     } catch (std::out_of_range& e) {
58980       {
58981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58982       };
58983     } catch (std::exception& e) {
58984       {
58985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58986       };
58987     } catch (...) {
58988       {
58989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58990       };
58991     }
58992   }
58993 }
58994
58995
58996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
58997   unsigned int jresult ;
58998   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58999   bool result;
59000
59001   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59002   {
59003     try {
59004       result = (bool)(arg1)->IsKeyboardFocusGroup();
59005     } catch (std::out_of_range& e) {
59006       {
59007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59008       };
59009     } catch (std::exception& e) {
59010       {
59011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59012       };
59013     } catch (...) {
59014       {
59015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59016       };
59017     }
59018   }
59019   jresult = result;
59020   return jresult;
59021 }
59022
59023
59024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
59025   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59026
59027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59028   {
59029     try {
59030       (arg1)->AccessibilityActivate();
59031     } catch (std::out_of_range& e) {
59032       {
59033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59034       };
59035     } catch (std::exception& e) {
59036       {
59037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59038       };
59039     } catch (...) {
59040       {
59041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59042       };
59043     }
59044   }
59045 }
59046
59047
59048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
59049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59050
59051   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59052   {
59053     try {
59054       (arg1)->KeyboardEnter();
59055     } catch (std::out_of_range& e) {
59056       {
59057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59058       };
59059     } catch (std::exception& e) {
59060       {
59061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59062       };
59063     } catch (...) {
59064       {
59065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59066       };
59067     }
59068   }
59069 }
59070
59071
59072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59073   void * jresult ;
59074   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59075   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59076
59077   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59078   {
59079     try {
59080       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59081     } catch (std::out_of_range& e) {
59082       {
59083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59084       };
59085     } catch (std::exception& e) {
59086       {
59087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59088       };
59089     } catch (...) {
59090       {
59091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59092       };
59093     }
59094   }
59095   jresult = (void *)result;
59096   return jresult;
59097 }
59098
59099
59100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59101   void * jresult ;
59102   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59103   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59104
59105   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59106   {
59107     try {
59108       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59109     } catch (std::out_of_range& e) {
59110       {
59111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59112       };
59113     } catch (std::exception& e) {
59114       {
59115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59116       };
59117     } catch (...) {
59118       {
59119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59120       };
59121     }
59122   }
59123   jresult = (void *)result;
59124   return jresult;
59125 }
59126
59127
59128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59129   void * jresult ;
59130   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59131   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59132
59133   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59134   {
59135     try {
59136       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59137     } catch (std::out_of_range& e) {
59138       {
59139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59140       };
59141     } catch (std::exception& e) {
59142       {
59143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59144       };
59145     } catch (...) {
59146       {
59147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59148       };
59149     }
59150   }
59151   jresult = (void *)result;
59152   return jresult;
59153 }
59154
59155
59156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
59157   unsigned int jresult ;
59158   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59159   Dali::KeyEvent *arg2 = 0 ;
59160   bool result;
59161
59162   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59163   arg2 = (Dali::KeyEvent *)jarg2;
59164   if (!arg2) {
59165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59166     return 0;
59167   }
59168   {
59169     try {
59170       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
59171     } catch (std::out_of_range& e) {
59172       {
59173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59174       };
59175     } catch (std::exception& e) {
59176       {
59177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59178       };
59179     } catch (...) {
59180       {
59181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59182       };
59183     }
59184   }
59185   jresult = result;
59186   return jresult;
59187 }
59188
59189
59190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
59191   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59192   int arg2 ;
59193   SwigDirector_ViewImpl *darg = 0;
59194
59195   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59196   arg2 = (int)jarg2;
59197   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59198   {
59199     try {
59200       (darg)->OnStageConnection(arg2);
59201     } catch (std::out_of_range& e) {
59202       {
59203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59204       };
59205     } catch (std::exception& e) {
59206       {
59207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59208       };
59209     } catch (...) {
59210       {
59211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59212       };
59213     }
59214   }
59215 }
59216
59217
59218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59219   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59220   int arg2 ;
59221   SwigDirector_ViewImpl *darg = 0;
59222
59223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59224   arg2 = (int)jarg2;
59225   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59226   {
59227     try {
59228       (darg)->OnStageConnectionSwigPublic(arg2);
59229     } catch (std::out_of_range& e) {
59230       {
59231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59232       };
59233     } catch (std::exception& e) {
59234       {
59235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59236       };
59237     } catch (...) {
59238       {
59239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59240       };
59241     }
59242   }
59243 }
59244
59245
59246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
59247   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59248   SwigDirector_ViewImpl *darg = 0;
59249
59250   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59251   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59252   {
59253     try {
59254       (darg)->OnStageDisconnection();
59255     } catch (std::out_of_range& e) {
59256       {
59257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59258       };
59259     } catch (std::exception& e) {
59260       {
59261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59262       };
59263     } catch (...) {
59264       {
59265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59266       };
59267     }
59268   }
59269 }
59270
59271
59272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
59273   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59274   SwigDirector_ViewImpl *darg = 0;
59275
59276   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59277   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59278   {
59279     try {
59280       (darg)->OnStageDisconnectionSwigPublic();
59281     } catch (std::out_of_range& e) {
59282       {
59283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59284       };
59285     } catch (std::exception& e) {
59286       {
59287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59288       };
59289     } catch (...) {
59290       {
59291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59292       };
59293     }
59294   }
59295 }
59296
59297
59298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59300   Dali::Actor *arg2 = 0 ;
59301   SwigDirector_ViewImpl *darg = 0;
59302
59303   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59304   arg2 = (Dali::Actor *)jarg2;
59305   if (!arg2) {
59306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59307     return ;
59308   }
59309   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59310   {
59311     try {
59312       (darg)->OnChildAdd(*arg2);
59313     } catch (std::out_of_range& e) {
59314       {
59315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59316       };
59317     } catch (std::exception& e) {
59318       {
59319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59320       };
59321     } catch (...) {
59322       {
59323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59324       };
59325     }
59326   }
59327 }
59328
59329
59330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59331   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59332   Dali::Actor *arg2 = 0 ;
59333   SwigDirector_ViewImpl *darg = 0;
59334
59335   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59336   arg2 = (Dali::Actor *)jarg2;
59337   if (!arg2) {
59338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59339     return ;
59340   }
59341   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59342   {
59343     try {
59344       (darg)->OnChildAddSwigPublic(*arg2);
59345     } catch (std::out_of_range& e) {
59346       {
59347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59348       };
59349     } catch (std::exception& e) {
59350       {
59351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59352       };
59353     } catch (...) {
59354       {
59355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59356       };
59357     }
59358   }
59359 }
59360
59361
59362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
59363   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59364   Dali::Actor *arg2 = 0 ;
59365   SwigDirector_ViewImpl *darg = 0;
59366
59367   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59368   arg2 = (Dali::Actor *)jarg2;
59369   if (!arg2) {
59370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59371     return ;
59372   }
59373   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59374   {
59375     try {
59376       (darg)->OnChildRemove(*arg2);
59377     } catch (std::out_of_range& e) {
59378       {
59379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59380       };
59381     } catch (std::exception& e) {
59382       {
59383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59384       };
59385     } catch (...) {
59386       {
59387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59388       };
59389     }
59390   }
59391 }
59392
59393
59394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59396   Dali::Actor *arg2 = 0 ;
59397   SwigDirector_ViewImpl *darg = 0;
59398
59399   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59400   arg2 = (Dali::Actor *)jarg2;
59401   if (!arg2) {
59402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59403     return ;
59404   }
59405   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59406   {
59407     try {
59408       (darg)->OnChildRemoveSwigPublic(*arg2);
59409     } catch (std::out_of_range& e) {
59410       {
59411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59412       };
59413     } catch (std::exception& e) {
59414       {
59415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59416       };
59417     } catch (...) {
59418       {
59419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59420       };
59421     }
59422   }
59423 }
59424
59425
59426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
59427   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59428   Dali::Property::Index arg2 ;
59429   Dali::Property::Value arg3 ;
59430   Dali::Property::Value *argp3 ;
59431   SwigDirector_ViewImpl *darg = 0;
59432
59433   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59434   arg2 = (Dali::Property::Index)jarg2;
59435   argp3 = (Dali::Property::Value *)jarg3;
59436   if (!argp3) {
59437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59438     return ;
59439   }
59440   arg3 = *argp3;
59441   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59442   {
59443     try {
59444       (darg)->OnPropertySet(arg2,arg3);
59445     } catch (std::out_of_range& e) {
59446       {
59447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59448       };
59449     } catch (std::exception& e) {
59450       {
59451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59452       };
59453     } catch (...) {
59454       {
59455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59456       };
59457     }
59458   }
59459 }
59460
59461
59462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
59463   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59464   Dali::Property::Index arg2 ;
59465   Dali::Property::Value arg3 ;
59466   Dali::Property::Value *argp3 ;
59467   SwigDirector_ViewImpl *darg = 0;
59468
59469   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59470   arg2 = (Dali::Property::Index)jarg2;
59471   argp3 = (Dali::Property::Value *)jarg3;
59472   if (!argp3) {
59473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59474     return ;
59475   }
59476   arg3 = *argp3;
59477   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59478   {
59479     try {
59480       (darg)->OnPropertySetSwigPublic(arg2,arg3);
59481     } catch (std::out_of_range& e) {
59482       {
59483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59484       };
59485     } catch (std::exception& e) {
59486       {
59487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59488       };
59489     } catch (...) {
59490       {
59491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59492       };
59493     }
59494   }
59495 }
59496
59497
59498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
59499   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59500   Dali::Vector3 *arg2 = 0 ;
59501   SwigDirector_ViewImpl *darg = 0;
59502
59503   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59504   arg2 = (Dali::Vector3 *)jarg2;
59505   if (!arg2) {
59506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59507     return ;
59508   }
59509   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59510   {
59511     try {
59512       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
59513     } catch (std::out_of_range& e) {
59514       {
59515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59516       };
59517     } catch (std::exception& e) {
59518       {
59519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59520       };
59521     } catch (...) {
59522       {
59523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59524       };
59525     }
59526   }
59527 }
59528
59529
59530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59531   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59532   Dali::Vector3 *arg2 = 0 ;
59533   SwigDirector_ViewImpl *darg = 0;
59534
59535   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59536   arg2 = (Dali::Vector3 *)jarg2;
59537   if (!arg2) {
59538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59539     return ;
59540   }
59541   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59542   {
59543     try {
59544       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
59545     } catch (std::out_of_range& e) {
59546       {
59547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59548       };
59549     } catch (std::exception& e) {
59550       {
59551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59552       };
59553     } catch (...) {
59554       {
59555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59556       };
59557     }
59558   }
59559 }
59560
59561
59562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
59563   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59564   Dali::Animation *arg2 = 0 ;
59565   Dali::Vector3 *arg3 = 0 ;
59566   SwigDirector_ViewImpl *darg = 0;
59567
59568   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59569   arg2 = (Dali::Animation *)jarg2;
59570   if (!arg2) {
59571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
59572     return ;
59573   }
59574   arg3 = (Dali::Vector3 *)jarg3;
59575   if (!arg3) {
59576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59577     return ;
59578   }
59579   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59580   {
59581     try {
59582       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
59583     } catch (std::out_of_range& e) {
59584       {
59585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59586       };
59587     } catch (std::exception& e) {
59588       {
59589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59590       };
59591     } catch (...) {
59592       {
59593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59594       };
59595     }
59596   }
59597 }
59598
59599
59600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
59601   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59602   Dali::Animation *arg2 = 0 ;
59603   Dali::Vector3 *arg3 = 0 ;
59604   SwigDirector_ViewImpl *darg = 0;
59605
59606   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59607   arg2 = (Dali::Animation *)jarg2;
59608   if (!arg2) {
59609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
59610     return ;
59611   }
59612   arg3 = (Dali::Vector3 *)jarg3;
59613   if (!arg3) {
59614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59615     return ;
59616   }
59617   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59618   {
59619     try {
59620       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
59621     } catch (std::out_of_range& e) {
59622       {
59623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59624       };
59625     } catch (std::exception& e) {
59626       {
59627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59628       };
59629     } catch (...) {
59630       {
59631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59632       };
59633     }
59634   }
59635 }
59636
59637
59638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
59639   unsigned int jresult ;
59640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59641   Dali::TouchEvent *arg2 = 0 ;
59642   SwigDirector_ViewImpl *darg = 0;
59643   bool result;
59644
59645   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59646   arg2 = (Dali::TouchEvent *)jarg2;
59647   if (!arg2) {
59648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
59649     return 0;
59650   }
59651   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59652   {
59653     try {
59654       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
59655     } catch (std::out_of_range& e) {
59656       {
59657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59658       };
59659     } catch (std::exception& e) {
59660       {
59661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59662       };
59663     } catch (...) {
59664       {
59665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59666       };
59667     }
59668   }
59669   jresult = result;
59670   return jresult;
59671 }
59672
59673
59674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59675   unsigned int jresult ;
59676   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59677   Dali::TouchEvent *arg2 = 0 ;
59678   SwigDirector_ViewImpl *darg = 0;
59679   bool result;
59680
59681   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59682   arg2 = (Dali::TouchEvent *)jarg2;
59683   if (!arg2) {
59684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
59685     return 0;
59686   }
59687   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59688   {
59689     try {
59690       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
59691     } catch (std::out_of_range& e) {
59692       {
59693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59694       };
59695     } catch (std::exception& e) {
59696       {
59697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59698       };
59699     } catch (...) {
59700       {
59701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59702       };
59703     }
59704   }
59705   jresult = result;
59706   return jresult;
59707 }
59708
59709
59710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
59711   unsigned int jresult ;
59712   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59713   Dali::HoverEvent *arg2 = 0 ;
59714   SwigDirector_ViewImpl *darg = 0;
59715   bool result;
59716
59717   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59718   arg2 = (Dali::HoverEvent *)jarg2;
59719   if (!arg2) {
59720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
59721     return 0;
59722   }
59723   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59724   {
59725     try {
59726       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
59727     } catch (std::out_of_range& e) {
59728       {
59729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59730       };
59731     } catch (std::exception& e) {
59732       {
59733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59734       };
59735     } catch (...) {
59736       {
59737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59738       };
59739     }
59740   }
59741   jresult = result;
59742   return jresult;
59743 }
59744
59745
59746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59747   unsigned int jresult ;
59748   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59749   Dali::HoverEvent *arg2 = 0 ;
59750   SwigDirector_ViewImpl *darg = 0;
59751   bool result;
59752
59753   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59754   arg2 = (Dali::HoverEvent *)jarg2;
59755   if (!arg2) {
59756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
59757     return 0;
59758   }
59759   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59760   {
59761     try {
59762       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
59763     } catch (std::out_of_range& e) {
59764       {
59765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59766       };
59767     } catch (std::exception& e) {
59768       {
59769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59770       };
59771     } catch (...) {
59772       {
59773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59774       };
59775     }
59776   }
59777   jresult = result;
59778   return jresult;
59779 }
59780
59781
59782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
59783   unsigned int jresult ;
59784   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59785   Dali::KeyEvent *arg2 = 0 ;
59786   SwigDirector_ViewImpl *darg = 0;
59787   bool result;
59788
59789   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59790   arg2 = (Dali::KeyEvent *)jarg2;
59791   if (!arg2) {
59792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59793     return 0;
59794   }
59795   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59796   {
59797     try {
59798       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
59799     } catch (std::out_of_range& e) {
59800       {
59801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59802       };
59803     } catch (std::exception& e) {
59804       {
59805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59806       };
59807     } catch (...) {
59808       {
59809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59810       };
59811     }
59812   }
59813   jresult = result;
59814   return jresult;
59815 }
59816
59817
59818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59819   unsigned int jresult ;
59820   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59821   Dali::KeyEvent *arg2 = 0 ;
59822   SwigDirector_ViewImpl *darg = 0;
59823   bool result;
59824
59825   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59826   arg2 = (Dali::KeyEvent *)jarg2;
59827   if (!arg2) {
59828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59829     return 0;
59830   }
59831   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59832   {
59833     try {
59834       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
59835     } catch (std::out_of_range& e) {
59836       {
59837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59838       };
59839     } catch (std::exception& e) {
59840       {
59841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59842       };
59843     } catch (...) {
59844       {
59845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59846       };
59847     }
59848   }
59849   jresult = result;
59850   return jresult;
59851 }
59852
59853
59854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
59855   unsigned int jresult ;
59856   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59857   Dali::WheelEvent *arg2 = 0 ;
59858   SwigDirector_ViewImpl *darg = 0;
59859   bool result;
59860
59861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59862   arg2 = (Dali::WheelEvent *)jarg2;
59863   if (!arg2) {
59864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
59865     return 0;
59866   }
59867   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59868   {
59869     try {
59870       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
59871     } catch (std::out_of_range& e) {
59872       {
59873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59874       };
59875     } catch (std::exception& e) {
59876       {
59877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59878       };
59879     } catch (...) {
59880       {
59881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59882       };
59883     }
59884   }
59885   jresult = result;
59886   return jresult;
59887 }
59888
59889
59890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59891   unsigned int jresult ;
59892   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59893   Dali::WheelEvent *arg2 = 0 ;
59894   SwigDirector_ViewImpl *darg = 0;
59895   bool result;
59896
59897   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59898   arg2 = (Dali::WheelEvent *)jarg2;
59899   if (!arg2) {
59900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
59901     return 0;
59902   }
59903   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59904   {
59905     try {
59906       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
59907     } catch (std::out_of_range& e) {
59908       {
59909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59910       };
59911     } catch (std::exception& e) {
59912       {
59913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59914       };
59915     } catch (...) {
59916       {
59917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59918       };
59919     }
59920   }
59921   jresult = result;
59922   return jresult;
59923 }
59924
59925
59926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
59927   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59928   Dali::Vector2 *arg2 = 0 ;
59929   Dali::RelayoutContainer *arg3 = 0 ;
59930   SwigDirector_ViewImpl *darg = 0;
59931
59932   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59933   arg2 = (Dali::Vector2 *)jarg2;
59934   if (!arg2) {
59935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
59936     return ;
59937   }
59938   arg3 = (Dali::RelayoutContainer *)jarg3;
59939   if (!arg3) {
59940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
59941     return ;
59942   }
59943   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59944   {
59945     try {
59946       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
59947     } catch (std::out_of_range& e) {
59948       {
59949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59950       };
59951     } catch (std::exception& e) {
59952       {
59953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59954       };
59955     } catch (...) {
59956       {
59957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59958       };
59959     }
59960   }
59961 }
59962
59963
59964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
59965   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59966   Dali::Vector2 *arg2 = 0 ;
59967   Dali::RelayoutContainer *arg3 = 0 ;
59968   SwigDirector_ViewImpl *darg = 0;
59969
59970   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59971   arg2 = (Dali::Vector2 *)jarg2;
59972   if (!arg2) {
59973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
59974     return ;
59975   }
59976   arg3 = (Dali::RelayoutContainer *)jarg3;
59977   if (!arg3) {
59978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
59979     return ;
59980   }
59981   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59982   {
59983     try {
59984       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
59985     } catch (std::out_of_range& e) {
59986       {
59987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59988       };
59989     } catch (std::exception& e) {
59990       {
59991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59992       };
59993     } catch (...) {
59994       {
59995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59996       };
59997     }
59998   }
59999 }
60000
60001
60002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60003   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60004   Dali::ResizePolicy::Type arg2 ;
60005   Dali::Dimension::Type arg3 ;
60006   SwigDirector_ViewImpl *darg = 0;
60007
60008   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60009   arg2 = (Dali::ResizePolicy::Type)jarg2;
60010   arg3 = (Dali::Dimension::Type)jarg3;
60011   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60012   {
60013     try {
60014       (darg)->OnSetResizePolicy(arg2,arg3);
60015     } catch (std::out_of_range& e) {
60016       {
60017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60018       };
60019     } catch (std::exception& e) {
60020       {
60021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60022       };
60023     } catch (...) {
60024       {
60025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60026       };
60027     }
60028   }
60029 }
60030
60031
60032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60033   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60034   Dali::ResizePolicy::Type arg2 ;
60035   Dali::Dimension::Type arg3 ;
60036   SwigDirector_ViewImpl *darg = 0;
60037
60038   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60039   arg2 = (Dali::ResizePolicy::Type)jarg2;
60040   arg3 = (Dali::Dimension::Type)jarg3;
60041   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60042   {
60043     try {
60044       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60045     } catch (std::out_of_range& e) {
60046       {
60047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60048       };
60049     } catch (std::exception& e) {
60050       {
60051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60052       };
60053     } catch (...) {
60054       {
60055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60056       };
60057     }
60058   }
60059 }
60060
60061
60062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60063   void * jresult ;
60064   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60065   SwigDirector_ViewImpl *darg = 0;
60066   Dali::Vector3 result;
60067
60068   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60069   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60070   {
60071     try {
60072       result = (darg)->GetNaturalSize();
60073     } catch (std::out_of_range& e) {
60074       {
60075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60076       };
60077     } catch (std::exception& e) {
60078       {
60079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60080       };
60081     } catch (...) {
60082       {
60083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60084       };
60085     }
60086   }
60087   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60088   return jresult;
60089 }
60090
60091
60092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60093   void * jresult ;
60094   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60095   SwigDirector_ViewImpl *darg = 0;
60096   Dali::Vector3 result;
60097
60098   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60099   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60100   {
60101     try {
60102       result = (darg)->GetNaturalSizeSwigPublic();
60103     } catch (std::out_of_range& e) {
60104       {
60105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60106       };
60107     } catch (std::exception& e) {
60108       {
60109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60110       };
60111     } catch (...) {
60112       {
60113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60114       };
60115     }
60116   }
60117   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60118   return jresult;
60119 }
60120
60121
60122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60123   float jresult ;
60124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60125   Dali::Actor *arg2 = 0 ;
60126   Dali::Dimension::Type arg3 ;
60127   SwigDirector_ViewImpl *darg = 0;
60128   float result;
60129
60130   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60131   arg2 = (Dali::Actor *)jarg2;
60132   if (!arg2) {
60133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60134     return 0;
60135   }
60136   arg3 = (Dali::Dimension::Type)jarg3;
60137   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60138   {
60139     try {
60140       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
60141     } catch (std::out_of_range& e) {
60142       {
60143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60144       };
60145     } catch (std::exception& e) {
60146       {
60147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60148       };
60149     } catch (...) {
60150       {
60151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60152       };
60153     }
60154   }
60155   jresult = result;
60156   return jresult;
60157 }
60158
60159
60160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60161   float jresult ;
60162   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60163   Dali::Actor *arg2 = 0 ;
60164   Dali::Dimension::Type arg3 ;
60165   SwigDirector_ViewImpl *darg = 0;
60166   float result;
60167
60168   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60169   arg2 = (Dali::Actor *)jarg2;
60170   if (!arg2) {
60171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60172     return 0;
60173   }
60174   arg3 = (Dali::Dimension::Type)jarg3;
60175   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60176   {
60177     try {
60178       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
60179     } catch (std::out_of_range& e) {
60180       {
60181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60182       };
60183     } catch (std::exception& e) {
60184       {
60185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60186       };
60187     } catch (...) {
60188       {
60189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60190       };
60191     }
60192   }
60193   jresult = result;
60194   return jresult;
60195 }
60196
60197
60198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
60199   float jresult ;
60200   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60201   float arg2 ;
60202   SwigDirector_ViewImpl *darg = 0;
60203   float result;
60204
60205   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60206   arg2 = (float)jarg2;
60207   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60208   {
60209     try {
60210       result = (float)(darg)->GetHeightForWidth(arg2);
60211     } catch (std::out_of_range& e) {
60212       {
60213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60214       };
60215     } catch (std::exception& e) {
60216       {
60217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60218       };
60219     } catch (...) {
60220       {
60221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60222       };
60223     }
60224   }
60225   jresult = result;
60226   return jresult;
60227 }
60228
60229
60230 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
60231   float jresult ;
60232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60233   float arg2 ;
60234   SwigDirector_ViewImpl *darg = 0;
60235   float result;
60236
60237   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60238   arg2 = (float)jarg2;
60239   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60240   {
60241     try {
60242       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
60243     } catch (std::out_of_range& e) {
60244       {
60245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60246       };
60247     } catch (std::exception& e) {
60248       {
60249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60250       };
60251     } catch (...) {
60252       {
60253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60254       };
60255     }
60256   }
60257   jresult = result;
60258   return jresult;
60259 }
60260
60261
60262 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
60263   float jresult ;
60264   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60265   float arg2 ;
60266   SwigDirector_ViewImpl *darg = 0;
60267   float result;
60268
60269   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60270   arg2 = (float)jarg2;
60271   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60272   {
60273     try {
60274       result = (float)(darg)->GetWidthForHeight(arg2);
60275     } catch (std::out_of_range& e) {
60276       {
60277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60278       };
60279     } catch (std::exception& e) {
60280       {
60281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60282       };
60283     } catch (...) {
60284       {
60285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60286       };
60287     }
60288   }
60289   jresult = result;
60290   return jresult;
60291 }
60292
60293
60294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
60295   float jresult ;
60296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60297   float arg2 ;
60298   SwigDirector_ViewImpl *darg = 0;
60299   float result;
60300
60301   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60302   arg2 = (float)jarg2;
60303   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60304   {
60305     try {
60306       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
60307     } catch (std::out_of_range& e) {
60308       {
60309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60310       };
60311     } catch (std::exception& e) {
60312       {
60313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60314       };
60315     } catch (...) {
60316       {
60317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60318       };
60319     }
60320   }
60321   jresult = result;
60322   return jresult;
60323 }
60324
60325
60326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
60327   unsigned int jresult ;
60328   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60329   Dali::Dimension::Type arg2 ;
60330   SwigDirector_ViewImpl *darg = 0;
60331   bool result;
60332
60333   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60334   arg2 = (Dali::Dimension::Type)jarg2;
60335   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60336   {
60337     try {
60338       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
60339     } catch (std::out_of_range& e) {
60340       {
60341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60342       };
60343     } catch (std::exception& e) {
60344       {
60345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60346       };
60347     } catch (...) {
60348       {
60349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60350       };
60351     }
60352   }
60353   jresult = result;
60354   return jresult;
60355 }
60356
60357
60358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
60359   unsigned int jresult ;
60360   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60361   Dali::Dimension::Type arg2 ;
60362   SwigDirector_ViewImpl *darg = 0;
60363   bool result;
60364
60365   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60366   arg2 = (Dali::Dimension::Type)jarg2;
60367   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60368   {
60369     try {
60370       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
60371     } catch (std::out_of_range& e) {
60372       {
60373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60374       };
60375     } catch (std::exception& e) {
60376       {
60377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60378       };
60379     } catch (...) {
60380       {
60381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60382       };
60383     }
60384   }
60385   jresult = result;
60386   return jresult;
60387 }
60388
60389
60390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
60391   unsigned int jresult ;
60392   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60393   SwigDirector_ViewImpl *darg = 0;
60394   bool result;
60395
60396   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60397   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60398   {
60399     try {
60400       result = (bool)(darg)->RelayoutDependentOnChildren();
60401     } catch (std::out_of_range& e) {
60402       {
60403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60404       };
60405     } catch (std::exception& e) {
60406       {
60407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60408       };
60409     } catch (...) {
60410       {
60411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60412       };
60413     }
60414   }
60415   jresult = result;
60416   return jresult;
60417 }
60418
60419
60420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
60421   unsigned int jresult ;
60422   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60423   SwigDirector_ViewImpl *darg = 0;
60424   bool result;
60425
60426   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60427   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60428   {
60429     try {
60430       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
60431     } catch (std::out_of_range& e) {
60432       {
60433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60434       };
60435     } catch (std::exception& e) {
60436       {
60437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60438       };
60439     } catch (...) {
60440       {
60441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60442       };
60443     }
60444   }
60445   jresult = result;
60446   return jresult;
60447 }
60448
60449
60450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
60451   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60452   Dali::Dimension::Type arg2 ;
60453   SwigDirector_ViewImpl *darg = 0;
60454
60455   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60456   arg2 = (Dali::Dimension::Type)jarg2;
60457   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60458   {
60459     try {
60460       (darg)->OnCalculateRelayoutSize(arg2);
60461     } catch (std::out_of_range& e) {
60462       {
60463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60464       };
60465     } catch (std::exception& e) {
60466       {
60467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60468       };
60469     } catch (...) {
60470       {
60471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60472       };
60473     }
60474   }
60475 }
60476
60477
60478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
60479   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60480   Dali::Dimension::Type arg2 ;
60481   SwigDirector_ViewImpl *darg = 0;
60482
60483   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60484   arg2 = (Dali::Dimension::Type)jarg2;
60485   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60486   {
60487     try {
60488       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
60489     } catch (std::out_of_range& e) {
60490       {
60491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60492       };
60493     } catch (std::exception& e) {
60494       {
60495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60496       };
60497     } catch (...) {
60498       {
60499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60500       };
60501     }
60502   }
60503 }
60504
60505
60506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
60507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60508   float arg2 ;
60509   Dali::Dimension::Type arg3 ;
60510   SwigDirector_ViewImpl *darg = 0;
60511
60512   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60513   arg2 = (float)jarg2;
60514   arg3 = (Dali::Dimension::Type)jarg3;
60515   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60516   {
60517     try {
60518       (darg)->OnLayoutNegotiated(arg2,arg3);
60519     } catch (std::out_of_range& e) {
60520       {
60521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60522       };
60523     } catch (std::exception& e) {
60524       {
60525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60526       };
60527     } catch (...) {
60528       {
60529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60530       };
60531     }
60532   }
60533 }
60534
60535
60536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
60537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60538   float arg2 ;
60539   Dali::Dimension::Type arg3 ;
60540   SwigDirector_ViewImpl *darg = 0;
60541
60542   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60543   arg2 = (float)jarg2;
60544   arg3 = (Dali::Dimension::Type)jarg3;
60545   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60546   {
60547     try {
60548       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
60549     } catch (std::out_of_range& e) {
60550       {
60551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60552       };
60553     } catch (std::exception& e) {
60554       {
60555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60556       };
60557     } catch (...) {
60558       {
60559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60560       };
60561     }
60562   }
60563 }
60564
60565
60566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
60567   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60568
60569   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60570   {
60571     try {
60572       (arg1)->OnInitialize();
60573     } catch (std::out_of_range& e) {
60574       {
60575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60576       };
60577     } catch (std::exception& e) {
60578       {
60579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60580       };
60581     } catch (...) {
60582       {
60583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60584       };
60585     }
60586   }
60587 }
60588
60589
60590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
60591   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60592
60593   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60594   {
60595     try {
60596       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
60597     } catch (std::out_of_range& e) {
60598       {
60599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60600       };
60601     } catch (std::exception& e) {
60602       {
60603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60604       };
60605     } catch (...) {
60606       {
60607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60608       };
60609     }
60610   }
60611 }
60612
60613
60614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
60615   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60616   Dali::Actor *arg2 = 0 ;
60617
60618   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60619   arg2 = (Dali::Actor *)jarg2;
60620   if (!arg2) {
60621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60622     return ;
60623   }
60624   {
60625     try {
60626       (arg1)->OnControlChildAdd(*arg2);
60627     } catch (std::out_of_range& e) {
60628       {
60629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60630       };
60631     } catch (std::exception& e) {
60632       {
60633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60634       };
60635     } catch (...) {
60636       {
60637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60638       };
60639     }
60640   }
60641 }
60642
60643
60644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60645   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60646   Dali::Actor *arg2 = 0 ;
60647
60648   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60649   arg2 = (Dali::Actor *)jarg2;
60650   if (!arg2) {
60651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60652     return ;
60653   }
60654   {
60655     try {
60656       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
60657     } catch (std::out_of_range& e) {
60658       {
60659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60660       };
60661     } catch (std::exception& e) {
60662       {
60663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60664       };
60665     } catch (...) {
60666       {
60667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60668       };
60669     }
60670   }
60671 }
60672
60673
60674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
60675   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60676   Dali::Actor *arg2 = 0 ;
60677
60678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60679   arg2 = (Dali::Actor *)jarg2;
60680   if (!arg2) {
60681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60682     return ;
60683   }
60684   {
60685     try {
60686       (arg1)->OnControlChildRemove(*arg2);
60687     } catch (std::out_of_range& e) {
60688       {
60689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60690       };
60691     } catch (std::exception& e) {
60692       {
60693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60694       };
60695     } catch (...) {
60696       {
60697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60698       };
60699     }
60700   }
60701 }
60702
60703
60704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60705   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60706   Dali::Actor *arg2 = 0 ;
60707
60708   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60709   arg2 = (Dali::Actor *)jarg2;
60710   if (!arg2) {
60711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60712     return ;
60713   }
60714   {
60715     try {
60716       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
60717     } catch (std::out_of_range& e) {
60718       {
60719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60720       };
60721     } catch (std::exception& e) {
60722       {
60723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60724       };
60725     } catch (...) {
60726       {
60727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60728       };
60729     }
60730   }
60731 }
60732
60733
60734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
60735   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60736   Dali::Toolkit::StyleManager arg2 ;
60737   Dali::StyleChange::Type arg3 ;
60738   Dali::Toolkit::StyleManager *argp2 ;
60739
60740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60741   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
60742   if (!argp2) {
60743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
60744     return ;
60745   }
60746   arg2 = *argp2;
60747   arg3 = (Dali::StyleChange::Type)jarg3;
60748   {
60749     try {
60750       (arg1)->OnStyleChange(arg2,arg3);
60751     } catch (std::out_of_range& e) {
60752       {
60753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60754       };
60755     } catch (std::exception& e) {
60756       {
60757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60758       };
60759     } catch (...) {
60760       {
60761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60762       };
60763     }
60764   }
60765 }
60766
60767
60768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60769   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60770   Dali::Toolkit::StyleManager arg2 ;
60771   Dali::StyleChange::Type arg3 ;
60772   Dali::Toolkit::StyleManager *argp2 ;
60773
60774   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60775   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
60776   if (!argp2) {
60777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
60778     return ;
60779   }
60780   arg2 = *argp2;
60781   arg3 = (Dali::StyleChange::Type)jarg3;
60782   {
60783     try {
60784       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
60785     } catch (std::out_of_range& e) {
60786       {
60787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60788       };
60789     } catch (std::exception& e) {
60790       {
60791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60792       };
60793     } catch (...) {
60794       {
60795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60796       };
60797     }
60798   }
60799 }
60800
60801
60802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
60803   unsigned int jresult ;
60804   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60805   bool result;
60806
60807   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60808   {
60809     try {
60810       result = (bool)(arg1)->OnAccessibilityActivated();
60811     } catch (std::out_of_range& e) {
60812       {
60813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60814       };
60815     } catch (std::exception& e) {
60816       {
60817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60818       };
60819     } catch (...) {
60820       {
60821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60822       };
60823     }
60824   }
60825   jresult = result;
60826   return jresult;
60827 }
60828
60829
60830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
60831   unsigned int jresult ;
60832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60833   bool result;
60834
60835   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60836   {
60837     try {
60838       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
60839     } catch (std::out_of_range& e) {
60840       {
60841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60842       };
60843     } catch (std::exception& e) {
60844       {
60845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60846       };
60847     } catch (...) {
60848       {
60849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60850       };
60851     }
60852   }
60853   jresult = result;
60854   return jresult;
60855 }
60856
60857
60858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
60859   unsigned int jresult ;
60860   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60861   Dali::PanGesture arg2 ;
60862   Dali::PanGesture *argp2 ;
60863   bool result;
60864
60865   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60866   argp2 = (Dali::PanGesture *)jarg2;
60867   if (!argp2) {
60868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
60869     return 0;
60870   }
60871   arg2 = *argp2;
60872   {
60873     try {
60874       result = (bool)(arg1)->OnAccessibilityPan(arg2);
60875     } catch (std::out_of_range& e) {
60876       {
60877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60878       };
60879     } catch (std::exception& e) {
60880       {
60881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60882       };
60883     } catch (...) {
60884       {
60885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60886       };
60887     }
60888   }
60889   jresult = result;
60890   return jresult;
60891 }
60892
60893
60894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60895   unsigned int jresult ;
60896   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60897   Dali::PanGesture arg2 ;
60898   Dali::PanGesture *argp2 ;
60899   bool result;
60900
60901   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60902   argp2 = (Dali::PanGesture *)jarg2;
60903   if (!argp2) {
60904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
60905     return 0;
60906   }
60907   arg2 = *argp2;
60908   {
60909     try {
60910       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
60911     } catch (std::out_of_range& e) {
60912       {
60913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60914       };
60915     } catch (std::exception& e) {
60916       {
60917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60918       };
60919     } catch (...) {
60920       {
60921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60922       };
60923     }
60924   }
60925   jresult = result;
60926   return jresult;
60927 }
60928
60929
60930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
60931   unsigned int jresult ;
60932   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60933   Dali::TouchEvent *arg2 = 0 ;
60934   bool result;
60935
60936   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60937   arg2 = (Dali::TouchEvent *)jarg2;
60938   if (!arg2) {
60939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60940     return 0;
60941   }
60942   {
60943     try {
60944       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
60945     } catch (std::out_of_range& e) {
60946       {
60947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60948       };
60949     } catch (std::exception& e) {
60950       {
60951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60952       };
60953     } catch (...) {
60954       {
60955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60956       };
60957     }
60958   }
60959   jresult = result;
60960   return jresult;
60961 }
60962
60963
60964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60965   unsigned int jresult ;
60966   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60967   Dali::TouchEvent *arg2 = 0 ;
60968   bool result;
60969
60970   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60971   arg2 = (Dali::TouchEvent *)jarg2;
60972   if (!arg2) {
60973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60974     return 0;
60975   }
60976   {
60977     try {
60978       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
60979     } catch (std::out_of_range& e) {
60980       {
60981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60982       };
60983     } catch (std::exception& e) {
60984       {
60985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60986       };
60987     } catch (...) {
60988       {
60989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60990       };
60991     }
60992   }
60993   jresult = result;
60994   return jresult;
60995 }
60996
60997
60998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
60999   unsigned int jresult ;
61000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61001   bool arg2 ;
61002   bool result;
61003
61004   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61005   arg2 = jarg2 ? true : false;
61006   {
61007     try {
61008       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61009     } catch (std::out_of_range& e) {
61010       {
61011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61012       };
61013     } catch (std::exception& e) {
61014       {
61015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61016       };
61017     } catch (...) {
61018       {
61019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61020       };
61021     }
61022   }
61023   jresult = result;
61024   return jresult;
61025 }
61026
61027
61028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61029   unsigned int jresult ;
61030   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61031   bool arg2 ;
61032   bool result;
61033
61034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61035   arg2 = jarg2 ? true : false;
61036   {
61037     try {
61038       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61039     } catch (std::out_of_range& e) {
61040       {
61041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61042       };
61043     } catch (std::exception& e) {
61044       {
61045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61046       };
61047     } catch (...) {
61048       {
61049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61050       };
61051     }
61052   }
61053   jresult = result;
61054   return jresult;
61055 }
61056
61057
61058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61059   unsigned int jresult ;
61060   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61061   bool result;
61062
61063   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61064   {
61065     try {
61066       result = (bool)(arg1)->OnAccessibilityZoom();
61067     } catch (std::out_of_range& e) {
61068       {
61069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61070       };
61071     } catch (std::exception& e) {
61072       {
61073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61074       };
61075     } catch (...) {
61076       {
61077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61078       };
61079     }
61080   }
61081   jresult = result;
61082   return jresult;
61083 }
61084
61085
61086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61087   unsigned int jresult ;
61088   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61089   bool result;
61090
61091   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61092   {
61093     try {
61094       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61095     } catch (std::out_of_range& e) {
61096       {
61097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61098       };
61099     } catch (std::exception& e) {
61100       {
61101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61102       };
61103     } catch (...) {
61104       {
61105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61106       };
61107     }
61108   }
61109   jresult = result;
61110   return jresult;
61111 }
61112
61113
61114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61116
61117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61118   {
61119     try {
61120       (arg1)->OnKeyInputFocusGained();
61121     } catch (std::out_of_range& e) {
61122       {
61123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61124       };
61125     } catch (std::exception& e) {
61126       {
61127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61128       };
61129     } catch (...) {
61130       {
61131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61132       };
61133     }
61134   }
61135 }
61136
61137
61138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
61139   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61140
61141   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61142   {
61143     try {
61144       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
61145     } catch (std::out_of_range& e) {
61146       {
61147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61148       };
61149     } catch (std::exception& e) {
61150       {
61151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61152       };
61153     } catch (...) {
61154       {
61155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61156       };
61157     }
61158   }
61159 }
61160
61161
61162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
61163   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61164
61165   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61166   {
61167     try {
61168       (arg1)->OnKeyInputFocusLost();
61169     } catch (std::out_of_range& e) {
61170       {
61171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61172       };
61173     } catch (std::exception& e) {
61174       {
61175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61176       };
61177     } catch (...) {
61178       {
61179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61180       };
61181     }
61182   }
61183 }
61184
61185
61186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
61187   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61188
61189   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61190   {
61191     try {
61192       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
61193     } catch (std::out_of_range& e) {
61194       {
61195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61196       };
61197     } catch (std::exception& e) {
61198       {
61199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61200       };
61201     } catch (...) {
61202       {
61203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61204       };
61205     }
61206   }
61207 }
61208
61209
61210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61211   void * jresult ;
61212   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61213   Dali::Actor arg2 ;
61214   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61215   bool arg4 ;
61216   Dali::Actor *argp2 ;
61217   Dali::Actor result;
61218
61219   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61220   argp2 = (Dali::Actor *)jarg2;
61221   if (!argp2) {
61222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61223     return 0;
61224   }
61225   arg2 = *argp2;
61226   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61227   arg4 = jarg4 ? true : false;
61228   {
61229     try {
61230       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61231     } catch (std::out_of_range& e) {
61232       {
61233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61234       };
61235     } catch (std::exception& e) {
61236       {
61237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61238       };
61239     } catch (...) {
61240       {
61241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61242       };
61243     }
61244   }
61245   jresult = new Dali::Actor((const Dali::Actor &)result);
61246   return jresult;
61247 }
61248
61249
61250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61251   void * jresult ;
61252   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61253   Dali::Actor arg2 ;
61254   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61255   bool arg4 ;
61256   Dali::Actor *argp2 ;
61257   Dali::Actor result;
61258
61259   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61260   argp2 = (Dali::Actor *)jarg2;
61261   if (!argp2) {
61262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61263     return 0;
61264   }
61265   arg2 = *argp2;
61266   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61267   arg4 = jarg4 ? true : false;
61268   {
61269     try {
61270       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61271     } catch (std::out_of_range& e) {
61272       {
61273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61274       };
61275     } catch (std::exception& e) {
61276       {
61277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61278       };
61279     } catch (...) {
61280       {
61281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61282       };
61283     }
61284   }
61285   jresult = new Dali::Actor((const Dali::Actor &)result);
61286   return jresult;
61287 }
61288
61289
61290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
61291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61292   Dali::Actor arg2 ;
61293   Dali::Actor *argp2 ;
61294
61295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61296   argp2 = (Dali::Actor *)jarg2;
61297   if (!argp2) {
61298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61299     return ;
61300   }
61301   arg2 = *argp2;
61302   {
61303     try {
61304       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
61305     } catch (std::out_of_range& e) {
61306       {
61307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61308       };
61309     } catch (std::exception& e) {
61310       {
61311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61312       };
61313     } catch (...) {
61314       {
61315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61316       };
61317     }
61318   }
61319 }
61320
61321
61322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61324   Dali::Actor arg2 ;
61325   Dali::Actor *argp2 ;
61326
61327   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61328   argp2 = (Dali::Actor *)jarg2;
61329   if (!argp2) {
61330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61331     return ;
61332   }
61333   arg2 = *argp2;
61334   {
61335     try {
61336       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
61337     } catch (std::out_of_range& e) {
61338       {
61339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61340       };
61341     } catch (std::exception& e) {
61342       {
61343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61344       };
61345     } catch (...) {
61346       {
61347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61348       };
61349     }
61350   }
61351 }
61352
61353
61354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
61355   unsigned int jresult ;
61356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61357   bool result;
61358
61359   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61360   {
61361     try {
61362       result = (bool)(arg1)->OnKeyboardEnter();
61363     } catch (std::out_of_range& e) {
61364       {
61365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61366       };
61367     } catch (std::exception& e) {
61368       {
61369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61370       };
61371     } catch (...) {
61372       {
61373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61374       };
61375     }
61376   }
61377   jresult = result;
61378   return jresult;
61379 }
61380
61381
61382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
61383   unsigned int jresult ;
61384   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61385   bool result;
61386
61387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61388   {
61389     try {
61390       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
61391     } catch (std::out_of_range& e) {
61392       {
61393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61394       };
61395     } catch (std::exception& e) {
61396       {
61397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61398       };
61399     } catch (...) {
61400       {
61401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61402       };
61403     }
61404   }
61405   jresult = result;
61406   return jresult;
61407 }
61408
61409
61410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
61411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61412   Dali::PinchGesture *arg2 = 0 ;
61413
61414   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61415   arg2 = (Dali::PinchGesture *)jarg2;
61416   if (!arg2) {
61417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61418     return ;
61419   }
61420   {
61421     try {
61422       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
61423     } catch (std::out_of_range& e) {
61424       {
61425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61426       };
61427     } catch (std::exception& e) {
61428       {
61429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61430       };
61431     } catch (...) {
61432       {
61433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61434       };
61435     }
61436   }
61437 }
61438
61439
61440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61442   Dali::PinchGesture *arg2 = 0 ;
61443
61444   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61445   arg2 = (Dali::PinchGesture *)jarg2;
61446   if (!arg2) {
61447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61448     return ;
61449   }
61450   {
61451     try {
61452       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
61453     } catch (std::out_of_range& e) {
61454       {
61455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61456       };
61457     } catch (std::exception& e) {
61458       {
61459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61460       };
61461     } catch (...) {
61462       {
61463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61464       };
61465     }
61466   }
61467 }
61468
61469
61470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
61471   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61472   Dali::PanGesture *arg2 = 0 ;
61473
61474   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61475   arg2 = (Dali::PanGesture *)jarg2;
61476   if (!arg2) {
61477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61478     return ;
61479   }
61480   {
61481     try {
61482       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
61483     } catch (std::out_of_range& e) {
61484       {
61485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61486       };
61487     } catch (std::exception& e) {
61488       {
61489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61490       };
61491     } catch (...) {
61492       {
61493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61494       };
61495     }
61496   }
61497 }
61498
61499
61500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61501   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61502   Dali::PanGesture *arg2 = 0 ;
61503
61504   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61505   arg2 = (Dali::PanGesture *)jarg2;
61506   if (!arg2) {
61507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61508     return ;
61509   }
61510   {
61511     try {
61512       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
61513     } catch (std::out_of_range& e) {
61514       {
61515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61516       };
61517     } catch (std::exception& e) {
61518       {
61519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61520       };
61521     } catch (...) {
61522       {
61523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61524       };
61525     }
61526   }
61527 }
61528
61529
61530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
61531   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61532   Dali::TapGesture *arg2 = 0 ;
61533
61534   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61535   arg2 = (Dali::TapGesture *)jarg2;
61536   if (!arg2) {
61537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
61538     return ;
61539   }
61540   {
61541     try {
61542       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
61543     } catch (std::out_of_range& e) {
61544       {
61545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61546       };
61547     } catch (std::exception& e) {
61548       {
61549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61550       };
61551     } catch (...) {
61552       {
61553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61554       };
61555     }
61556   }
61557 }
61558
61559
61560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61561   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61562   Dali::TapGesture *arg2 = 0 ;
61563
61564   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61565   arg2 = (Dali::TapGesture *)jarg2;
61566   if (!arg2) {
61567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
61568     return ;
61569   }
61570   {
61571     try {
61572       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
61573     } catch (std::out_of_range& e) {
61574       {
61575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61576       };
61577     } catch (std::exception& e) {
61578       {
61579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61580       };
61581     } catch (...) {
61582       {
61583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61584       };
61585     }
61586   }
61587 }
61588
61589
61590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
61591   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61592   Dali::LongPressGesture *arg2 = 0 ;
61593
61594   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61595   arg2 = (Dali::LongPressGesture *)jarg2;
61596   if (!arg2) {
61597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
61598     return ;
61599   }
61600   {
61601     try {
61602       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
61603     } catch (std::out_of_range& e) {
61604       {
61605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61606       };
61607     } catch (std::exception& e) {
61608       {
61609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61610       };
61611     } catch (...) {
61612       {
61613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61614       };
61615     }
61616   }
61617 }
61618
61619
61620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61621   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61622   Dali::LongPressGesture *arg2 = 0 ;
61623
61624   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61625   arg2 = (Dali::LongPressGesture *)jarg2;
61626   if (!arg2) {
61627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
61628     return ;
61629   }
61630   {
61631     try {
61632       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
61633     } catch (std::out_of_range& e) {
61634       {
61635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61636       };
61637     } catch (std::exception& e) {
61638       {
61639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61640       };
61641     } catch (...) {
61642       {
61643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61644       };
61645     }
61646   }
61647 }
61648
61649
61650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
61651   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61652   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
61653   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
61654
61655   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61656   arg2 = (Dali::SlotObserver *)jarg2;
61657   arg3 = (Dali::CallbackBase *)jarg3;
61658   {
61659     try {
61660       (arg1)->SignalConnected(arg2,arg3);
61661     } catch (std::out_of_range& e) {
61662       {
61663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61664       };
61665     } catch (std::exception& e) {
61666       {
61667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61668       };
61669     } catch (...) {
61670       {
61671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61672       };
61673     }
61674   }
61675 }
61676
61677
61678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61679   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61680   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
61681   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
61682
61683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61684   arg2 = (Dali::SlotObserver *)jarg2;
61685   arg3 = (Dali::CallbackBase *)jarg3;
61686   {
61687     try {
61688       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
61689     } catch (std::out_of_range& e) {
61690       {
61691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61692       };
61693     } catch (std::exception& e) {
61694       {
61695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61696       };
61697     } catch (...) {
61698       {
61699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61700       };
61701     }
61702   }
61703 }
61704
61705
61706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
61707   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61708   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
61709   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
61710
61711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61712   arg2 = (Dali::SlotObserver *)jarg2;
61713   arg3 = (Dali::CallbackBase *)jarg3;
61714   {
61715     try {
61716       (arg1)->SignalDisconnected(arg2,arg3);
61717     } catch (std::out_of_range& e) {
61718       {
61719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61720       };
61721     } catch (std::exception& e) {
61722       {
61723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61724       };
61725     } catch (...) {
61726       {
61727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61728       };
61729     }
61730   }
61731 }
61732
61733
61734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61735   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61736   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
61737   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
61738
61739   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61740   arg2 = (Dali::SlotObserver *)jarg2;
61741   arg3 = (Dali::CallbackBase *)jarg3;
61742   {
61743     try {
61744       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
61745     } catch (std::out_of_range& e) {
61746       {
61747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61748       };
61749     } catch (std::exception& e) {
61750       {
61751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61752       };
61753     } catch (...) {
61754       {
61755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61756       };
61757     }
61758   }
61759 }
61760
61761
61762 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) {
61763   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
61764   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
61765   if (director) {
61766     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);
61767   }
61768 }
61769
61770
61771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
61772   void * jresult ;
61773   Dali::Toolkit::Control *arg1 = 0 ;
61774   Dali::Toolkit::Internal::Control *result = 0 ;
61775
61776   arg1 = (Dali::Toolkit::Control *)jarg1;
61777   if (!arg1) {
61778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
61779     return 0;
61780   }
61781   {
61782     try {
61783       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
61784     } catch (std::out_of_range& e) {
61785       {
61786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61787       };
61788     } catch (std::exception& e) {
61789       {
61790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61791       };
61792     } catch (...) {
61793       {
61794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61795       };
61796     }
61797   }
61798   jresult = (void *)result;
61799   return jresult;
61800 }
61801
61802
61803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
61804   int jresult ;
61805   int result;
61806
61807   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
61808   jresult = (int)result;
61809   return jresult;
61810 }
61811
61812
61813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
61814   int jresult ;
61815   int result;
61816
61817   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
61818   jresult = (int)result;
61819   return jresult;
61820 }
61821
61822
61823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
61824   int jresult ;
61825   int result;
61826
61827   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
61828   jresult = (int)result;
61829   return jresult;
61830 }
61831
61832
61833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
61834   int jresult ;
61835   int result;
61836
61837   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
61838   jresult = (int)result;
61839   return jresult;
61840 }
61841
61842
61843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
61844   int jresult ;
61845   int result;
61846
61847   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
61848   jresult = (int)result;
61849   return jresult;
61850 }
61851
61852
61853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
61854   void * jresult ;
61855   Dali::Toolkit::Control::Property *result = 0 ;
61856
61857   {
61858     try {
61859       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
61860     } catch (std::out_of_range& e) {
61861       {
61862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61863       };
61864     } catch (std::exception& e) {
61865       {
61866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61867       };
61868     } catch (...) {
61869       {
61870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61871       };
61872     }
61873   }
61874   jresult = (void *)result;
61875   return jresult;
61876 }
61877
61878
61879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
61880   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
61881
61882   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
61883   {
61884     try {
61885       delete arg1;
61886     } catch (std::out_of_range& e) {
61887       {
61888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61889       };
61890     } catch (std::exception& e) {
61891       {
61892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61893       };
61894     } catch (...) {
61895       {
61896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61897       };
61898     }
61899   }
61900 }
61901
61902
61903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
61904   void * jresult ;
61905   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
61906
61907   {
61908     try {
61909       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
61910     } catch (std::out_of_range& e) {
61911       {
61912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61913       };
61914     } catch (std::exception& e) {
61915       {
61916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61917       };
61918     } catch (...) {
61919       {
61920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61921       };
61922     }
61923   }
61924   jresult = (void *)result;
61925   return jresult;
61926 }
61927
61928
61929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
61930   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
61931
61932   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
61933   {
61934     try {
61935       delete arg1;
61936     } catch (std::out_of_range& e) {
61937       {
61938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61939       };
61940     } catch (std::exception& e) {
61941       {
61942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61943       };
61944     } catch (...) {
61945       {
61946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61947       };
61948     }
61949   }
61950 }
61951
61952
61953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
61954   void * jresult ;
61955   Dali::Toolkit::Control result;
61956
61957   {
61958     try {
61959       result = Dali::Toolkit::Control::New();
61960     } catch (std::out_of_range& e) {
61961       {
61962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61963       };
61964     } catch (std::exception& e) {
61965       {
61966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61967       };
61968     } catch (...) {
61969       {
61970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61971       };
61972     }
61973   }
61974   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
61975   return jresult;
61976 }
61977
61978
61979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
61980   void * jresult ;
61981   Dali::Toolkit::Control *result = 0 ;
61982
61983   {
61984     try {
61985       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
61986     } catch (std::out_of_range& e) {
61987       {
61988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61989       };
61990     } catch (std::exception& e) {
61991       {
61992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61993       };
61994     } catch (...) {
61995       {
61996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61997       };
61998     }
61999   }
62000   jresult = (void *)result;
62001   return jresult;
62002 }
62003
62004
62005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
62006   void * jresult ;
62007   Dali::Toolkit::Control *arg1 = 0 ;
62008   Dali::Toolkit::Control *result = 0 ;
62009
62010   arg1 = (Dali::Toolkit::Control *)jarg1;
62011   if (!arg1) {
62012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62013     return 0;
62014   }
62015   {
62016     try {
62017       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
62018     } catch (std::out_of_range& e) {
62019       {
62020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62021       };
62022     } catch (std::exception& e) {
62023       {
62024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62025       };
62026     } catch (...) {
62027       {
62028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62029       };
62030     }
62031   }
62032   jresult = (void *)result;
62033   return jresult;
62034 }
62035
62036
62037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
62038   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62039
62040   arg1 = (Dali::Toolkit::Control *)jarg1;
62041   {
62042     try {
62043       delete arg1;
62044     } catch (std::out_of_range& e) {
62045       {
62046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62047       };
62048     } catch (std::exception& e) {
62049       {
62050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62051       };
62052     } catch (...) {
62053       {
62054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62055       };
62056     }
62057   }
62058 }
62059
62060
62061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
62062   void * jresult ;
62063   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62064   Dali::Toolkit::Control *arg2 = 0 ;
62065   Dali::Toolkit::Control *result = 0 ;
62066
62067   arg1 = (Dali::Toolkit::Control *)jarg1;
62068   arg2 = (Dali::Toolkit::Control *)jarg2;
62069   if (!arg2) {
62070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62071     return 0;
62072   }
62073   {
62074     try {
62075       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
62076     } catch (std::out_of_range& e) {
62077       {
62078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62079       };
62080     } catch (std::exception& e) {
62081       {
62082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62083       };
62084     } catch (...) {
62085       {
62086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62087       };
62088     }
62089   }
62090   jresult = (void *)result;
62091   return jresult;
62092 }
62093
62094
62095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
62096   void * jresult ;
62097   Dali::BaseHandle arg1 ;
62098   Dali::BaseHandle *argp1 ;
62099   Dali::Toolkit::Control result;
62100
62101   argp1 = (Dali::BaseHandle *)jarg1;
62102   if (!argp1) {
62103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62104     return 0;
62105   }
62106   arg1 = *argp1;
62107   {
62108     try {
62109       result = Dali::Toolkit::Control::DownCast(arg1);
62110     } catch (std::out_of_range& e) {
62111       {
62112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62113       };
62114     } catch (std::exception& e) {
62115       {
62116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62117       };
62118     } catch (...) {
62119       {
62120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62121       };
62122     }
62123   }
62124   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62125   return jresult;
62126 }
62127
62128
62129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
62130   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62131
62132   arg1 = (Dali::Toolkit::Control *)jarg1;
62133   {
62134     try {
62135       (arg1)->SetKeyInputFocus();
62136     } catch (std::out_of_range& e) {
62137       {
62138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62139       };
62140     } catch (std::exception& e) {
62141       {
62142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62143       };
62144     } catch (...) {
62145       {
62146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62147       };
62148     }
62149   }
62150 }
62151
62152
62153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
62154   unsigned int jresult ;
62155   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62156   bool result;
62157
62158   arg1 = (Dali::Toolkit::Control *)jarg1;
62159   {
62160     try {
62161       result = (bool)(arg1)->HasKeyInputFocus();
62162     } catch (std::out_of_range& e) {
62163       {
62164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62165       };
62166     } catch (std::exception& e) {
62167       {
62168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62169       };
62170     } catch (...) {
62171       {
62172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62173       };
62174     }
62175   }
62176   jresult = result;
62177   return jresult;
62178 }
62179
62180
62181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
62182   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62183
62184   arg1 = (Dali::Toolkit::Control *)jarg1;
62185   {
62186     try {
62187       (arg1)->ClearKeyInputFocus();
62188     } catch (std::out_of_range& e) {
62189       {
62190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62191       };
62192     } catch (std::exception& e) {
62193       {
62194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62195       };
62196     } catch (...) {
62197       {
62198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62199       };
62200     }
62201   }
62202 }
62203
62204
62205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
62206   void * jresult ;
62207   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62208   Dali::PinchGestureDetector result;
62209
62210   arg1 = (Dali::Toolkit::Control *)jarg1;
62211   {
62212     try {
62213       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
62214     } catch (std::out_of_range& e) {
62215       {
62216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62217       };
62218     } catch (std::exception& e) {
62219       {
62220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62221       };
62222     } catch (...) {
62223       {
62224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62225       };
62226     }
62227   }
62228   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
62229   return jresult;
62230 }
62231
62232
62233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
62234   void * jresult ;
62235   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62236   Dali::PanGestureDetector result;
62237
62238   arg1 = (Dali::Toolkit::Control *)jarg1;
62239   {
62240     try {
62241       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
62242     } catch (std::out_of_range& e) {
62243       {
62244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62245       };
62246     } catch (std::exception& e) {
62247       {
62248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62249       };
62250     } catch (...) {
62251       {
62252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62253       };
62254     }
62255   }
62256   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
62257   return jresult;
62258 }
62259
62260
62261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
62262   void * jresult ;
62263   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62264   Dali::TapGestureDetector result;
62265
62266   arg1 = (Dali::Toolkit::Control *)jarg1;
62267   {
62268     try {
62269       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
62270     } catch (std::out_of_range& e) {
62271       {
62272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62273       };
62274     } catch (std::exception& e) {
62275       {
62276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62277       };
62278     } catch (...) {
62279       {
62280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62281       };
62282     }
62283   }
62284   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
62285   return jresult;
62286 }
62287
62288
62289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
62290   void * jresult ;
62291   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62292   Dali::LongPressGestureDetector result;
62293
62294   arg1 = (Dali::Toolkit::Control *)jarg1;
62295   {
62296     try {
62297       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
62298     } catch (std::out_of_range& e) {
62299       {
62300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62301       };
62302     } catch (std::exception& e) {
62303       {
62304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62305       };
62306     } catch (...) {
62307       {
62308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62309       };
62310     }
62311   }
62312   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
62313   return jresult;
62314 }
62315
62316
62317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
62318   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62319   std::string *arg2 = 0 ;
62320
62321   arg1 = (Dali::Toolkit::Control *)jarg1;
62322   if (!jarg2) {
62323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62324     return ;
62325   }
62326   std::string arg2_str(jarg2);
62327   arg2 = &arg2_str;
62328   {
62329     try {
62330       (arg1)->SetStyleName((std::string const &)*arg2);
62331     } catch (std::out_of_range& e) {
62332       {
62333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62334       };
62335     } catch (std::exception& e) {
62336       {
62337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62338       };
62339     } catch (...) {
62340       {
62341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62342       };
62343     }
62344   }
62345
62346   //argout typemap for const std::string&
62347
62348 }
62349
62350
62351 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
62352   char * jresult ;
62353   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62354   std::string *result = 0 ;
62355
62356   arg1 = (Dali::Toolkit::Control *)jarg1;
62357   {
62358     try {
62359       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
62360     } catch (std::out_of_range& e) {
62361       {
62362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62363       };
62364     } catch (std::exception& e) {
62365       {
62366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62367       };
62368     } catch (...) {
62369       {
62370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62371       };
62372     }
62373   }
62374   jresult = SWIG_csharp_string_callback(result->c_str());
62375   return jresult;
62376 }
62377
62378
62379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
62380   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62381   Dali::Vector4 *arg2 = 0 ;
62382
62383   arg1 = (Dali::Toolkit::Control *)jarg1;
62384   arg2 = (Dali::Vector4 *)jarg2;
62385   if (!arg2) {
62386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
62387     return ;
62388   }
62389   {
62390     try {
62391       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
62392     } catch (std::out_of_range& e) {
62393       {
62394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62395       };
62396     } catch (std::exception& e) {
62397       {
62398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62399       };
62400     } catch (...) {
62401       {
62402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62403       };
62404     }
62405   }
62406 }
62407
62408
62409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
62410   void * jresult ;
62411   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62412   Dali::Vector4 result;
62413
62414   arg1 = (Dali::Toolkit::Control *)jarg1;
62415   {
62416     try {
62417       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
62418     } catch (std::out_of_range& e) {
62419       {
62420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62421       };
62422     } catch (std::exception& e) {
62423       {
62424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62425       };
62426     } catch (...) {
62427       {
62428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62429       };
62430     }
62431   }
62432   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
62433   return jresult;
62434 }
62435
62436
62437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
62438   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62439   Dali::Image arg2 ;
62440   Dali::Image *argp2 ;
62441
62442   arg1 = (Dali::Toolkit::Control *)jarg1;
62443   argp2 = (Dali::Image *)jarg2;
62444   if (!argp2) {
62445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62446     return ;
62447   }
62448   arg2 = *argp2;
62449   {
62450     try {
62451       (arg1)->SetBackgroundImage(arg2);
62452     } catch (std::out_of_range& e) {
62453       {
62454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62455       };
62456     } catch (std::exception& e) {
62457       {
62458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62459       };
62460     } catch (...) {
62461       {
62462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62463       };
62464     }
62465   }
62466 }
62467
62468
62469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
62470   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62471
62472   arg1 = (Dali::Toolkit::Control *)jarg1;
62473   {
62474     try {
62475       (arg1)->ClearBackground();
62476     } catch (std::out_of_range& e) {
62477       {
62478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62479       };
62480     } catch (std::exception& e) {
62481       {
62482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62483       };
62484     } catch (...) {
62485       {
62486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62487       };
62488     }
62489   }
62490 }
62491
62492
62493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
62494   void * jresult ;
62495   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62496   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
62497
62498   arg1 = (Dali::Toolkit::Control *)jarg1;
62499   {
62500     try {
62501       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
62502     } catch (std::out_of_range& e) {
62503       {
62504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62505       };
62506     } catch (std::exception& e) {
62507       {
62508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62509       };
62510     } catch (...) {
62511       {
62512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62513       };
62514     }
62515   }
62516   jresult = (void *)result;
62517   return jresult;
62518 }
62519
62520
62521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
62522   void * jresult ;
62523   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62524   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62525
62526   arg1 = (Dali::Toolkit::Control *)jarg1;
62527   {
62528     try {
62529       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
62530     } catch (std::out_of_range& e) {
62531       {
62532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62533       };
62534     } catch (std::exception& e) {
62535       {
62536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62537       };
62538     } catch (...) {
62539       {
62540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62541       };
62542     }
62543   }
62544   jresult = (void *)result;
62545   return jresult;
62546 }
62547
62548
62549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
62550   void * jresult ;
62551   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62552   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62553
62554   arg1 = (Dali::Toolkit::Control *)jarg1;
62555   {
62556     try {
62557       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
62558     } catch (std::out_of_range& e) {
62559       {
62560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62561       };
62562     } catch (std::exception& e) {
62563       {
62564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62565       };
62566     } catch (...) {
62567       {
62568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62569       };
62570     }
62571   }
62572   jresult = (void *)result;
62573   return jresult;
62574 }
62575
62576
62577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
62578   void * jresult ;
62579   Dali::Toolkit::Internal::Control *arg1 = 0 ;
62580   Dali::Toolkit::Control *result = 0 ;
62581
62582   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62583   if (!arg1) {
62584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
62585     return 0;
62586   }
62587   {
62588     try {
62589       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
62590     } catch (std::out_of_range& e) {
62591       {
62592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62593       };
62594     } catch (std::exception& e) {
62595       {
62596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62597       };
62598     } catch (...) {
62599       {
62600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62601       };
62602     }
62603   }
62604   jresult = (void *)result;
62605   return jresult;
62606 }
62607
62608
62609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
62610   void * jresult ;
62611   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
62612
62613   {
62614     try {
62615       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
62616     } catch (std::out_of_range& e) {
62617       {
62618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62619       };
62620     } catch (std::exception& e) {
62621       {
62622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62623       };
62624     } catch (...) {
62625       {
62626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62627       };
62628     }
62629   }
62630   jresult = (void *)result;
62631   return jresult;
62632 }
62633
62634
62635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
62636   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62637
62638   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62639   {
62640     try {
62641       delete arg1;
62642     } catch (std::out_of_range& e) {
62643       {
62644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62645       };
62646     } catch (std::exception& e) {
62647       {
62648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62649       };
62650     } catch (...) {
62651       {
62652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62653       };
62654     }
62655   }
62656 }
62657
62658
62659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
62660   void * jresult ;
62661   Dali::Toolkit::KeyInputFocusManager result;
62662
62663   {
62664     try {
62665       result = Dali::Toolkit::KeyInputFocusManager::Get();
62666     } catch (std::out_of_range& e) {
62667       {
62668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62669       };
62670     } catch (std::exception& e) {
62671       {
62672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62673       };
62674     } catch (...) {
62675       {
62676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62677       };
62678     }
62679   }
62680   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
62681   return jresult;
62682 }
62683
62684
62685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
62686   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62687   Dali::Toolkit::Control arg2 ;
62688   Dali::Toolkit::Control *argp2 ;
62689
62690   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62691   argp2 = (Dali::Toolkit::Control *)jarg2;
62692   if (!argp2) {
62693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
62694     return ;
62695   }
62696   arg2 = *argp2;
62697   {
62698     try {
62699       (arg1)->SetFocus(arg2);
62700     } catch (std::out_of_range& e) {
62701       {
62702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62703       };
62704     } catch (std::exception& e) {
62705       {
62706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62707       };
62708     } catch (...) {
62709       {
62710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62711       };
62712     }
62713   }
62714 }
62715
62716
62717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
62718   void * jresult ;
62719   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62720   Dali::Toolkit::Control result;
62721
62722   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62723   {
62724     try {
62725       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
62726     } catch (std::out_of_range& e) {
62727       {
62728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62729       };
62730     } catch (std::exception& e) {
62731       {
62732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62733       };
62734     } catch (...) {
62735       {
62736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62737       };
62738     }
62739   }
62740   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62741   return jresult;
62742 }
62743
62744
62745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
62746   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62747   Dali::Toolkit::Control arg2 ;
62748   Dali::Toolkit::Control *argp2 ;
62749
62750   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62751   argp2 = (Dali::Toolkit::Control *)jarg2;
62752   if (!argp2) {
62753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
62754     return ;
62755   }
62756   arg2 = *argp2;
62757   {
62758     try {
62759       (arg1)->RemoveFocus(arg2);
62760     } catch (std::out_of_range& e) {
62761       {
62762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62763       };
62764     } catch (std::exception& e) {
62765       {
62766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62767       };
62768     } catch (...) {
62769       {
62770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62771       };
62772     }
62773   }
62774 }
62775
62776
62777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_IsKeyboardListener(void * jarg1, void * jarg2) {
62778   unsigned int jresult ;
62779   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62780   Dali::Toolkit::Control arg2 ;
62781   Dali::Toolkit::Control *argp2 ;
62782   bool result;
62783
62784   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62785   argp2 = (Dali::Toolkit::Control *)jarg2;
62786   if (!argp2) {
62787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
62788     return 0;
62789   }
62790   arg2 = *argp2;
62791   {
62792     try {
62793       result = (bool)(arg1)->IsKeyboardListener(arg2);
62794     } catch (std::out_of_range& e) {
62795       {
62796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62797       };
62798     } catch (std::exception& e) {
62799       {
62800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62801       };
62802     } catch (...) {
62803       {
62804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62805       };
62806     }
62807   }
62808   jresult = result;
62809   return jresult;
62810 }
62811
62812
62813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
62814   void * jresult ;
62815   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62816   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
62817
62818   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62819   {
62820     try {
62821       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
62822     } catch (std::out_of_range& e) {
62823       {
62824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62825       };
62826     } catch (std::exception& e) {
62827       {
62828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62829       };
62830     } catch (...) {
62831       {
62832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62833       };
62834     }
62835   }
62836   jresult = (void *)result;
62837   return jresult;
62838 }
62839
62840
62841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_UnhandledKeyEventSignal(void * jarg1) {
62842   void * jresult ;
62843   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62844   Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *result = 0 ;
62845
62846   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62847   {
62848     try {
62849       result = (Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *) &(arg1)->UnhandledKeyEventSignal();
62850     } catch (std::out_of_range& e) {
62851       {
62852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62853       };
62854     } catch (std::exception& e) {
62855       {
62856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62857       };
62858     } catch (...) {
62859       {
62860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62861       };
62862     }
62863   }
62864   jresult = (void *)result;
62865   return jresult;
62866 }
62867
62868
62869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
62870   void * jresult ;
62871   Dali::Toolkit::Alignment::Padding *result = 0 ;
62872
62873   {
62874     try {
62875       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
62876     } catch (std::out_of_range& e) {
62877       {
62878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62879       };
62880     } catch (std::exception& e) {
62881       {
62882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62883       };
62884     } catch (...) {
62885       {
62886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62887       };
62888     }
62889   }
62890   jresult = (void *)result;
62891   return jresult;
62892 }
62893
62894
62895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
62896   void * jresult ;
62897   float arg1 ;
62898   float arg2 ;
62899   float arg3 ;
62900   float arg4 ;
62901   Dali::Toolkit::Alignment::Padding *result = 0 ;
62902
62903   arg1 = (float)jarg1;
62904   arg2 = (float)jarg2;
62905   arg3 = (float)jarg3;
62906   arg4 = (float)jarg4;
62907   {
62908     try {
62909       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
62910     } catch (std::out_of_range& e) {
62911       {
62912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62913       };
62914     } catch (std::exception& e) {
62915       {
62916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62917       };
62918     } catch (...) {
62919       {
62920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62921       };
62922     }
62923   }
62924   jresult = (void *)result;
62925   return jresult;
62926 }
62927
62928
62929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
62930   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62931   float arg2 ;
62932
62933   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62934   arg2 = (float)jarg2;
62935   if (arg1) (arg1)->left = arg2;
62936 }
62937
62938
62939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
62940   float jresult ;
62941   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62942   float result;
62943
62944   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62945   result = (float) ((arg1)->left);
62946   jresult = result;
62947   return jresult;
62948 }
62949
62950
62951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
62952   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62953   float arg2 ;
62954
62955   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62956   arg2 = (float)jarg2;
62957   if (arg1) (arg1)->right = arg2;
62958 }
62959
62960
62961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
62962   float jresult ;
62963   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62964   float result;
62965
62966   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62967   result = (float) ((arg1)->right);
62968   jresult = result;
62969   return jresult;
62970 }
62971
62972
62973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
62974   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62975   float arg2 ;
62976
62977   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62978   arg2 = (float)jarg2;
62979   if (arg1) (arg1)->top = arg2;
62980 }
62981
62982
62983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
62984   float jresult ;
62985   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62986   float result;
62987
62988   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
62989   result = (float) ((arg1)->top);
62990   jresult = result;
62991   return jresult;
62992 }
62993
62994
62995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
62996   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
62997   float arg2 ;
62998
62999   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63000   arg2 = (float)jarg2;
63001   if (arg1) (arg1)->bottom = arg2;
63002 }
63003
63004
63005 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
63006   float jresult ;
63007   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63008   float result;
63009
63010   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63011   result = (float) ((arg1)->bottom);
63012   jresult = result;
63013   return jresult;
63014 }
63015
63016
63017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
63018   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63019
63020   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63021   {
63022     try {
63023       delete arg1;
63024     } catch (std::out_of_range& e) {
63025       {
63026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63027       };
63028     } catch (std::exception& e) {
63029       {
63030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63031       };
63032     } catch (...) {
63033       {
63034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63035       };
63036     }
63037   }
63038 }
63039
63040
63041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
63042   void * jresult ;
63043   Dali::Toolkit::Alignment *result = 0 ;
63044
63045   {
63046     try {
63047       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
63048     } catch (std::out_of_range& e) {
63049       {
63050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63051       };
63052     } catch (std::exception& e) {
63053       {
63054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63055       };
63056     } catch (...) {
63057       {
63058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63059       };
63060     }
63061   }
63062   jresult = (void *)result;
63063   return jresult;
63064 }
63065
63066
63067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
63068   void * jresult ;
63069   Dali::Toolkit::Alignment::Type arg1 ;
63070   Dali::Toolkit::Alignment::Type arg2 ;
63071   Dali::Toolkit::Alignment result;
63072
63073   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63074   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63075   {
63076     try {
63077       result = Dali::Toolkit::Alignment::New(arg1,arg2);
63078     } catch (std::out_of_range& e) {
63079       {
63080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63081       };
63082     } catch (std::exception& e) {
63083       {
63084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63085       };
63086     } catch (...) {
63087       {
63088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63089       };
63090     }
63091   }
63092   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63093   return jresult;
63094 }
63095
63096
63097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
63098   void * jresult ;
63099   Dali::Toolkit::Alignment::Type arg1 ;
63100   Dali::Toolkit::Alignment result;
63101
63102   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63103   {
63104     try {
63105       result = Dali::Toolkit::Alignment::New(arg1);
63106     } catch (std::out_of_range& e) {
63107       {
63108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63109       };
63110     } catch (std::exception& e) {
63111       {
63112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63113       };
63114     } catch (...) {
63115       {
63116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63117       };
63118     }
63119   }
63120   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63121   return jresult;
63122 }
63123
63124
63125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
63126   void * jresult ;
63127   Dali::Toolkit::Alignment result;
63128
63129   {
63130     try {
63131       result = Dali::Toolkit::Alignment::New();
63132     } catch (std::out_of_range& e) {
63133       {
63134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63135       };
63136     } catch (std::exception& e) {
63137       {
63138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63139       };
63140     } catch (...) {
63141       {
63142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63143       };
63144     }
63145   }
63146   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63147   return jresult;
63148 }
63149
63150
63151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
63152   void * jresult ;
63153   Dali::Toolkit::Alignment *arg1 = 0 ;
63154   Dali::Toolkit::Alignment *result = 0 ;
63155
63156   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63157   if (!arg1) {
63158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63159     return 0;
63160   }
63161   {
63162     try {
63163       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
63164     } catch (std::out_of_range& e) {
63165       {
63166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63167       };
63168     } catch (std::exception& e) {
63169       {
63170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63171       };
63172     } catch (...) {
63173       {
63174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63175       };
63176     }
63177   }
63178   jresult = (void *)result;
63179   return jresult;
63180 }
63181
63182
63183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
63184   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63185
63186   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63187   {
63188     try {
63189       delete arg1;
63190     } catch (std::out_of_range& e) {
63191       {
63192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63193       };
63194     } catch (std::exception& e) {
63195       {
63196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63197       };
63198     } catch (...) {
63199       {
63200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63201       };
63202     }
63203   }
63204 }
63205
63206
63207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
63208   void * jresult ;
63209   Dali::BaseHandle arg1 ;
63210   Dali::BaseHandle *argp1 ;
63211   Dali::Toolkit::Alignment result;
63212
63213   argp1 = (Dali::BaseHandle *)jarg1;
63214   if (!argp1) {
63215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63216     return 0;
63217   }
63218   arg1 = *argp1;
63219   {
63220     try {
63221       result = Dali::Toolkit::Alignment::DownCast(arg1);
63222     } catch (std::out_of_range& e) {
63223       {
63224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63225       };
63226     } catch (std::exception& e) {
63227       {
63228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63229       };
63230     } catch (...) {
63231       {
63232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63233       };
63234     }
63235   }
63236   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63237   return jresult;
63238 }
63239
63240
63241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
63242   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63243   Dali::Toolkit::Alignment::Type arg2 ;
63244
63245   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63246   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63247   {
63248     try {
63249       (arg1)->SetAlignmentType(arg2);
63250     } catch (std::out_of_range& e) {
63251       {
63252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63253       };
63254     } catch (std::exception& e) {
63255       {
63256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63257       };
63258     } catch (...) {
63259       {
63260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63261       };
63262     }
63263   }
63264 }
63265
63266
63267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
63268   int jresult ;
63269   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63270   Dali::Toolkit::Alignment::Type result;
63271
63272   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63273   {
63274     try {
63275       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
63276     } catch (std::out_of_range& e) {
63277       {
63278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63279       };
63280     } catch (std::exception& e) {
63281       {
63282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63283       };
63284     } catch (...) {
63285       {
63286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63287       };
63288     }
63289   }
63290   jresult = (int)result;
63291   return jresult;
63292 }
63293
63294
63295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
63296   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63297   Dali::Toolkit::Alignment::Scaling arg2 ;
63298
63299   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63300   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
63301   {
63302     try {
63303       (arg1)->SetScaling(arg2);
63304     } catch (std::out_of_range& e) {
63305       {
63306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63307       };
63308     } catch (std::exception& e) {
63309       {
63310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63311       };
63312     } catch (...) {
63313       {
63314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63315       };
63316     }
63317   }
63318 }
63319
63320
63321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
63322   int jresult ;
63323   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63324   Dali::Toolkit::Alignment::Scaling result;
63325
63326   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63327   {
63328     try {
63329       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
63330     } catch (std::out_of_range& e) {
63331       {
63332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63333       };
63334     } catch (std::exception& e) {
63335       {
63336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63337       };
63338     } catch (...) {
63339       {
63340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63341       };
63342     }
63343   }
63344   jresult = (int)result;
63345   return jresult;
63346 }
63347
63348
63349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
63350   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63351   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
63352
63353   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63354   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
63355   if (!arg2) {
63356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
63357     return ;
63358   }
63359   {
63360     try {
63361       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
63362     } catch (std::out_of_range& e) {
63363       {
63364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63365       };
63366     } catch (std::exception& e) {
63367       {
63368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63369       };
63370     } catch (...) {
63371       {
63372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63373       };
63374     }
63375   }
63376 }
63377
63378
63379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
63380   void * jresult ;
63381   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63382   Dali::Toolkit::Alignment::Padding *result = 0 ;
63383
63384   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63385   {
63386     try {
63387       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
63388     } catch (std::out_of_range& e) {
63389       {
63390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63391       };
63392     } catch (std::exception& e) {
63393       {
63394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63395       };
63396     } catch (...) {
63397       {
63398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63399       };
63400     }
63401   }
63402   jresult = (void *)result;
63403   return jresult;
63404 }
63405
63406
63407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
63408   void * jresult ;
63409   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63410   Dali::Toolkit::Alignment *arg2 = 0 ;
63411   Dali::Toolkit::Alignment *result = 0 ;
63412
63413   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63414   arg2 = (Dali::Toolkit::Alignment *)jarg2;
63415   if (!arg2) {
63416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63417     return 0;
63418   }
63419   {
63420     try {
63421       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
63422     } catch (std::out_of_range& e) {
63423       {
63424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63425       };
63426     } catch (std::exception& e) {
63427       {
63428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63429       };
63430     } catch (...) {
63431       {
63432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63433       };
63434     }
63435   }
63436   jresult = (void *)result;
63437   return jresult;
63438 }
63439
63440
63441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
63442   int jresult ;
63443   int result;
63444
63445   result = (int)Dali::Toolkit::Button::Property::DISABLED;
63446   jresult = (int)result;
63447   return jresult;
63448 }
63449
63450
63451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
63452   int jresult ;
63453   int result;
63454
63455   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
63456   jresult = (int)result;
63457   return jresult;
63458 }
63459
63460
63461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
63462   int jresult ;
63463   int result;
63464
63465   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
63466   jresult = (int)result;
63467   return jresult;
63468 }
63469
63470
63471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
63472   int jresult ;
63473   int result;
63474
63475   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
63476   jresult = (int)result;
63477   return jresult;
63478 }
63479
63480
63481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
63482   int jresult ;
63483   int result;
63484
63485   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
63486   jresult = (int)result;
63487   return jresult;
63488 }
63489
63490
63491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
63492   int jresult ;
63493   int result;
63494
63495   result = (int)Dali::Toolkit::Button::Property::SELECTED;
63496   jresult = (int)result;
63497   return jresult;
63498 }
63499
63500
63501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_STATE_IMAGE_get() {
63502   int jresult ;
63503   int result;
63504
63505   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_STATE_IMAGE;
63506   jresult = (int)result;
63507   return jresult;
63508 }
63509
63510
63511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_STATE_IMAGE_get() {
63512   int jresult ;
63513   int result;
63514
63515   result = (int)Dali::Toolkit::Button::Property::SELECTED_STATE_IMAGE;
63516   jresult = (int)result;
63517   return jresult;
63518 }
63519
63520
63521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_STATE_IMAGE_get() {
63522   int jresult ;
63523   int result;
63524
63525   result = (int)Dali::Toolkit::Button::Property::DISABLED_STATE_IMAGE;
63526   jresult = (int)result;
63527   return jresult;
63528 }
63529
63530
63531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
63532   int jresult ;
63533   int result;
63534
63535   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
63536   jresult = (int)result;
63537   return jresult;
63538 }
63539
63540
63541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
63542   int jresult ;
63543   int result;
63544
63545   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
63546   jresult = (int)result;
63547   return jresult;
63548 }
63549
63550
63551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
63552   int jresult ;
63553   int result;
63554
63555   result = (int)Dali::Toolkit::Button::Property::LABEL;
63556   jresult = (int)result;
63557   return jresult;
63558 }
63559
63560
63561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
63562   int jresult ;
63563   int result;
63564
63565   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
63566   jresult = (int)result;
63567   return jresult;
63568 }
63569
63570
63571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
63572   void * jresult ;
63573   Dali::Toolkit::Button::Property *result = 0 ;
63574
63575   {
63576     try {
63577       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
63578     } catch (std::out_of_range& e) {
63579       {
63580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63581       };
63582     } catch (std::exception& e) {
63583       {
63584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63585       };
63586     } catch (...) {
63587       {
63588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63589       };
63590     }
63591   }
63592   jresult = (void *)result;
63593   return jresult;
63594 }
63595
63596
63597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
63598   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
63599
63600   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
63601   {
63602     try {
63603       delete arg1;
63604     } catch (std::out_of_range& e) {
63605       {
63606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63607       };
63608     } catch (std::exception& e) {
63609       {
63610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63611       };
63612     } catch (...) {
63613       {
63614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63615       };
63616     }
63617   }
63618 }
63619
63620
63621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
63622   void * jresult ;
63623   Dali::Toolkit::Button *result = 0 ;
63624
63625   {
63626     try {
63627       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
63628     } catch (std::out_of_range& e) {
63629       {
63630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63631       };
63632     } catch (std::exception& e) {
63633       {
63634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63635       };
63636     } catch (...) {
63637       {
63638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63639       };
63640     }
63641   }
63642   jresult = (void *)result;
63643   return jresult;
63644 }
63645
63646
63647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
63648   void * jresult ;
63649   Dali::Toolkit::Button *arg1 = 0 ;
63650   Dali::Toolkit::Button *result = 0 ;
63651
63652   arg1 = (Dali::Toolkit::Button *)jarg1;
63653   if (!arg1) {
63654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
63655     return 0;
63656   }
63657   {
63658     try {
63659       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
63660     } catch (std::out_of_range& e) {
63661       {
63662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63663       };
63664     } catch (std::exception& e) {
63665       {
63666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63667       };
63668     } catch (...) {
63669       {
63670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63671       };
63672     }
63673   }
63674   jresult = (void *)result;
63675   return jresult;
63676 }
63677
63678
63679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
63680   void * jresult ;
63681   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63682   Dali::Toolkit::Button *arg2 = 0 ;
63683   Dali::Toolkit::Button *result = 0 ;
63684
63685   arg1 = (Dali::Toolkit::Button *)jarg1;
63686   arg2 = (Dali::Toolkit::Button *)jarg2;
63687   if (!arg2) {
63688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
63689     return 0;
63690   }
63691   {
63692     try {
63693       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
63694     } catch (std::out_of_range& e) {
63695       {
63696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63697       };
63698     } catch (std::exception& e) {
63699       {
63700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63701       };
63702     } catch (...) {
63703       {
63704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63705       };
63706     }
63707   }
63708   jresult = (void *)result;
63709   return jresult;
63710 }
63711
63712
63713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
63714   void * jresult ;
63715   Dali::BaseHandle arg1 ;
63716   Dali::BaseHandle *argp1 ;
63717   Dali::Toolkit::Button result;
63718
63719   argp1 = (Dali::BaseHandle *)jarg1;
63720   if (!argp1) {
63721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63722     return 0;
63723   }
63724   arg1 = *argp1;
63725   {
63726     try {
63727       result = Dali::Toolkit::Button::DownCast(arg1);
63728     } catch (std::out_of_range& e) {
63729       {
63730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63731       };
63732     } catch (std::exception& e) {
63733       {
63734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63735       };
63736     } catch (...) {
63737       {
63738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63739       };
63740     }
63741   }
63742   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
63743   return jresult;
63744 }
63745
63746
63747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
63748   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63749
63750   arg1 = (Dali::Toolkit::Button *)jarg1;
63751   {
63752     try {
63753       delete arg1;
63754     } catch (std::out_of_range& e) {
63755       {
63756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63757       };
63758     } catch (std::exception& e) {
63759       {
63760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63761       };
63762     } catch (...) {
63763       {
63764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63765       };
63766     }
63767   }
63768 }
63769
63770
63771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
63772   unsigned int jresult ;
63773   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63774   bool result;
63775
63776   arg1 = (Dali::Toolkit::Button *)jarg1;
63777   {
63778     try {
63779       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
63780     } catch (std::out_of_range& e) {
63781       {
63782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63783       };
63784     } catch (std::exception& e) {
63785       {
63786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63787       };
63788     } catch (...) {
63789       {
63790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63791       };
63792     }
63793   }
63794   jresult = result;
63795   return jresult;
63796 }
63797
63798
63799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
63800   unsigned int jresult ;
63801   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63802   bool result;
63803
63804   arg1 = (Dali::Toolkit::Button *)jarg1;
63805   {
63806     try {
63807       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
63808     } catch (std::out_of_range& e) {
63809       {
63810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63811       };
63812     } catch (std::exception& e) {
63813       {
63814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63815       };
63816     } catch (...) {
63817       {
63818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63819       };
63820     }
63821   }
63822   jresult = result;
63823   return jresult;
63824 }
63825
63826
63827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
63828   float jresult ;
63829   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63830   float result;
63831
63832   arg1 = (Dali::Toolkit::Button *)jarg1;
63833   {
63834     try {
63835       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
63836     } catch (std::out_of_range& e) {
63837       {
63838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63839       };
63840     } catch (std::exception& e) {
63841       {
63842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63843       };
63844     } catch (...) {
63845       {
63846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63847       };
63848     }
63849   }
63850   jresult = result;
63851   return jresult;
63852 }
63853
63854
63855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
63856   float jresult ;
63857   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63858   float result;
63859
63860   arg1 = (Dali::Toolkit::Button *)jarg1;
63861   {
63862     try {
63863       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
63864     } catch (std::out_of_range& e) {
63865       {
63866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63867       };
63868     } catch (std::exception& e) {
63869       {
63870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63871       };
63872     } catch (...) {
63873       {
63874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63875       };
63876     }
63877   }
63878   jresult = result;
63879   return jresult;
63880 }
63881
63882
63883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
63884   unsigned int jresult ;
63885   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63886   bool result;
63887
63888   arg1 = (Dali::Toolkit::Button *)jarg1;
63889   {
63890     try {
63891       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
63892     } catch (std::out_of_range& e) {
63893       {
63894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63895       };
63896     } catch (std::exception& e) {
63897       {
63898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63899       };
63900     } catch (...) {
63901       {
63902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63903       };
63904     }
63905   }
63906   jresult = result;
63907   return jresult;
63908 }
63909
63910
63911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
63912   unsigned int jresult ;
63913   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63914   bool result;
63915
63916   arg1 = (Dali::Toolkit::Button *)jarg1;
63917   {
63918     try {
63919       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
63920     } catch (std::out_of_range& e) {
63921       {
63922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63923       };
63924     } catch (std::exception& e) {
63925       {
63926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63927       };
63928     } catch (...) {
63929       {
63930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63931       };
63932     }
63933   }
63934   jresult = result;
63935   return jresult;
63936 }
63937
63938
63939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
63940   float jresult ;
63941   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63942   float result;
63943
63944   arg1 = (Dali::Toolkit::Button *)jarg1;
63945   {
63946     try {
63947       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
63948     } catch (std::out_of_range& e) {
63949       {
63950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63951       };
63952     } catch (std::exception& e) {
63953       {
63954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63955       };
63956     } catch (...) {
63957       {
63958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63959       };
63960     }
63961   }
63962   jresult = result;
63963   return jresult;
63964 }
63965
63966
63967 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
63968   char * jresult ;
63969   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63970   std::string result;
63971
63972   arg1 = (Dali::Toolkit::Button *)jarg1;
63973   {
63974     try {
63975       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
63976     } catch (std::out_of_range& e) {
63977       {
63978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63979       };
63980     } catch (std::exception& e) {
63981       {
63982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63983       };
63984     } catch (...) {
63985       {
63986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63987       };
63988     }
63989   }
63990   jresult = SWIG_csharp_string_callback((&result)->c_str());
63991   return jresult;
63992 }
63993
63994
63995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
63996   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63997   Dali::Actor arg2 ;
63998   Dali::Actor *argp2 ;
63999
64000   arg1 = (Dali::Toolkit::Button *)jarg1;
64001   argp2 = (Dali::Actor *)jarg2;
64002   if (!argp2) {
64003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64004     return ;
64005   }
64006   arg2 = *argp2;
64007   {
64008     try {
64009       (arg1)->SetLabel(arg2);
64010     } catch (std::out_of_range& e) {
64011       {
64012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64013       };
64014     } catch (std::exception& e) {
64015       {
64016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64017       };
64018     } catch (...) {
64019       {
64020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64021       };
64022     }
64023   }
64024 }
64025
64026
64027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
64028   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64029   Dali::Image arg2 ;
64030   Dali::Image *argp2 ;
64031
64032   arg1 = (Dali::Toolkit::Button *)jarg1;
64033   argp2 = (Dali::Image *)jarg2;
64034   if (!argp2) {
64035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64036     return ;
64037   }
64038   arg2 = *argp2;
64039   {
64040     try {
64041       (arg1)->SetButtonImage(arg2);
64042     } catch (std::out_of_range& e) {
64043       {
64044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64045       };
64046     } catch (std::exception& e) {
64047       {
64048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64049       };
64050     } catch (...) {
64051       {
64052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64053       };
64054     }
64055   }
64056 }
64057
64058
64059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
64060   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64061   Dali::Image arg2 ;
64062   Dali::Image *argp2 ;
64063
64064   arg1 = (Dali::Toolkit::Button *)jarg1;
64065   argp2 = (Dali::Image *)jarg2;
64066   if (!argp2) {
64067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64068     return ;
64069   }
64070   arg2 = *argp2;
64071   {
64072     try {
64073       (arg1)->SetSelectedImage(arg2);
64074     } catch (std::out_of_range& e) {
64075       {
64076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64077       };
64078     } catch (std::exception& e) {
64079       {
64080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64081       };
64082     } catch (...) {
64083       {
64084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64085       };
64086     }
64087   }
64088 }
64089
64090
64091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
64092   void * jresult ;
64093   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64094   Dali::Actor result;
64095
64096   arg1 = (Dali::Toolkit::Button *)jarg1;
64097   {
64098     try {
64099       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
64100     } catch (std::out_of_range& e) {
64101       {
64102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64103       };
64104     } catch (std::exception& e) {
64105       {
64106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64107       };
64108     } catch (...) {
64109       {
64110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64111       };
64112     }
64113   }
64114   jresult = new Dali::Actor((const Dali::Actor &)result);
64115   return jresult;
64116 }
64117
64118
64119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
64120   void * jresult ;
64121   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64122   Dali::Actor result;
64123
64124   arg1 = (Dali::Toolkit::Button *)jarg1;
64125   {
64126     try {
64127       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
64128     } catch (std::out_of_range& e) {
64129       {
64130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64131       };
64132     } catch (std::exception& e) {
64133       {
64134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64135       };
64136     } catch (...) {
64137       {
64138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64139       };
64140     }
64141   }
64142   jresult = new Dali::Actor((const Dali::Actor &)result);
64143   return jresult;
64144 }
64145
64146
64147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
64148   void * jresult ;
64149   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64150   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64151
64152   arg1 = (Dali::Toolkit::Button *)jarg1;
64153   {
64154     try {
64155       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
64156     } catch (std::out_of_range& e) {
64157       {
64158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64159       };
64160     } catch (std::exception& e) {
64161       {
64162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64163       };
64164     } catch (...) {
64165       {
64166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64167       };
64168     }
64169   }
64170   jresult = (void *)result;
64171   return jresult;
64172 }
64173
64174
64175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
64176   void * jresult ;
64177   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64178   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64179
64180   arg1 = (Dali::Toolkit::Button *)jarg1;
64181   {
64182     try {
64183       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
64184     } catch (std::out_of_range& e) {
64185       {
64186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64187       };
64188     } catch (std::exception& e) {
64189       {
64190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64191       };
64192     } catch (...) {
64193       {
64194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64195       };
64196     }
64197   }
64198   jresult = (void *)result;
64199   return jresult;
64200 }
64201
64202
64203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
64204   void * jresult ;
64205   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64206   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64207
64208   arg1 = (Dali::Toolkit::Button *)jarg1;
64209   {
64210     try {
64211       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
64212     } catch (std::out_of_range& e) {
64213       {
64214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64215       };
64216     } catch (std::exception& e) {
64217       {
64218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64219       };
64220     } catch (...) {
64221       {
64222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64223       };
64224     }
64225   }
64226   jresult = (void *)result;
64227   return jresult;
64228 }
64229
64230
64231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
64232   void * jresult ;
64233   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64234   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64235
64236   arg1 = (Dali::Toolkit::Button *)jarg1;
64237   {
64238     try {
64239       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
64240     } catch (std::out_of_range& e) {
64241       {
64242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64243       };
64244     } catch (std::exception& e) {
64245       {
64246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64247       };
64248     } catch (...) {
64249       {
64250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64251       };
64252     }
64253   }
64254   jresult = (void *)result;
64255   return jresult;
64256 }
64257
64258
64259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
64260   void * jresult ;
64261   Dali::Toolkit::CheckBoxButton *result = 0 ;
64262
64263   {
64264     try {
64265       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
64266     } catch (std::out_of_range& e) {
64267       {
64268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64269       };
64270     } catch (std::exception& e) {
64271       {
64272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64273       };
64274     } catch (...) {
64275       {
64276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64277       };
64278     }
64279   }
64280   jresult = (void *)result;
64281   return jresult;
64282 }
64283
64284
64285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
64286   void * jresult ;
64287   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
64288   Dali::Toolkit::CheckBoxButton *result = 0 ;
64289
64290   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64291   if (!arg1) {
64292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64293     return 0;
64294   }
64295   {
64296     try {
64297       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
64298     } catch (std::out_of_range& e) {
64299       {
64300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64301       };
64302     } catch (std::exception& e) {
64303       {
64304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64305       };
64306     } catch (...) {
64307       {
64308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64309       };
64310     }
64311   }
64312   jresult = (void *)result;
64313   return jresult;
64314 }
64315
64316
64317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
64318   void * jresult ;
64319   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64320   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
64321   Dali::Toolkit::CheckBoxButton *result = 0 ;
64322
64323   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64324   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
64325   if (!arg2) {
64326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64327     return 0;
64328   }
64329   {
64330     try {
64331       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
64332     } catch (std::out_of_range& e) {
64333       {
64334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64335       };
64336     } catch (std::exception& e) {
64337       {
64338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64339       };
64340     } catch (...) {
64341       {
64342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64343       };
64344     }
64345   }
64346   jresult = (void *)result;
64347   return jresult;
64348 }
64349
64350
64351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
64352   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64353
64354   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64355   {
64356     try {
64357       delete arg1;
64358     } catch (std::out_of_range& e) {
64359       {
64360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64361       };
64362     } catch (std::exception& e) {
64363       {
64364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64365       };
64366     } catch (...) {
64367       {
64368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64369       };
64370     }
64371   }
64372 }
64373
64374
64375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
64376   void * jresult ;
64377   Dali::Toolkit::CheckBoxButton result;
64378
64379   {
64380     try {
64381       result = Dali::Toolkit::CheckBoxButton::New();
64382     } catch (std::out_of_range& e) {
64383       {
64384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64385       };
64386     } catch (std::exception& e) {
64387       {
64388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64389       };
64390     } catch (...) {
64391       {
64392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64393       };
64394     }
64395   }
64396   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64397   return jresult;
64398 }
64399
64400
64401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
64402   void * jresult ;
64403   Dali::BaseHandle arg1 ;
64404   Dali::BaseHandle *argp1 ;
64405   Dali::Toolkit::CheckBoxButton result;
64406
64407   argp1 = (Dali::BaseHandle *)jarg1;
64408   if (!argp1) {
64409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64410     return 0;
64411   }
64412   arg1 = *argp1;
64413   {
64414     try {
64415       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
64416     } catch (std::out_of_range& e) {
64417       {
64418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64419       };
64420     } catch (std::exception& e) {
64421       {
64422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64423       };
64424     } catch (...) {
64425       {
64426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64427       };
64428     }
64429   }
64430   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64431   return jresult;
64432 }
64433
64434
64435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
64436   int jresult ;
64437   int result;
64438
64439   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
64440   jresult = (int)result;
64441   return jresult;
64442 }
64443
64444
64445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
64446   int jresult ;
64447   int result;
64448
64449   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
64450   jresult = (int)result;
64451   return jresult;
64452 }
64453
64454
64455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
64456   int jresult ;
64457   int result;
64458
64459   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
64460   jresult = (int)result;
64461   return jresult;
64462 }
64463
64464
64465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
64466   int jresult ;
64467   int result;
64468
64469   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
64470   jresult = (int)result;
64471   return jresult;
64472 }
64473
64474
64475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
64476   int jresult ;
64477   int result;
64478
64479   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
64480   jresult = (int)result;
64481   return jresult;
64482 }
64483
64484
64485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
64486   void * jresult ;
64487   Dali::Toolkit::PushButton::Property *result = 0 ;
64488
64489   {
64490     try {
64491       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
64492     } catch (std::out_of_range& e) {
64493       {
64494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64495       };
64496     } catch (std::exception& e) {
64497       {
64498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64499       };
64500     } catch (...) {
64501       {
64502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64503       };
64504     }
64505   }
64506   jresult = (void *)result;
64507   return jresult;
64508 }
64509
64510
64511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
64512   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
64513
64514   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
64515   {
64516     try {
64517       delete arg1;
64518     } catch (std::out_of_range& e) {
64519       {
64520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64521       };
64522     } catch (std::exception& e) {
64523       {
64524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64525       };
64526     } catch (...) {
64527       {
64528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64529       };
64530     }
64531   }
64532 }
64533
64534
64535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
64536   void * jresult ;
64537   Dali::Toolkit::PushButton *result = 0 ;
64538
64539   {
64540     try {
64541       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
64542     } catch (std::out_of_range& e) {
64543       {
64544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64545       };
64546     } catch (std::exception& e) {
64547       {
64548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64549       };
64550     } catch (...) {
64551       {
64552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64553       };
64554     }
64555   }
64556   jresult = (void *)result;
64557   return jresult;
64558 }
64559
64560
64561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
64562   void * jresult ;
64563   Dali::Toolkit::PushButton *arg1 = 0 ;
64564   Dali::Toolkit::PushButton *result = 0 ;
64565
64566   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64567   if (!arg1) {
64568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
64569     return 0;
64570   }
64571   {
64572     try {
64573       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
64574     } catch (std::out_of_range& e) {
64575       {
64576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64577       };
64578     } catch (std::exception& e) {
64579       {
64580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64581       };
64582     } catch (...) {
64583       {
64584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64585       };
64586     }
64587   }
64588   jresult = (void *)result;
64589   return jresult;
64590 }
64591
64592
64593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
64594   void * jresult ;
64595   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64596   Dali::Toolkit::PushButton *arg2 = 0 ;
64597   Dali::Toolkit::PushButton *result = 0 ;
64598
64599   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64600   arg2 = (Dali::Toolkit::PushButton *)jarg2;
64601   if (!arg2) {
64602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
64603     return 0;
64604   }
64605   {
64606     try {
64607       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
64608     } catch (std::out_of_range& e) {
64609       {
64610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64611       };
64612     } catch (std::exception& e) {
64613       {
64614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64615       };
64616     } catch (...) {
64617       {
64618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64619       };
64620     }
64621   }
64622   jresult = (void *)result;
64623   return jresult;
64624 }
64625
64626
64627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
64628   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64629
64630   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64631   {
64632     try {
64633       delete arg1;
64634     } catch (std::out_of_range& e) {
64635       {
64636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64637       };
64638     } catch (std::exception& e) {
64639       {
64640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64641       };
64642     } catch (...) {
64643       {
64644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64645       };
64646     }
64647   }
64648 }
64649
64650
64651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
64652   void * jresult ;
64653   Dali::Toolkit::PushButton result;
64654
64655   {
64656     try {
64657       result = Dali::Toolkit::PushButton::New();
64658     } catch (std::out_of_range& e) {
64659       {
64660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64661       };
64662     } catch (std::exception& e) {
64663       {
64664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64665       };
64666     } catch (...) {
64667       {
64668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64669       };
64670     }
64671   }
64672   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
64673   return jresult;
64674 }
64675
64676
64677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
64678   void * jresult ;
64679   Dali::BaseHandle arg1 ;
64680   Dali::BaseHandle *argp1 ;
64681   Dali::Toolkit::PushButton result;
64682
64683   argp1 = (Dali::BaseHandle *)jarg1;
64684   if (!argp1) {
64685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64686     return 0;
64687   }
64688   arg1 = *argp1;
64689   {
64690     try {
64691       result = Dali::Toolkit::PushButton::DownCast(arg1);
64692     } catch (std::out_of_range& e) {
64693       {
64694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64695       };
64696     } catch (std::exception& e) {
64697       {
64698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64699       };
64700     } catch (...) {
64701       {
64702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64703       };
64704     }
64705   }
64706   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
64707   return jresult;
64708 }
64709
64710
64711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
64712   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64713   Dali::Image arg2 ;
64714   Dali::Image *argp2 ;
64715
64716   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64717   argp2 = (Dali::Image *)jarg2;
64718   if (!argp2) {
64719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64720     return ;
64721   }
64722   arg2 = *argp2;
64723   {
64724     try {
64725       (arg1)->SetButtonImage(arg2);
64726     } catch (std::out_of_range& e) {
64727       {
64728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64729       };
64730     } catch (std::exception& e) {
64731       {
64732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64733       };
64734     } catch (...) {
64735       {
64736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64737       };
64738     }
64739   }
64740 }
64741
64742
64743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
64744   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64745   Dali::Actor arg2 ;
64746   Dali::Actor *argp2 ;
64747
64748   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64749   argp2 = (Dali::Actor *)jarg2;
64750   if (!argp2) {
64751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64752     return ;
64753   }
64754   arg2 = *argp2;
64755   {
64756     try {
64757       (arg1)->SetButtonImage(arg2);
64758     } catch (std::out_of_range& e) {
64759       {
64760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64761       };
64762     } catch (std::exception& e) {
64763       {
64764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64765       };
64766     } catch (...) {
64767       {
64768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64769       };
64770     }
64771   }
64772 }
64773
64774
64775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
64776   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64777   Dali::Actor arg2 ;
64778   Dali::Actor *argp2 ;
64779
64780   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64781   argp2 = (Dali::Actor *)jarg2;
64782   if (!argp2) {
64783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64784     return ;
64785   }
64786   arg2 = *argp2;
64787   {
64788     try {
64789       (arg1)->SetBackgroundImage(arg2);
64790     } catch (std::out_of_range& e) {
64791       {
64792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64793       };
64794     } catch (std::exception& e) {
64795       {
64796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64797       };
64798     } catch (...) {
64799       {
64800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64801       };
64802     }
64803   }
64804 }
64805
64806
64807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
64808   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64809   Dali::Image arg2 ;
64810   Dali::Image *argp2 ;
64811
64812   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64813   argp2 = (Dali::Image *)jarg2;
64814   if (!argp2) {
64815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64816     return ;
64817   }
64818   arg2 = *argp2;
64819   {
64820     try {
64821       (arg1)->SetSelectedImage(arg2);
64822     } catch (std::out_of_range& e) {
64823       {
64824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64825       };
64826     } catch (std::exception& e) {
64827       {
64828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64829       };
64830     } catch (...) {
64831       {
64832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64833       };
64834     }
64835   }
64836 }
64837
64838
64839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
64840   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64841   Dali::Actor arg2 ;
64842   Dali::Actor *argp2 ;
64843
64844   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64845   argp2 = (Dali::Actor *)jarg2;
64846   if (!argp2) {
64847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64848     return ;
64849   }
64850   arg2 = *argp2;
64851   {
64852     try {
64853       (arg1)->SetSelectedImage(arg2);
64854     } catch (std::out_of_range& e) {
64855       {
64856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64857       };
64858     } catch (std::exception& e) {
64859       {
64860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64861       };
64862     } catch (...) {
64863       {
64864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64865       };
64866     }
64867   }
64868 }
64869
64870
64871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
64872   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64873   Dali::Actor arg2 ;
64874   Dali::Actor *argp2 ;
64875
64876   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64877   argp2 = (Dali::Actor *)jarg2;
64878   if (!argp2) {
64879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64880     return ;
64881   }
64882   arg2 = *argp2;
64883   {
64884     try {
64885       (arg1)->SetSelectedBackgroundImage(arg2);
64886     } catch (std::out_of_range& e) {
64887       {
64888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64889       };
64890     } catch (std::exception& e) {
64891       {
64892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64893       };
64894     } catch (...) {
64895       {
64896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64897       };
64898     }
64899   }
64900 }
64901
64902
64903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
64904   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64905   Dali::Actor arg2 ;
64906   Dali::Actor *argp2 ;
64907
64908   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64909   argp2 = (Dali::Actor *)jarg2;
64910   if (!argp2) {
64911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64912     return ;
64913   }
64914   arg2 = *argp2;
64915   {
64916     try {
64917       (arg1)->SetDisabledBackgroundImage(arg2);
64918     } catch (std::out_of_range& e) {
64919       {
64920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64921       };
64922     } catch (std::exception& e) {
64923       {
64924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64925       };
64926     } catch (...) {
64927       {
64928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64929       };
64930     }
64931   }
64932 }
64933
64934
64935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
64936   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64937   Dali::Actor arg2 ;
64938   Dali::Actor *argp2 ;
64939
64940   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64941   argp2 = (Dali::Actor *)jarg2;
64942   if (!argp2) {
64943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64944     return ;
64945   }
64946   arg2 = *argp2;
64947   {
64948     try {
64949       (arg1)->SetDisabledImage(arg2);
64950     } catch (std::out_of_range& e) {
64951       {
64952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64953       };
64954     } catch (std::exception& e) {
64955       {
64956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64957       };
64958     } catch (...) {
64959       {
64960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64961       };
64962     }
64963   }
64964 }
64965
64966
64967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
64968   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64969   Dali::Actor arg2 ;
64970   Dali::Actor *argp2 ;
64971
64972   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64973   argp2 = (Dali::Actor *)jarg2;
64974   if (!argp2) {
64975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64976     return ;
64977   }
64978   arg2 = *argp2;
64979   {
64980     try {
64981       (arg1)->SetDisabledSelectedImage(arg2);
64982     } catch (std::out_of_range& e) {
64983       {
64984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64985       };
64986     } catch (std::exception& e) {
64987       {
64988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64989       };
64990     } catch (...) {
64991       {
64992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64993       };
64994     }
64995   }
64996 }
64997
64998
64999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65000   void * jresult ;
65001   Dali::Toolkit::RadioButton *result = 0 ;
65002
65003   {
65004     try {
65005       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65006     } catch (std::out_of_range& e) {
65007       {
65008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65009       };
65010     } catch (std::exception& e) {
65011       {
65012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65013       };
65014     } catch (...) {
65015       {
65016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65017       };
65018     }
65019   }
65020   jresult = (void *)result;
65021   return jresult;
65022 }
65023
65024
65025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65026   void * jresult ;
65027   Dali::Toolkit::RadioButton *arg1 = 0 ;
65028   Dali::Toolkit::RadioButton *result = 0 ;
65029
65030   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65031   if (!arg1) {
65032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65033     return 0;
65034   }
65035   {
65036     try {
65037       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65038     } catch (std::out_of_range& e) {
65039       {
65040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65041       };
65042     } catch (std::exception& e) {
65043       {
65044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65045       };
65046     } catch (...) {
65047       {
65048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65049       };
65050     }
65051   }
65052   jresult = (void *)result;
65053   return jresult;
65054 }
65055
65056
65057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65058   void * jresult ;
65059   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65060   Dali::Toolkit::RadioButton *arg2 = 0 ;
65061   Dali::Toolkit::RadioButton *result = 0 ;
65062
65063   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65064   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65065   if (!arg2) {
65066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65067     return 0;
65068   }
65069   {
65070     try {
65071       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65072     } catch (std::out_of_range& e) {
65073       {
65074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65075       };
65076     } catch (std::exception& e) {
65077       {
65078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65079       };
65080     } catch (...) {
65081       {
65082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65083       };
65084     }
65085   }
65086   jresult = (void *)result;
65087   return jresult;
65088 }
65089
65090
65091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65092   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65093
65094   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65095   {
65096     try {
65097       delete arg1;
65098     } catch (std::out_of_range& e) {
65099       {
65100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65101       };
65102     } catch (std::exception& e) {
65103       {
65104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65105       };
65106     } catch (...) {
65107       {
65108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65109       };
65110     }
65111   }
65112 }
65113
65114
65115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65116   void * jresult ;
65117   Dali::Toolkit::RadioButton result;
65118
65119   {
65120     try {
65121       result = Dali::Toolkit::RadioButton::New();
65122     } catch (std::out_of_range& e) {
65123       {
65124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65125       };
65126     } catch (std::exception& e) {
65127       {
65128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65129       };
65130     } catch (...) {
65131       {
65132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65133       };
65134     }
65135   }
65136   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65137   return jresult;
65138 }
65139
65140
65141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65142   void * jresult ;
65143   std::string *arg1 = 0 ;
65144   Dali::Toolkit::RadioButton result;
65145
65146   if (!jarg1) {
65147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65148     return 0;
65149   }
65150   std::string arg1_str(jarg1);
65151   arg1 = &arg1_str;
65152   {
65153     try {
65154       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65155     } catch (std::out_of_range& e) {
65156       {
65157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65158       };
65159     } catch (std::exception& e) {
65160       {
65161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65162       };
65163     } catch (...) {
65164       {
65165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65166       };
65167     }
65168   }
65169   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65170
65171   //argout typemap for const std::string&
65172
65173   return jresult;
65174 }
65175
65176
65177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65178   void * jresult ;
65179   Dali::BaseHandle arg1 ;
65180   Dali::BaseHandle *argp1 ;
65181   Dali::Toolkit::RadioButton result;
65182
65183   argp1 = (Dali::BaseHandle *)jarg1;
65184   if (!argp1) {
65185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65186     return 0;
65187   }
65188   arg1 = *argp1;
65189   {
65190     try {
65191       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65192     } catch (std::out_of_range& e) {
65193       {
65194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65195       };
65196     } catch (std::exception& e) {
65197       {
65198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65199       };
65200     } catch (...) {
65201       {
65202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65203       };
65204     }
65205   }
65206   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65207   return jresult;
65208 }
65209
65210
65211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65212   int jresult ;
65213   int result;
65214
65215   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65216   jresult = (int)result;
65217   return jresult;
65218 }
65219
65220
65221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65222   int jresult ;
65223   int result;
65224
65225   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65226   jresult = (int)result;
65227   return jresult;
65228 }
65229
65230
65231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65232   int jresult ;
65233   int result;
65234
65235   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65236   jresult = (int)result;
65237   return jresult;
65238 }
65239
65240
65241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65242   int jresult ;
65243   int result;
65244
65245   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65246   jresult = (int)result;
65247   return jresult;
65248 }
65249
65250
65251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65252   int jresult ;
65253   int result;
65254
65255   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65256   jresult = (int)result;
65257   return jresult;
65258 }
65259
65260
65261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65262   int jresult ;
65263   int result;
65264
65265   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65266   jresult = (int)result;
65267   return jresult;
65268 }
65269
65270
65271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65272   void * jresult ;
65273   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65274
65275   {
65276     try {
65277       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
65278     } catch (std::out_of_range& e) {
65279       {
65280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65281       };
65282     } catch (std::exception& e) {
65283       {
65284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65285       };
65286     } catch (...) {
65287       {
65288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65289       };
65290     }
65291   }
65292   jresult = (void *)result;
65293   return jresult;
65294 }
65295
65296
65297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65298   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65299
65300   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
65301   {
65302     try {
65303       delete arg1;
65304     } catch (std::out_of_range& e) {
65305       {
65306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65307       };
65308     } catch (std::exception& e) {
65309       {
65310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65311       };
65312     } catch (...) {
65313       {
65314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65315       };
65316     }
65317   }
65318 }
65319
65320
65321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
65322   int jresult ;
65323   int result;
65324
65325   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
65326   jresult = (int)result;
65327   return jresult;
65328 }
65329
65330
65331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
65332   int jresult ;
65333   int result;
65334
65335   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
65336   jresult = (int)result;
65337   return jresult;
65338 }
65339
65340
65341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
65342   int jresult ;
65343   int result;
65344
65345   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
65346   jresult = (int)result;
65347   return jresult;
65348 }
65349
65350
65351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
65352   void * jresult ;
65353   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
65354
65355   {
65356     try {
65357       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
65358     } catch (std::out_of_range& e) {
65359       {
65360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65361       };
65362     } catch (std::exception& e) {
65363       {
65364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65365       };
65366     } catch (...) {
65367       {
65368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65369       };
65370     }
65371   }
65372   jresult = (void *)result;
65373   return jresult;
65374 }
65375
65376
65377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
65378   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
65379
65380   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
65381   {
65382     try {
65383       delete arg1;
65384     } catch (std::out_of_range& e) {
65385       {
65386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65387       };
65388     } catch (std::exception& e) {
65389       {
65390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65391       };
65392     } catch (...) {
65393       {
65394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65395       };
65396     }
65397   }
65398 }
65399
65400
65401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
65402   void * jresult ;
65403   Dali::Toolkit::FlexContainer *result = 0 ;
65404
65405   {
65406     try {
65407       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
65408     } catch (std::out_of_range& e) {
65409       {
65410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65411       };
65412     } catch (std::exception& e) {
65413       {
65414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65415       };
65416     } catch (...) {
65417       {
65418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65419       };
65420     }
65421   }
65422   jresult = (void *)result;
65423   return jresult;
65424 }
65425
65426
65427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
65428   void * jresult ;
65429   Dali::Toolkit::FlexContainer *arg1 = 0 ;
65430   Dali::Toolkit::FlexContainer *result = 0 ;
65431
65432   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65433   if (!arg1) {
65434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65435     return 0;
65436   }
65437   {
65438     try {
65439       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
65440     } catch (std::out_of_range& e) {
65441       {
65442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65443       };
65444     } catch (std::exception& e) {
65445       {
65446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65447       };
65448     } catch (...) {
65449       {
65450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65451       };
65452     }
65453   }
65454   jresult = (void *)result;
65455   return jresult;
65456 }
65457
65458
65459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
65460   void * jresult ;
65461   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65462   Dali::Toolkit::FlexContainer *arg2 = 0 ;
65463   Dali::Toolkit::FlexContainer *result = 0 ;
65464
65465   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65466   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
65467   if (!arg2) {
65468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65469     return 0;
65470   }
65471   {
65472     try {
65473       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
65474     } catch (std::out_of_range& e) {
65475       {
65476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65477       };
65478     } catch (std::exception& e) {
65479       {
65480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65481       };
65482     } catch (...) {
65483       {
65484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65485       };
65486     }
65487   }
65488   jresult = (void *)result;
65489   return jresult;
65490 }
65491
65492
65493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
65494   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65495
65496   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65497   {
65498     try {
65499       delete arg1;
65500     } catch (std::out_of_range& e) {
65501       {
65502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65503       };
65504     } catch (std::exception& e) {
65505       {
65506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65507       };
65508     } catch (...) {
65509       {
65510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65511       };
65512     }
65513   }
65514 }
65515
65516
65517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
65518   void * jresult ;
65519   Dali::Toolkit::FlexContainer result;
65520
65521   {
65522     try {
65523       result = Dali::Toolkit::FlexContainer::New();
65524     } catch (std::out_of_range& e) {
65525       {
65526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65527       };
65528     } catch (std::exception& e) {
65529       {
65530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65531       };
65532     } catch (...) {
65533       {
65534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65535       };
65536     }
65537   }
65538   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
65539   return jresult;
65540 }
65541
65542
65543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
65544   void * jresult ;
65545   Dali::BaseHandle arg1 ;
65546   Dali::BaseHandle *argp1 ;
65547   Dali::Toolkit::FlexContainer result;
65548
65549   argp1 = (Dali::BaseHandle *)jarg1;
65550   if (!argp1) {
65551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65552     return 0;
65553   }
65554   arg1 = *argp1;
65555   {
65556     try {
65557       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
65558     } catch (std::out_of_range& e) {
65559       {
65560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65561       };
65562     } catch (std::exception& e) {
65563       {
65564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65565       };
65566     } catch (...) {
65567       {
65568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65569       };
65570     }
65571   }
65572   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
65573   return jresult;
65574 }
65575
65576
65577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
65578   int jresult ;
65579   int result;
65580
65581   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
65582   jresult = (int)result;
65583   return jresult;
65584 }
65585
65586
65587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
65588   int jresult ;
65589   int result;
65590
65591   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
65592   jresult = (int)result;
65593   return jresult;
65594 }
65595
65596
65597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
65598   int jresult ;
65599   int result;
65600
65601   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
65602   jresult = (int)result;
65603   return jresult;
65604 }
65605
65606
65607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
65608   int jresult ;
65609   int result;
65610
65611   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
65612   jresult = (int)result;
65613   return jresult;
65614 }
65615
65616
65617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
65618   void * jresult ;
65619   Dali::Toolkit::ImageView::Property *result = 0 ;
65620
65621   {
65622     try {
65623       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
65624     } catch (std::out_of_range& e) {
65625       {
65626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65627       };
65628     } catch (std::exception& e) {
65629       {
65630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65631       };
65632     } catch (...) {
65633       {
65634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65635       };
65636     }
65637   }
65638   jresult = (void *)result;
65639   return jresult;
65640 }
65641
65642
65643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
65644   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
65645
65646   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
65647   {
65648     try {
65649       delete arg1;
65650     } catch (std::out_of_range& e) {
65651       {
65652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65653       };
65654     } catch (std::exception& e) {
65655       {
65656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65657       };
65658     } catch (...) {
65659       {
65660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65661       };
65662     }
65663   }
65664 }
65665
65666
65667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
65668   void * jresult ;
65669   Dali::Toolkit::ImageView *result = 0 ;
65670
65671   {
65672     try {
65673       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
65674     } catch (std::out_of_range& e) {
65675       {
65676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65677       };
65678     } catch (std::exception& e) {
65679       {
65680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65681       };
65682     } catch (...) {
65683       {
65684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65685       };
65686     }
65687   }
65688   jresult = (void *)result;
65689   return jresult;
65690 }
65691
65692
65693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
65694   void * jresult ;
65695   Dali::Toolkit::ImageView result;
65696
65697   {
65698     try {
65699       result = Dali::Toolkit::ImageView::New();
65700     } catch (std::out_of_range& e) {
65701       {
65702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65703       };
65704     } catch (std::exception& e) {
65705       {
65706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65707       };
65708     } catch (...) {
65709       {
65710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65711       };
65712     }
65713   }
65714   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
65715   return jresult;
65716 }
65717
65718
65719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
65720   void * jresult ;
65721   Dali::Image arg1 ;
65722   Dali::Image *argp1 ;
65723   Dali::Toolkit::ImageView result;
65724
65725   argp1 = (Dali::Image *)jarg1;
65726   if (!argp1) {
65727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65728     return 0;
65729   }
65730   arg1 = *argp1;
65731   {
65732     try {
65733       result = Dali::Toolkit::ImageView::New(arg1);
65734     } catch (std::out_of_range& e) {
65735       {
65736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65737       };
65738     } catch (std::exception& e) {
65739       {
65740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65741       };
65742     } catch (...) {
65743       {
65744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65745       };
65746     }
65747   }
65748   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
65749   return jresult;
65750 }
65751
65752
65753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
65754   void * jresult ;
65755   std::string *arg1 = 0 ;
65756   Dali::Toolkit::ImageView result;
65757
65758   if (!jarg1) {
65759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65760     return 0;
65761   }
65762   std::string arg1_str(jarg1);
65763   arg1 = &arg1_str;
65764   {
65765     try {
65766       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
65767     } catch (std::out_of_range& e) {
65768       {
65769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65770       };
65771     } catch (std::exception& e) {
65772       {
65773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65774       };
65775     } catch (...) {
65776       {
65777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65778       };
65779     }
65780   }
65781   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
65782
65783   //argout typemap for const std::string&
65784
65785   return jresult;
65786 }
65787
65788
65789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
65790   void * jresult ;
65791   std::string *arg1 = 0 ;
65792   Dali::ImageDimensions arg2 ;
65793   Dali::ImageDimensions *argp2 ;
65794   Dali::Toolkit::ImageView result;
65795
65796   if (!jarg1) {
65797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65798     return 0;
65799   }
65800   std::string arg1_str(jarg1);
65801   arg1 = &arg1_str;
65802   argp2 = (Dali::ImageDimensions *)jarg2;
65803   if (!argp2) {
65804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
65805     return 0;
65806   }
65807   arg2 = *argp2;
65808   {
65809     try {
65810       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
65811     } catch (std::out_of_range& e) {
65812       {
65813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65814       };
65815     } catch (std::exception& e) {
65816       {
65817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65818       };
65819     } catch (...) {
65820       {
65821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65822       };
65823     }
65824   }
65825   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
65826
65827   //argout typemap for const std::string&
65828
65829   return jresult;
65830 }
65831
65832
65833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
65834   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
65835
65836   arg1 = (Dali::Toolkit::ImageView *)jarg1;
65837   {
65838     try {
65839       delete arg1;
65840     } catch (std::out_of_range& e) {
65841       {
65842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65843       };
65844     } catch (std::exception& e) {
65845       {
65846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65847       };
65848     } catch (...) {
65849       {
65850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65851       };
65852     }
65853   }
65854 }
65855
65856
65857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
65858   void * jresult ;
65859   Dali::Toolkit::ImageView *arg1 = 0 ;
65860   Dali::Toolkit::ImageView *result = 0 ;
65861
65862   arg1 = (Dali::Toolkit::ImageView *)jarg1;
65863   if (!arg1) {
65864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
65865     return 0;
65866   }
65867   {
65868     try {
65869       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
65870     } catch (std::out_of_range& e) {
65871       {
65872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65873       };
65874     } catch (std::exception& e) {
65875       {
65876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65877       };
65878     } catch (...) {
65879       {
65880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65881       };
65882     }
65883   }
65884   jresult = (void *)result;
65885   return jresult;
65886 }
65887
65888
65889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
65890   void * jresult ;
65891   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
65892   Dali::Toolkit::ImageView *arg2 = 0 ;
65893   Dali::Toolkit::ImageView *result = 0 ;
65894
65895   arg1 = (Dali::Toolkit::ImageView *)jarg1;
65896   arg2 = (Dali::Toolkit::ImageView *)jarg2;
65897   if (!arg2) {
65898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
65899     return 0;
65900   }
65901   {
65902     try {
65903       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
65904     } catch (std::out_of_range& e) {
65905       {
65906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65907       };
65908     } catch (std::exception& e) {
65909       {
65910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65911       };
65912     } catch (...) {
65913       {
65914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65915       };
65916     }
65917   }
65918   jresult = (void *)result;
65919   return jresult;
65920 }
65921
65922
65923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
65924   void * jresult ;
65925   Dali::BaseHandle arg1 ;
65926   Dali::BaseHandle *argp1 ;
65927   Dali::Toolkit::ImageView result;
65928
65929   argp1 = (Dali::BaseHandle *)jarg1;
65930   if (!argp1) {
65931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65932     return 0;
65933   }
65934   arg1 = *argp1;
65935   {
65936     try {
65937       result = Dali::Toolkit::ImageView::DownCast(arg1);
65938     } catch (std::out_of_range& e) {
65939       {
65940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65941       };
65942     } catch (std::exception& e) {
65943       {
65944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65945       };
65946     } catch (...) {
65947       {
65948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65949       };
65950     }
65951   }
65952   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
65953   return jresult;
65954 }
65955
65956
65957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
65958   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
65959   Dali::Image arg2 ;
65960   Dali::Image *argp2 ;
65961
65962   arg1 = (Dali::Toolkit::ImageView *)jarg1;
65963   argp2 = (Dali::Image *)jarg2;
65964   if (!argp2) {
65965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65966     return ;
65967   }
65968   arg2 = *argp2;
65969   {
65970     try {
65971       (arg1)->SetImage(arg2);
65972     } catch (std::out_of_range& e) {
65973       {
65974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65975       };
65976     } catch (std::exception& e) {
65977       {
65978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65979       };
65980     } catch (...) {
65981       {
65982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65983       };
65984     }
65985   }
65986 }
65987
65988
65989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
65990   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
65991   std::string *arg2 = 0 ;
65992
65993   arg1 = (Dali::Toolkit::ImageView *)jarg1;
65994   if (!jarg2) {
65995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65996     return ;
65997   }
65998   std::string arg2_str(jarg2);
65999   arg2 = &arg2_str;
66000   {
66001     try {
66002       (arg1)->SetImage((std::string const &)*arg2);
66003     } catch (std::out_of_range& e) {
66004       {
66005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66006       };
66007     } catch (std::exception& e) {
66008       {
66009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66010       };
66011     } catch (...) {
66012       {
66013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66014       };
66015     }
66016   }
66017
66018   //argout typemap for const std::string&
66019
66020 }
66021
66022
66023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66024   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66025   std::string *arg2 = 0 ;
66026   Dali::ImageDimensions arg3 ;
66027   Dali::ImageDimensions *argp3 ;
66028
66029   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66030   if (!jarg2) {
66031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66032     return ;
66033   }
66034   std::string arg2_str(jarg2);
66035   arg2 = &arg2_str;
66036   argp3 = (Dali::ImageDimensions *)jarg3;
66037   if (!argp3) {
66038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66039     return ;
66040   }
66041   arg3 = *argp3;
66042   {
66043     try {
66044       (arg1)->SetImage((std::string const &)*arg2,arg3);
66045     } catch (std::out_of_range& e) {
66046       {
66047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66048       };
66049     } catch (std::exception& e) {
66050       {
66051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66052       };
66053     } catch (...) {
66054       {
66055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66056       };
66057     }
66058   }
66059
66060   //argout typemap for const std::string&
66061
66062 }
66063
66064
66065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
66066   void * jresult ;
66067   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66068   Dali::Image result;
66069
66070   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66071   {
66072     try {
66073       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
66074     } catch (std::out_of_range& e) {
66075       {
66076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66077       };
66078     } catch (std::exception& e) {
66079       {
66080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66081       };
66082     } catch (...) {
66083       {
66084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66085       };
66086     }
66087   }
66088   jresult = new Dali::Image((const Dali::Image &)result);
66089   return jresult;
66090 }
66091
66092
66093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66094   int jresult ;
66095   int result;
66096
66097   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66098   jresult = (int)result;
66099   return jresult;
66100 }
66101
66102
66103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66104   int jresult ;
66105   int result;
66106
66107   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66108   jresult = (int)result;
66109   return jresult;
66110 }
66111
66112
66113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66114   int jresult ;
66115   int result;
66116
66117   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66118   jresult = (int)result;
66119   return jresult;
66120 }
66121
66122
66123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66124   int jresult ;
66125   int result;
66126
66127   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66128   jresult = (int)result;
66129   return jresult;
66130 }
66131
66132
66133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66134   int jresult ;
66135   int result;
66136
66137   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66138   jresult = (int)result;
66139   return jresult;
66140 }
66141
66142
66143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66144   int jresult ;
66145   int result;
66146
66147   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66148   jresult = (int)result;
66149   return jresult;
66150 }
66151
66152
66153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66154   int jresult ;
66155   int result;
66156
66157   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66158   jresult = (int)result;
66159   return jresult;
66160 }
66161
66162
66163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66164   int jresult ;
66165   int result;
66166
66167   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66168   jresult = (int)result;
66169   return jresult;
66170 }
66171
66172
66173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66174   void * jresult ;
66175   Dali::Toolkit::Model3dView::Property *result = 0 ;
66176
66177   {
66178     try {
66179       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66180     } catch (std::out_of_range& e) {
66181       {
66182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66183       };
66184     } catch (std::exception& e) {
66185       {
66186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66187       };
66188     } catch (...) {
66189       {
66190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66191       };
66192     }
66193   }
66194   jresult = (void *)result;
66195   return jresult;
66196 }
66197
66198
66199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66200   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66201
66202   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66203   {
66204     try {
66205       delete arg1;
66206     } catch (std::out_of_range& e) {
66207       {
66208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66209       };
66210     } catch (std::exception& e) {
66211       {
66212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66213       };
66214     } catch (...) {
66215       {
66216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66217       };
66218     }
66219   }
66220 }
66221
66222
66223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66224   void * jresult ;
66225   Dali::Toolkit::Model3dView result;
66226
66227   {
66228     try {
66229       result = Dali::Toolkit::Model3dView::New();
66230     } catch (std::out_of_range& e) {
66231       {
66232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66233       };
66234     } catch (std::exception& e) {
66235       {
66236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66237       };
66238     } catch (...) {
66239       {
66240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66241       };
66242     }
66243   }
66244   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66245   return jresult;
66246 }
66247
66248
66249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66250   void * jresult ;
66251   std::string *arg1 = 0 ;
66252   std::string *arg2 = 0 ;
66253   std::string *arg3 = 0 ;
66254   Dali::Toolkit::Model3dView result;
66255
66256   if (!jarg1) {
66257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66258     return 0;
66259   }
66260   std::string arg1_str(jarg1);
66261   arg1 = &arg1_str;
66262   if (!jarg2) {
66263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66264     return 0;
66265   }
66266   std::string arg2_str(jarg2);
66267   arg2 = &arg2_str;
66268   if (!jarg3) {
66269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66270     return 0;
66271   }
66272   std::string arg3_str(jarg3);
66273   arg3 = &arg3_str;
66274   {
66275     try {
66276       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66277     } catch (std::out_of_range& e) {
66278       {
66279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66280       };
66281     } catch (std::exception& e) {
66282       {
66283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66284       };
66285     } catch (...) {
66286       {
66287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66288       };
66289     }
66290   }
66291   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66292
66293   //argout typemap for const std::string&
66294
66295
66296   //argout typemap for const std::string&
66297
66298
66299   //argout typemap for const std::string&
66300
66301   return jresult;
66302 }
66303
66304
66305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
66306   void * jresult ;
66307   Dali::Toolkit::Model3dView *result = 0 ;
66308
66309   {
66310     try {
66311       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
66312     } catch (std::out_of_range& e) {
66313       {
66314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66315       };
66316     } catch (std::exception& e) {
66317       {
66318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66319       };
66320     } catch (...) {
66321       {
66322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66323       };
66324     }
66325   }
66326   jresult = (void *)result;
66327   return jresult;
66328 }
66329
66330
66331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
66332   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66333
66334   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66335   {
66336     try {
66337       delete arg1;
66338     } catch (std::out_of_range& e) {
66339       {
66340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66341       };
66342     } catch (std::exception& e) {
66343       {
66344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66345       };
66346     } catch (...) {
66347       {
66348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66349       };
66350     }
66351   }
66352 }
66353
66354
66355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
66356   void * jresult ;
66357   Dali::Toolkit::Model3dView *arg1 = 0 ;
66358   Dali::Toolkit::Model3dView *result = 0 ;
66359
66360   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66361   if (!arg1) {
66362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66363     return 0;
66364   }
66365   {
66366     try {
66367       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
66368     } catch (std::out_of_range& e) {
66369       {
66370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66371       };
66372     } catch (std::exception& e) {
66373       {
66374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66375       };
66376     } catch (...) {
66377       {
66378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66379       };
66380     }
66381   }
66382   jresult = (void *)result;
66383   return jresult;
66384 }
66385
66386
66387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
66388   void * jresult ;
66389   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66390   Dali::Toolkit::Model3dView *arg2 = 0 ;
66391   Dali::Toolkit::Model3dView *result = 0 ;
66392
66393   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66394   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
66395   if (!arg2) {
66396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66397     return 0;
66398   }
66399   {
66400     try {
66401       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
66402     } catch (std::out_of_range& e) {
66403       {
66404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66405       };
66406     } catch (std::exception& e) {
66407       {
66408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66409       };
66410     } catch (...) {
66411       {
66412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66413       };
66414     }
66415   }
66416   jresult = (void *)result;
66417   return jresult;
66418 }
66419
66420
66421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
66422   void * jresult ;
66423   Dali::BaseHandle arg1 ;
66424   Dali::BaseHandle *argp1 ;
66425   Dali::Toolkit::Model3dView result;
66426
66427   argp1 = (Dali::BaseHandle *)jarg1;
66428   if (!argp1) {
66429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66430     return 0;
66431   }
66432   arg1 = *argp1;
66433   {
66434     try {
66435       result = Dali::Toolkit::Model3dView::DownCast(arg1);
66436     } catch (std::out_of_range& e) {
66437       {
66438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66439       };
66440     } catch (std::exception& e) {
66441       {
66442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66443       };
66444     } catch (...) {
66445       {
66446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66447       };
66448     }
66449   }
66450   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66451   return jresult;
66452 }
66453
66454
66455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
66456   int jresult ;
66457   int result;
66458
66459   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
66460   jresult = (int)result;
66461   return jresult;
66462 }
66463
66464
66465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
66466   int jresult ;
66467   int result;
66468
66469   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
66470   jresult = (int)result;
66471   return jresult;
66472 }
66473
66474
66475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
66476   int jresult ;
66477   int result;
66478
66479   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
66480   jresult = (int)result;
66481   return jresult;
66482 }
66483
66484
66485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
66486   int jresult ;
66487   int result;
66488
66489   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
66490   jresult = (int)result;
66491   return jresult;
66492 }
66493
66494
66495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
66496   int jresult ;
66497   int result;
66498
66499   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
66500   jresult = (int)result;
66501   return jresult;
66502 }
66503
66504
66505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
66506   int jresult ;
66507   int result;
66508
66509   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
66510   jresult = (int)result;
66511   return jresult;
66512 }
66513
66514
66515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
66516   int jresult ;
66517   int result;
66518
66519   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
66520   jresult = (int)result;
66521   return jresult;
66522 }
66523
66524
66525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
66526   int jresult ;
66527   int result;
66528
66529   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
66530   jresult = (int)result;
66531   return jresult;
66532 }
66533
66534
66535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
66536   int jresult ;
66537   int result;
66538
66539   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
66540   jresult = (int)result;
66541   return jresult;
66542 }
66543
66544
66545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
66546   void * jresult ;
66547   Dali::Toolkit::ScrollBar::Property *result = 0 ;
66548
66549   {
66550     try {
66551       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
66552     } catch (std::out_of_range& e) {
66553       {
66554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66555       };
66556     } catch (std::exception& e) {
66557       {
66558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66559       };
66560     } catch (...) {
66561       {
66562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66563       };
66564     }
66565   }
66566   jresult = (void *)result;
66567   return jresult;
66568 }
66569
66570
66571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
66572   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
66573
66574   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
66575   {
66576     try {
66577       delete arg1;
66578     } catch (std::out_of_range& e) {
66579       {
66580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66581       };
66582     } catch (std::exception& e) {
66583       {
66584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66585       };
66586     } catch (...) {
66587       {
66588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66589       };
66590     }
66591   }
66592 }
66593
66594
66595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
66596   void * jresult ;
66597   Dali::Toolkit::ScrollBar *result = 0 ;
66598
66599   {
66600     try {
66601       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
66602     } catch (std::out_of_range& e) {
66603       {
66604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66605       };
66606     } catch (std::exception& e) {
66607       {
66608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66609       };
66610     } catch (...) {
66611       {
66612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66613       };
66614     }
66615   }
66616   jresult = (void *)result;
66617   return jresult;
66618 }
66619
66620
66621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
66622   void * jresult ;
66623   Dali::Toolkit::ScrollBar *arg1 = 0 ;
66624   Dali::Toolkit::ScrollBar *result = 0 ;
66625
66626   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66627   if (!arg1) {
66628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
66629     return 0;
66630   }
66631   {
66632     try {
66633       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
66634     } catch (std::out_of_range& e) {
66635       {
66636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66637       };
66638     } catch (std::exception& e) {
66639       {
66640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66641       };
66642     } catch (...) {
66643       {
66644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66645       };
66646     }
66647   }
66648   jresult = (void *)result;
66649   return jresult;
66650 }
66651
66652
66653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
66654   void * jresult ;
66655   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66656   Dali::Toolkit::ScrollBar *arg2 = 0 ;
66657   Dali::Toolkit::ScrollBar *result = 0 ;
66658
66659   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66660   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
66661   if (!arg2) {
66662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
66663     return 0;
66664   }
66665   {
66666     try {
66667       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
66668     } catch (std::out_of_range& e) {
66669       {
66670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66671       };
66672     } catch (std::exception& e) {
66673       {
66674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66675       };
66676     } catch (...) {
66677       {
66678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66679       };
66680     }
66681   }
66682   jresult = (void *)result;
66683   return jresult;
66684 }
66685
66686
66687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
66688   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66689
66690   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66691   {
66692     try {
66693       delete arg1;
66694     } catch (std::out_of_range& e) {
66695       {
66696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66697       };
66698     } catch (std::exception& e) {
66699       {
66700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66701       };
66702     } catch (...) {
66703       {
66704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66705       };
66706     }
66707   }
66708 }
66709
66710
66711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
66712   void * jresult ;
66713   Dali::Toolkit::ScrollBar::Direction arg1 ;
66714   Dali::Toolkit::ScrollBar result;
66715
66716   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
66717   {
66718     try {
66719       result = Dali::Toolkit::ScrollBar::New(arg1);
66720     } catch (std::out_of_range& e) {
66721       {
66722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66723       };
66724     } catch (std::exception& e) {
66725       {
66726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66727       };
66728     } catch (...) {
66729       {
66730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66731       };
66732     }
66733   }
66734   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
66735   return jresult;
66736 }
66737
66738
66739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
66740   void * jresult ;
66741   Dali::Toolkit::ScrollBar result;
66742
66743   {
66744     try {
66745       result = Dali::Toolkit::ScrollBar::New();
66746     } catch (std::out_of_range& e) {
66747       {
66748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66749       };
66750     } catch (std::exception& e) {
66751       {
66752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66753       };
66754     } catch (...) {
66755       {
66756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66757       };
66758     }
66759   }
66760   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
66761   return jresult;
66762 }
66763
66764
66765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
66766   void * jresult ;
66767   Dali::BaseHandle arg1 ;
66768   Dali::BaseHandle *argp1 ;
66769   Dali::Toolkit::ScrollBar result;
66770
66771   argp1 = (Dali::BaseHandle *)jarg1;
66772   if (!argp1) {
66773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66774     return 0;
66775   }
66776   arg1 = *argp1;
66777   {
66778     try {
66779       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
66780     } catch (std::out_of_range& e) {
66781       {
66782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66783       };
66784     } catch (std::exception& e) {
66785       {
66786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66787       };
66788     } catch (...) {
66789       {
66790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66791       };
66792     }
66793   }
66794   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
66795   return jresult;
66796 }
66797
66798
66799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
66800   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66801   Dali::Handle arg2 ;
66802   Dali::Property::Index arg3 ;
66803   Dali::Property::Index arg4 ;
66804   Dali::Property::Index arg5 ;
66805   Dali::Property::Index arg6 ;
66806   Dali::Handle *argp2 ;
66807
66808   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66809   argp2 = (Dali::Handle *)jarg2;
66810   if (!argp2) {
66811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
66812     return ;
66813   }
66814   arg2 = *argp2;
66815   arg3 = (Dali::Property::Index)jarg3;
66816   arg4 = (Dali::Property::Index)jarg4;
66817   arg5 = (Dali::Property::Index)jarg5;
66818   arg6 = (Dali::Property::Index)jarg6;
66819   {
66820     try {
66821       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
66822     } catch (std::out_of_range& e) {
66823       {
66824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66825       };
66826     } catch (std::exception& e) {
66827       {
66828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66829       };
66830     } catch (...) {
66831       {
66832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66833       };
66834     }
66835   }
66836 }
66837
66838
66839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
66840   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66841   Dali::Actor arg2 ;
66842   Dali::Actor *argp2 ;
66843
66844   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66845   argp2 = (Dali::Actor *)jarg2;
66846   if (!argp2) {
66847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66848     return ;
66849   }
66850   arg2 = *argp2;
66851   {
66852     try {
66853       (arg1)->SetScrollIndicator(arg2);
66854     } catch (std::out_of_range& e) {
66855       {
66856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66857       };
66858     } catch (std::exception& e) {
66859       {
66860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66861       };
66862     } catch (...) {
66863       {
66864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66865       };
66866     }
66867   }
66868 }
66869
66870
66871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
66872   void * jresult ;
66873   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66874   Dali::Actor result;
66875
66876   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66877   {
66878     try {
66879       result = (arg1)->GetScrollIndicator();
66880     } catch (std::out_of_range& e) {
66881       {
66882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66883       };
66884     } catch (std::exception& e) {
66885       {
66886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66887       };
66888     } catch (...) {
66889       {
66890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66891       };
66892     }
66893   }
66894   jresult = new Dali::Actor((const Dali::Actor &)result);
66895   return jresult;
66896 }
66897
66898
66899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
66900   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66901   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
66902
66903   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66904   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
66905   if (!arg2) {
66906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
66907     return ;
66908   }
66909   {
66910     try {
66911       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
66912     } catch (std::out_of_range& e) {
66913       {
66914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66915       };
66916     } catch (std::exception& e) {
66917       {
66918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66919       };
66920     } catch (...) {
66921       {
66922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66923       };
66924     }
66925   }
66926 }
66927
66928
66929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
66930   void * jresult ;
66931   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66932   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
66933
66934   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66935   {
66936     try {
66937       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
66938     } catch (std::out_of_range& e) {
66939       {
66940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66941       };
66942     } catch (std::exception& e) {
66943       {
66944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66945       };
66946     } catch (...) {
66947       {
66948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66949       };
66950     }
66951   }
66952   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
66953   return jresult;
66954 }
66955
66956
66957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
66958   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66959   Dali::Toolkit::ScrollBar::Direction arg2 ;
66960
66961   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66962   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
66963   {
66964     try {
66965       (arg1)->SetScrollDirection(arg2);
66966     } catch (std::out_of_range& e) {
66967       {
66968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66969       };
66970     } catch (std::exception& e) {
66971       {
66972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66973       };
66974     } catch (...) {
66975       {
66976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66977       };
66978     }
66979   }
66980 }
66981
66982
66983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
66984   int jresult ;
66985   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66986   Dali::Toolkit::ScrollBar::Direction result;
66987
66988   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66989   {
66990     try {
66991       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
66992     } catch (std::out_of_range& e) {
66993       {
66994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66995       };
66996     } catch (std::exception& e) {
66997       {
66998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66999       };
67000     } catch (...) {
67001       {
67002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67003       };
67004     }
67005   }
67006   jresult = (int)result;
67007   return jresult;
67008 }
67009
67010
67011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67012   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67013   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67014
67015   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67016   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67017   {
67018     try {
67019       (arg1)->SetIndicatorHeightPolicy(arg2);
67020     } catch (std::out_of_range& e) {
67021       {
67022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67023       };
67024     } catch (std::exception& e) {
67025       {
67026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67027       };
67028     } catch (...) {
67029       {
67030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67031       };
67032     }
67033   }
67034 }
67035
67036
67037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67038   int jresult ;
67039   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67040   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67041
67042   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67043   {
67044     try {
67045       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67046     } catch (std::out_of_range& e) {
67047       {
67048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67049       };
67050     } catch (std::exception& e) {
67051       {
67052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67053       };
67054     } catch (...) {
67055       {
67056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67057       };
67058     }
67059   }
67060   jresult = (int)result;
67061   return jresult;
67062 }
67063
67064
67065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67066   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67067   float arg2 ;
67068
67069   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67070   arg2 = (float)jarg2;
67071   {
67072     try {
67073       (arg1)->SetIndicatorFixedHeight(arg2);
67074     } catch (std::out_of_range& e) {
67075       {
67076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67077       };
67078     } catch (std::exception& e) {
67079       {
67080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67081       };
67082     } catch (...) {
67083       {
67084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67085       };
67086     }
67087   }
67088 }
67089
67090
67091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67092   float jresult ;
67093   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67094   float result;
67095
67096   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67097   {
67098     try {
67099       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67100     } catch (std::out_of_range& e) {
67101       {
67102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67103       };
67104     } catch (std::exception& e) {
67105       {
67106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67107       };
67108     } catch (...) {
67109       {
67110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67111       };
67112     }
67113   }
67114   jresult = result;
67115   return jresult;
67116 }
67117
67118
67119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67120   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67121   float arg2 ;
67122
67123   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67124   arg2 = (float)jarg2;
67125   {
67126     try {
67127       (arg1)->SetIndicatorShowDuration(arg2);
67128     } catch (std::out_of_range& e) {
67129       {
67130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67131       };
67132     } catch (std::exception& e) {
67133       {
67134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67135       };
67136     } catch (...) {
67137       {
67138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67139       };
67140     }
67141   }
67142 }
67143
67144
67145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67146   float jresult ;
67147   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67148   float result;
67149
67150   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67151   {
67152     try {
67153       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67154     } catch (std::out_of_range& e) {
67155       {
67156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67157       };
67158     } catch (std::exception& e) {
67159       {
67160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67161       };
67162     } catch (...) {
67163       {
67164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67165       };
67166     }
67167   }
67168   jresult = result;
67169   return jresult;
67170 }
67171
67172
67173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
67174   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67175   float arg2 ;
67176
67177   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67178   arg2 = (float)jarg2;
67179   {
67180     try {
67181       (arg1)->SetIndicatorHideDuration(arg2);
67182     } catch (std::out_of_range& e) {
67183       {
67184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67185       };
67186     } catch (std::exception& e) {
67187       {
67188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67189       };
67190     } catch (...) {
67191       {
67192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67193       };
67194     }
67195   }
67196 }
67197
67198
67199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
67200   float jresult ;
67201   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67202   float result;
67203
67204   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67205   {
67206     try {
67207       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
67208     } catch (std::out_of_range& e) {
67209       {
67210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67211       };
67212     } catch (std::exception& e) {
67213       {
67214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67215       };
67216     } catch (...) {
67217       {
67218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67219       };
67220     }
67221   }
67222   jresult = result;
67223   return jresult;
67224 }
67225
67226
67227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
67228   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67229
67230   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67231   {
67232     try {
67233       (arg1)->ShowIndicator();
67234     } catch (std::out_of_range& e) {
67235       {
67236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67237       };
67238     } catch (std::exception& e) {
67239       {
67240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67241       };
67242     } catch (...) {
67243       {
67244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67245       };
67246     }
67247   }
67248 }
67249
67250
67251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
67252   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67253
67254   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67255   {
67256     try {
67257       (arg1)->HideIndicator();
67258     } catch (std::out_of_range& e) {
67259       {
67260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67261       };
67262     } catch (std::exception& e) {
67263       {
67264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67265       };
67266     } catch (...) {
67267       {
67268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67269       };
67270     }
67271   }
67272 }
67273
67274
67275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
67276   void * jresult ;
67277   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67278   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
67279
67280   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67281   {
67282     try {
67283       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
67284     } catch (std::out_of_range& e) {
67285       {
67286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67287       };
67288     } catch (std::exception& e) {
67289       {
67290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67291       };
67292     } catch (...) {
67293       {
67294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67295       };
67296     }
67297   }
67298   jresult = (void *)result;
67299   return jresult;
67300 }
67301
67302
67303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
67304   void * jresult ;
67305   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67306   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
67307
67308   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67309   {
67310     try {
67311       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
67312     } catch (std::out_of_range& e) {
67313       {
67314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67315       };
67316     } catch (std::exception& e) {
67317       {
67318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67319       };
67320     } catch (...) {
67321       {
67322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67323       };
67324     }
67325   }
67326   jresult = (void *)result;
67327   return jresult;
67328 }
67329
67330
67331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
67332   int jresult ;
67333   int result;
67334
67335   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
67336   jresult = (int)result;
67337   return jresult;
67338 }
67339
67340
67341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
67342   int jresult ;
67343   int result;
67344
67345   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
67346   jresult = (int)result;
67347   return jresult;
67348 }
67349
67350
67351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
67352   int jresult ;
67353   int result;
67354
67355   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
67356   jresult = (int)result;
67357   return jresult;
67358 }
67359
67360
67361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
67362   int jresult ;
67363   int result;
67364
67365   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
67366   jresult = (int)result;
67367   return jresult;
67368 }
67369
67370
67371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
67372   int jresult ;
67373   int result;
67374
67375   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
67376   jresult = (int)result;
67377   return jresult;
67378 }
67379
67380
67381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
67382   int jresult ;
67383   int result;
67384
67385   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
67386   jresult = (int)result;
67387   return jresult;
67388 }
67389
67390
67391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
67392   int jresult ;
67393   int result;
67394
67395   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
67396   jresult = (int)result;
67397   return jresult;
67398 }
67399
67400
67401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
67402   int jresult ;
67403   int result;
67404
67405   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
67406   jresult = (int)result;
67407   return jresult;
67408 }
67409
67410
67411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
67412   int jresult ;
67413   int result;
67414
67415   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
67416   jresult = (int)result;
67417   return jresult;
67418 }
67419
67420
67421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
67422   int jresult ;
67423   int result;
67424
67425   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
67426   jresult = (int)result;
67427   return jresult;
67428 }
67429
67430
67431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
67432   int jresult ;
67433   int result;
67434
67435   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
67436   jresult = (int)result;
67437   return jresult;
67438 }
67439
67440
67441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
67442   int jresult ;
67443   int result;
67444
67445   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
67446   jresult = (int)result;
67447   return jresult;
67448 }
67449
67450
67451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
67452   int jresult ;
67453   int result;
67454
67455   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
67456   jresult = (int)result;
67457   return jresult;
67458 }
67459
67460
67461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
67462   int jresult ;
67463   int result;
67464
67465   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
67466   jresult = (int)result;
67467   return jresult;
67468 }
67469
67470
67471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
67472   void * jresult ;
67473   Dali::Toolkit::Scrollable::Property *result = 0 ;
67474
67475   {
67476     try {
67477       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
67478     } catch (std::out_of_range& e) {
67479       {
67480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67481       };
67482     } catch (std::exception& e) {
67483       {
67484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67485       };
67486     } catch (...) {
67487       {
67488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67489       };
67490     }
67491   }
67492   jresult = (void *)result;
67493   return jresult;
67494 }
67495
67496
67497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
67498   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
67499
67500   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
67501   {
67502     try {
67503       delete arg1;
67504     } catch (std::out_of_range& e) {
67505       {
67506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67507       };
67508     } catch (std::exception& e) {
67509       {
67510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67511       };
67512     } catch (...) {
67513       {
67514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67515       };
67516     }
67517   }
67518 }
67519
67520
67521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
67522   void * jresult ;
67523   Dali::Toolkit::Scrollable *result = 0 ;
67524
67525   {
67526     try {
67527       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
67528     } catch (std::out_of_range& e) {
67529       {
67530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67531       };
67532     } catch (std::exception& e) {
67533       {
67534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67535       };
67536     } catch (...) {
67537       {
67538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67539       };
67540     }
67541   }
67542   jresult = (void *)result;
67543   return jresult;
67544 }
67545
67546
67547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
67548   void * jresult ;
67549   Dali::Toolkit::Scrollable *arg1 = 0 ;
67550   Dali::Toolkit::Scrollable *result = 0 ;
67551
67552   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67553   if (!arg1) {
67554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
67555     return 0;
67556   }
67557   {
67558     try {
67559       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
67560     } catch (std::out_of_range& e) {
67561       {
67562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67563       };
67564     } catch (std::exception& e) {
67565       {
67566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67567       };
67568     } catch (...) {
67569       {
67570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67571       };
67572     }
67573   }
67574   jresult = (void *)result;
67575   return jresult;
67576 }
67577
67578
67579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
67580   void * jresult ;
67581   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67582   Dali::Toolkit::Scrollable *arg2 = 0 ;
67583   Dali::Toolkit::Scrollable *result = 0 ;
67584
67585   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67586   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
67587   if (!arg2) {
67588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
67589     return 0;
67590   }
67591   {
67592     try {
67593       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
67594     } catch (std::out_of_range& e) {
67595       {
67596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67597       };
67598     } catch (std::exception& e) {
67599       {
67600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67601       };
67602     } catch (...) {
67603       {
67604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67605       };
67606     }
67607   }
67608   jresult = (void *)result;
67609   return jresult;
67610 }
67611
67612
67613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
67614   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67615
67616   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67617   {
67618     try {
67619       delete arg1;
67620     } catch (std::out_of_range& e) {
67621       {
67622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67623       };
67624     } catch (std::exception& e) {
67625       {
67626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67627       };
67628     } catch (...) {
67629       {
67630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67631       };
67632     }
67633   }
67634 }
67635
67636
67637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
67638   void * jresult ;
67639   Dali::BaseHandle arg1 ;
67640   Dali::BaseHandle *argp1 ;
67641   Dali::Toolkit::Scrollable result;
67642
67643   argp1 = (Dali::BaseHandle *)jarg1;
67644   if (!argp1) {
67645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67646     return 0;
67647   }
67648   arg1 = *argp1;
67649   {
67650     try {
67651       result = Dali::Toolkit::Scrollable::DownCast(arg1);
67652     } catch (std::out_of_range& e) {
67653       {
67654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67655       };
67656     } catch (std::exception& e) {
67657       {
67658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67659       };
67660     } catch (...) {
67661       {
67662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67663       };
67664     }
67665   }
67666   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
67667   return jresult;
67668 }
67669
67670
67671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
67672   unsigned int jresult ;
67673   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67674   bool result;
67675
67676   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67677   {
67678     try {
67679       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
67680     } catch (std::out_of_range& e) {
67681       {
67682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67683       };
67684     } catch (std::exception& e) {
67685       {
67686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67687       };
67688     } catch (...) {
67689       {
67690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67691       };
67692     }
67693   }
67694   jresult = result;
67695   return jresult;
67696 }
67697
67698
67699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
67700   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67701   bool arg2 ;
67702
67703   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67704   arg2 = jarg2 ? true : false;
67705   {
67706     try {
67707       (arg1)->SetOvershootEnabled(arg2);
67708     } catch (std::out_of_range& e) {
67709       {
67710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67711       };
67712     } catch (std::exception& e) {
67713       {
67714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67715       };
67716     } catch (...) {
67717       {
67718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67719       };
67720     }
67721   }
67722 }
67723
67724
67725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
67726   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67727   Dali::Vector4 *arg2 = 0 ;
67728
67729   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67730   arg2 = (Dali::Vector4 *)jarg2;
67731   if (!arg2) {
67732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67733     return ;
67734   }
67735   {
67736     try {
67737       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
67738     } catch (std::out_of_range& e) {
67739       {
67740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67741       };
67742     } catch (std::exception& e) {
67743       {
67744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67745       };
67746     } catch (...) {
67747       {
67748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67749       };
67750     }
67751   }
67752 }
67753
67754
67755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
67756   void * jresult ;
67757   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67758   Dali::Vector4 result;
67759
67760   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67761   {
67762     try {
67763       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
67764     } catch (std::out_of_range& e) {
67765       {
67766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67767       };
67768     } catch (std::exception& e) {
67769       {
67770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67771       };
67772     } catch (...) {
67773       {
67774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67775       };
67776     }
67777   }
67778   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67779   return jresult;
67780 }
67781
67782
67783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
67784   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67785   float arg2 ;
67786
67787   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67788   arg2 = (float)jarg2;
67789   {
67790     try {
67791       (arg1)->SetOvershootAnimationSpeed(arg2);
67792     } catch (std::out_of_range& e) {
67793       {
67794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67795       };
67796     } catch (std::exception& e) {
67797       {
67798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67799       };
67800     } catch (...) {
67801       {
67802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67803       };
67804     }
67805   }
67806 }
67807
67808
67809 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
67810   float jresult ;
67811   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67812   float result;
67813
67814   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67815   {
67816     try {
67817       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
67818     } catch (std::out_of_range& e) {
67819       {
67820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67821       };
67822     } catch (std::exception& e) {
67823       {
67824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67825       };
67826     } catch (...) {
67827       {
67828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67829       };
67830     }
67831   }
67832   jresult = result;
67833   return jresult;
67834 }
67835
67836
67837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
67838   void * jresult ;
67839   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67840   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
67841
67842   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67843   {
67844     try {
67845       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
67846     } catch (std::out_of_range& e) {
67847       {
67848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67849       };
67850     } catch (std::exception& e) {
67851       {
67852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67853       };
67854     } catch (...) {
67855       {
67856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67857       };
67858     }
67859   }
67860   jresult = (void *)result;
67861   return jresult;
67862 }
67863
67864
67865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
67866   void * jresult ;
67867   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67868   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
67869
67870   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67871   {
67872     try {
67873       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
67874     } catch (std::out_of_range& e) {
67875       {
67876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67877       };
67878     } catch (std::exception& e) {
67879       {
67880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67881       };
67882     } catch (...) {
67883       {
67884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67885       };
67886     }
67887   }
67888   jresult = (void *)result;
67889   return jresult;
67890 }
67891
67892
67893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
67894   void * jresult ;
67895   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67896   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
67897
67898   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67899   {
67900     try {
67901       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
67902     } catch (std::out_of_range& e) {
67903       {
67904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67905       };
67906     } catch (std::exception& e) {
67907       {
67908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67909       };
67910     } catch (...) {
67911       {
67912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67913       };
67914     }
67915   }
67916   jresult = (void *)result;
67917   return jresult;
67918 }
67919
67920
67921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
67922   unsigned int jresult ;
67923   Dali::Toolkit::ControlOrientation::Type arg1 ;
67924   bool result;
67925
67926   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
67927   {
67928     try {
67929       result = (bool)Dali::Toolkit::IsVertical(arg1);
67930     } catch (std::out_of_range& e) {
67931       {
67932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67933       };
67934     } catch (std::exception& e) {
67935       {
67936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67937       };
67938     } catch (...) {
67939       {
67940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67941       };
67942     }
67943   }
67944   jresult = result;
67945   return jresult;
67946 }
67947
67948
67949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
67950   unsigned int jresult ;
67951   Dali::Toolkit::ControlOrientation::Type arg1 ;
67952   bool result;
67953
67954   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
67955   {
67956     try {
67957       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
67958     } catch (std::out_of_range& e) {
67959       {
67960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67961       };
67962     } catch (std::exception& e) {
67963       {
67964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67965       };
67966     } catch (...) {
67967       {
67968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67969       };
67970     }
67971   }
67972   jresult = result;
67973   return jresult;
67974 }
67975
67976
67977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
67978   void * jresult ;
67979   unsigned int arg1 ;
67980   unsigned int arg2 ;
67981   Dali::Toolkit::ItemRange *result = 0 ;
67982
67983   arg1 = (unsigned int)jarg1;
67984   arg2 = (unsigned int)jarg2;
67985   {
67986     try {
67987       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
67988     } catch (std::out_of_range& e) {
67989       {
67990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67991       };
67992     } catch (std::exception& e) {
67993       {
67994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67995       };
67996     } catch (...) {
67997       {
67998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67999       };
68000     }
68001   }
68002   jresult = (void *)result;
68003   return jresult;
68004 }
68005
68006
68007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68008   void * jresult ;
68009   Dali::Toolkit::ItemRange *arg1 = 0 ;
68010   Dali::Toolkit::ItemRange *result = 0 ;
68011
68012   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68013   if (!arg1) {
68014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68015     return 0;
68016   }
68017   {
68018     try {
68019       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68020     } catch (std::out_of_range& e) {
68021       {
68022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68023       };
68024     } catch (std::exception& e) {
68025       {
68026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68027       };
68028     } catch (...) {
68029       {
68030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68031       };
68032     }
68033   }
68034   jresult = (void *)result;
68035   return jresult;
68036 }
68037
68038
68039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
68040   void * jresult ;
68041   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68042   Dali::Toolkit::ItemRange *arg2 = 0 ;
68043   Dali::Toolkit::ItemRange *result = 0 ;
68044
68045   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68046   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68047   if (!arg2) {
68048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68049     return 0;
68050   }
68051   {
68052     try {
68053       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
68054     } catch (std::out_of_range& e) {
68055       {
68056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68057       };
68058     } catch (std::exception& e) {
68059       {
68060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68061       };
68062     } catch (...) {
68063       {
68064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68065       };
68066     }
68067   }
68068   jresult = (void *)result;
68069   return jresult;
68070 }
68071
68072
68073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
68074   unsigned int jresult ;
68075   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68076   unsigned int arg2 ;
68077   bool result;
68078
68079   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68080   arg2 = (unsigned int)jarg2;
68081   {
68082     try {
68083       result = (bool)(arg1)->Within(arg2);
68084     } catch (std::out_of_range& e) {
68085       {
68086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68087       };
68088     } catch (std::exception& e) {
68089       {
68090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68091       };
68092     } catch (...) {
68093       {
68094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68095       };
68096     }
68097   }
68098   jresult = result;
68099   return jresult;
68100 }
68101
68102
68103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
68104   void * jresult ;
68105   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68106   Dali::Toolkit::ItemRange *arg2 = 0 ;
68107   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68108
68109   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68110   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68111   if (!arg2) {
68112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68113     return 0;
68114   }
68115   {
68116     try {
68117       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
68118     } catch (std::out_of_range& e) {
68119       {
68120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68121       };
68122     } catch (std::exception& e) {
68123       {
68124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68125       };
68126     } catch (...) {
68127       {
68128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68129       };
68130     }
68131   }
68132   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68133   return jresult;
68134 }
68135
68136
68137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
68138   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68139   unsigned int arg2 ;
68140
68141   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68142   arg2 = (unsigned int)jarg2;
68143   if (arg1) (arg1)->begin = arg2;
68144 }
68145
68146
68147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
68148   unsigned int jresult ;
68149   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68150   unsigned int result;
68151
68152   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68153   result = (unsigned int) ((arg1)->begin);
68154   jresult = result;
68155   return jresult;
68156 }
68157
68158
68159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
68160   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68161   unsigned int arg2 ;
68162
68163   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68164   arg2 = (unsigned int)jarg2;
68165   if (arg1) (arg1)->end = arg2;
68166 }
68167
68168
68169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
68170   unsigned int jresult ;
68171   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68172   unsigned int result;
68173
68174   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68175   result = (unsigned int) ((arg1)->end);
68176   jresult = result;
68177   return jresult;
68178 }
68179
68180
68181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
68182   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68183
68184   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68185   {
68186     try {
68187       delete arg1;
68188     } catch (std::out_of_range& e) {
68189       {
68190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68191       };
68192     } catch (std::exception& e) {
68193       {
68194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68195       };
68196     } catch (...) {
68197       {
68198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68199       };
68200     }
68201   }
68202 }
68203
68204
68205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
68206   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68207
68208   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68209   {
68210     try {
68211       delete arg1;
68212     } catch (std::out_of_range& e) {
68213       {
68214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68215       };
68216     } catch (std::exception& e) {
68217       {
68218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68219       };
68220     } catch (...) {
68221       {
68222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68223       };
68224     }
68225   }
68226 }
68227
68228
68229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
68230   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68231   Dali::Toolkit::ControlOrientation::Type arg2 ;
68232
68233   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68234   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
68235   {
68236     try {
68237       (arg1)->SetOrientation(arg2);
68238     } catch (std::out_of_range& e) {
68239       {
68240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68241       };
68242     } catch (std::exception& e) {
68243       {
68244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68245       };
68246     } catch (...) {
68247       {
68248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68249       };
68250     }
68251   }
68252 }
68253
68254
68255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
68256   int jresult ;
68257   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68258   Dali::Toolkit::ControlOrientation::Type result;
68259
68260   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68261   {
68262     try {
68263       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
68264     } catch (std::out_of_range& e) {
68265       {
68266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68267       };
68268     } catch (std::exception& e) {
68269       {
68270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68271       };
68272     } catch (...) {
68273       {
68274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68275       };
68276     }
68277   }
68278   jresult = (int)result;
68279   return jresult;
68280 }
68281
68282
68283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
68284   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68285   Dali::Property::Map *arg2 = 0 ;
68286
68287   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68288   arg2 = (Dali::Property::Map *)jarg2;
68289   if (!arg2) {
68290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
68291     return ;
68292   }
68293   {
68294     try {
68295       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
68296     } catch (std::out_of_range& e) {
68297       {
68298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68299       };
68300     } catch (std::exception& e) {
68301       {
68302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68303       };
68304     } catch (...) {
68305       {
68306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68307       };
68308     }
68309   }
68310 }
68311
68312
68313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
68314   void * jresult ;
68315   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68316   Dali::Property::Map result;
68317
68318   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68319   {
68320     try {
68321       result = (arg1)->GetLayoutProperties();
68322     } catch (std::out_of_range& e) {
68323       {
68324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68325       };
68326     } catch (std::exception& e) {
68327       {
68328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68329       };
68330     } catch (...) {
68331       {
68332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68333       };
68334     }
68335   }
68336   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
68337   return jresult;
68338 }
68339
68340
68341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68342   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68343   unsigned int arg2 ;
68344   Dali::Vector3 *arg3 = 0 ;
68345   Dali::Vector3 *arg4 = 0 ;
68346
68347   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68348   arg2 = (unsigned int)jarg2;
68349   arg3 = (Dali::Vector3 *)jarg3;
68350   if (!arg3) {
68351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68352     return ;
68353   }
68354   arg4 = (Dali::Vector3 *)jarg4;
68355   if (!arg4) {
68356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68357     return ;
68358   }
68359   {
68360     try {
68361       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68362     } catch (std::out_of_range& e) {
68363       {
68364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68365       };
68366     } catch (std::exception& e) {
68367       {
68368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68369       };
68370     } catch (...) {
68371       {
68372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68373       };
68374     }
68375   }
68376 }
68377
68378
68379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
68380   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68381   Dali::Vector3 *arg2 = 0 ;
68382
68383   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68384   arg2 = (Dali::Vector3 *)jarg2;
68385   if (!arg2) {
68386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68387     return ;
68388   }
68389   {
68390     try {
68391       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
68392     } catch (std::out_of_range& e) {
68393       {
68394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68395       };
68396     } catch (std::exception& e) {
68397       {
68398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68399       };
68400     } catch (...) {
68401       {
68402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68403       };
68404     }
68405   }
68406 }
68407
68408
68409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
68410   float jresult ;
68411   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68412   unsigned int arg2 ;
68413   Dali::Vector3 arg3 ;
68414   Dali::Vector3 *argp3 ;
68415   float result;
68416
68417   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68418   arg2 = (unsigned int)jarg2;
68419   argp3 = (Dali::Vector3 *)jarg3;
68420   if (!argp3) {
68421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68422     return 0;
68423   }
68424   arg3 = *argp3;
68425   {
68426     try {
68427       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
68428     } catch (std::out_of_range& e) {
68429       {
68430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68431       };
68432     } catch (std::exception& e) {
68433       {
68434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68435       };
68436     } catch (...) {
68437       {
68438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68439       };
68440     }
68441   }
68442   jresult = result;
68443   return jresult;
68444 }
68445
68446
68447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
68448   float jresult ;
68449   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68450   float arg2 ;
68451   float result;
68452
68453   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68454   arg2 = (float)jarg2;
68455   {
68456     try {
68457       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
68458     } catch (std::out_of_range& e) {
68459       {
68460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68461       };
68462     } catch (std::exception& e) {
68463       {
68464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68465       };
68466     } catch (...) {
68467       {
68468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68469       };
68470     }
68471   }
68472   jresult = result;
68473   return jresult;
68474 }
68475
68476
68477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
68478   float jresult ;
68479   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68480   unsigned int arg2 ;
68481   float result;
68482
68483   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68484   arg2 = (unsigned int)jarg2;
68485   {
68486     try {
68487       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
68488     } catch (std::out_of_range& e) {
68489       {
68490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68491       };
68492     } catch (std::exception& e) {
68493       {
68494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68495       };
68496     } catch (...) {
68497       {
68498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68499       };
68500     }
68501   }
68502   jresult = result;
68503   return jresult;
68504 }
68505
68506
68507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
68508   void * jresult ;
68509   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68510   float arg2 ;
68511   Dali::Vector3 arg3 ;
68512   Dali::Vector3 *argp3 ;
68513   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68514
68515   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68516   arg2 = (float)jarg2;
68517   argp3 = (Dali::Vector3 *)jarg3;
68518   if (!argp3) {
68519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68520     return 0;
68521   }
68522   arg3 = *argp3;
68523   {
68524     try {
68525       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
68526     } catch (std::out_of_range& e) {
68527       {
68528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68529       };
68530     } catch (std::exception& e) {
68531       {
68532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68533       };
68534     } catch (...) {
68535       {
68536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68537       };
68538     }
68539   }
68540   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68541   return jresult;
68542 }
68543
68544
68545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
68546   float jresult ;
68547   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68548   int arg2 ;
68549   float arg3 ;
68550   Dali::Vector3 *arg4 = 0 ;
68551   float result;
68552
68553   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68554   arg2 = (int)jarg2;
68555   arg3 = (float)jarg3;
68556   arg4 = (Dali::Vector3 *)jarg4;
68557   if (!arg4) {
68558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68559     return 0;
68560   }
68561   {
68562     try {
68563       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
68564     } catch (std::out_of_range& e) {
68565       {
68566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68567       };
68568     } catch (std::exception& e) {
68569       {
68570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68571       };
68572     } catch (...) {
68573       {
68574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68575       };
68576     }
68577   }
68578   jresult = result;
68579   return jresult;
68580 }
68581
68582
68583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
68584   unsigned int jresult ;
68585   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68586   Dali::Vector3 arg2 ;
68587   Dali::Vector3 *argp2 ;
68588   unsigned int result;
68589
68590   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68591   argp2 = (Dali::Vector3 *)jarg2;
68592   if (!argp2) {
68593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68594     return 0;
68595   }
68596   arg2 = *argp2;
68597   {
68598     try {
68599       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
68600     } catch (std::out_of_range& e) {
68601       {
68602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68603       };
68604     } catch (std::exception& e) {
68605       {
68606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68607       };
68608     } catch (...) {
68609       {
68610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68611       };
68612     }
68613   }
68614   jresult = result;
68615   return jresult;
68616 }
68617
68618
68619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68620   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68621   unsigned int arg2 ;
68622   Dali::Vector3 *arg3 = 0 ;
68623   Dali::Vector3 *arg4 = 0 ;
68624
68625   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68626   arg2 = (unsigned int)jarg2;
68627   arg3 = (Dali::Vector3 *)jarg3;
68628   if (!arg3) {
68629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68630     return ;
68631   }
68632   arg4 = (Dali::Vector3 *)jarg4;
68633   if (!arg4) {
68634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68635     return ;
68636   }
68637   {
68638     try {
68639       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68640     } catch (std::out_of_range& e) {
68641       {
68642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68643       };
68644     } catch (std::exception& e) {
68645       {
68646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68647       };
68648     } catch (...) {
68649       {
68650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68651       };
68652     }
68653   }
68654 }
68655
68656
68657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
68658   void * jresult ;
68659   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68660   Dali::Degree result;
68661
68662   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68663   {
68664     try {
68665       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
68666     } catch (std::out_of_range& e) {
68667       {
68668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68669       };
68670     } catch (std::exception& e) {
68671       {
68672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68673       };
68674     } catch (...) {
68675       {
68676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68677       };
68678     }
68679   }
68680   jresult = new Dali::Degree((const Dali::Degree &)result);
68681   return jresult;
68682 }
68683
68684
68685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
68686   float jresult ;
68687   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68688   float result;
68689
68690   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68691   {
68692     try {
68693       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
68694     } catch (std::out_of_range& e) {
68695       {
68696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68697       };
68698     } catch (std::exception& e) {
68699       {
68700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68701       };
68702     } catch (...) {
68703       {
68704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68705       };
68706     }
68707   }
68708   jresult = result;
68709   return jresult;
68710 }
68711
68712
68713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
68714   float jresult ;
68715   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68716   float result;
68717
68718   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68719   {
68720     try {
68721       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
68722     } catch (std::out_of_range& e) {
68723       {
68724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68725       };
68726     } catch (std::exception& e) {
68727       {
68728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68729       };
68730     } catch (...) {
68731       {
68732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68733       };
68734     }
68735   }
68736   jresult = result;
68737   return jresult;
68738 }
68739
68740
68741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
68742   float jresult ;
68743   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68744   float result;
68745
68746   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68747   {
68748     try {
68749       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
68750     } catch (std::out_of_range& e) {
68751       {
68752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68753       };
68754     } catch (std::exception& e) {
68755       {
68756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68757       };
68758     } catch (...) {
68759       {
68760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68761       };
68762     }
68763   }
68764   jresult = result;
68765   return jresult;
68766 }
68767
68768
68769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
68770   int jresult ;
68771   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68772   int arg2 ;
68773   int arg3 ;
68774   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
68775   bool arg5 ;
68776   int result;
68777
68778   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68779   arg2 = (int)jarg2;
68780   arg3 = (int)jarg3;
68781   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
68782   arg5 = jarg5 ? true : false;
68783   {
68784     try {
68785       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
68786     } catch (std::out_of_range& e) {
68787       {
68788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68789       };
68790     } catch (std::exception& e) {
68791       {
68792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68793       };
68794     } catch (...) {
68795       {
68796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68797       };
68798     }
68799   }
68800   jresult = result;
68801   return jresult;
68802 }
68803
68804
68805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
68806   float jresult ;
68807   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68808   float result;
68809
68810   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68811   {
68812     try {
68813       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
68814     } catch (std::out_of_range& e) {
68815       {
68816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68817       };
68818     } catch (std::exception& e) {
68819       {
68820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68821       };
68822     } catch (...) {
68823       {
68824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68825       };
68826     }
68827   }
68828   jresult = result;
68829   return jresult;
68830 }
68831
68832
68833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
68834   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68835   Dali::Actor *arg2 = 0 ;
68836   int arg3 ;
68837   Dali::Vector3 *arg4 = 0 ;
68838   Dali::Actor *arg5 = 0 ;
68839
68840   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68841   arg2 = (Dali::Actor *)jarg2;
68842   if (!arg2) {
68843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
68844     return ;
68845   }
68846   arg3 = (int)jarg3;
68847   arg4 = (Dali::Vector3 *)jarg4;
68848   if (!arg4) {
68849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68850     return ;
68851   }
68852   arg5 = (Dali::Actor *)jarg5;
68853   if (!arg5) {
68854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
68855     return ;
68856   }
68857   {
68858     try {
68859       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
68860     } catch (std::out_of_range& e) {
68861       {
68862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68863       };
68864     } catch (std::exception& e) {
68865       {
68866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68867       };
68868     } catch (...) {
68869       {
68870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68871       };
68872     }
68873   }
68874 }
68875
68876
68877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
68878   void * jresult ;
68879   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68880   int arg2 ;
68881   float arg3 ;
68882   Dali::Vector3 *arg4 = 0 ;
68883   Dali::Vector3 result;
68884
68885   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68886   arg2 = (int)jarg2;
68887   arg3 = (float)jarg3;
68888   arg4 = (Dali::Vector3 *)jarg4;
68889   if (!arg4) {
68890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68891     return 0;
68892   }
68893   {
68894     try {
68895       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
68896     } catch (std::out_of_range& e) {
68897       {
68898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68899       };
68900     } catch (std::exception& e) {
68901       {
68902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68903       };
68904     } catch (...) {
68905       {
68906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68907       };
68908     }
68909   }
68910   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
68911   return jresult;
68912 }
68913
68914
68915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
68916   void * jresult ;
68917   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
68918   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
68919
68920   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
68921   {
68922     try {
68923       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
68924     } catch (std::out_of_range& e) {
68925       {
68926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68927       };
68928     } catch (std::exception& e) {
68929       {
68930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68931       };
68932     } catch (...) {
68933       {
68934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68935       };
68936     }
68937   }
68938   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
68939   return jresult;
68940 }
68941
68942
68943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
68944   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
68945
68946   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
68947   {
68948     try {
68949       delete arg1;
68950     } catch (std::out_of_range& e) {
68951       {
68952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68953       };
68954     } catch (std::exception& e) {
68955       {
68956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68957       };
68958     } catch (...) {
68959       {
68960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68961       };
68962     }
68963   }
68964 }
68965
68966
68967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
68968   unsigned int jresult ;
68969   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
68970   unsigned int result;
68971
68972   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
68973   {
68974     try {
68975       result = (unsigned int)(arg1)->GetNumberOfItems();
68976     } catch (std::out_of_range& e) {
68977       {
68978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68979       };
68980     } catch (std::exception& e) {
68981       {
68982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68983       };
68984     } catch (...) {
68985       {
68986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68987       };
68988     }
68989   }
68990   jresult = result;
68991   return jresult;
68992 }
68993
68994
68995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
68996   void * jresult ;
68997   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
68998   unsigned int arg2 ;
68999   Dali::Actor result;
69000
69001   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69002   arg2 = (unsigned int)jarg2;
69003   {
69004     try {
69005       result = (arg1)->NewItem(arg2);
69006     } catch (std::out_of_range& e) {
69007       {
69008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69009       };
69010     } catch (std::exception& e) {
69011       {
69012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69013       };
69014     } catch (...) {
69015       {
69016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69017       };
69018     }
69019   }
69020   jresult = new Dali::Actor((const Dali::Actor &)result);
69021   return jresult;
69022 }
69023
69024
69025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
69026   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69027   unsigned int arg2 ;
69028   Dali::Actor arg3 ;
69029   Dali::Actor *argp3 ;
69030
69031   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69032   arg2 = (unsigned int)jarg2;
69033   argp3 = (Dali::Actor *)jarg3;
69034   if (!argp3) {
69035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69036     return ;
69037   }
69038   arg3 = *argp3;
69039   {
69040     try {
69041       (arg1)->ItemReleased(arg2,arg3);
69042     } catch (std::out_of_range& e) {
69043       {
69044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69045       };
69046     } catch (std::exception& e) {
69047       {
69048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69049       };
69050     } catch (...) {
69051       {
69052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69053       };
69054     }
69055   }
69056 }
69057
69058
69059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
69060   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69061   unsigned int arg2 ;
69062   Dali::Actor arg3 ;
69063   Dali::Actor *argp3 ;
69064
69065   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69066   arg2 = (unsigned int)jarg2;
69067   argp3 = (Dali::Actor *)jarg3;
69068   if (!argp3) {
69069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69070     return ;
69071   }
69072   arg3 = *argp3;
69073   {
69074     try {
69075       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
69076     } catch (std::out_of_range& e) {
69077       {
69078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69079       };
69080     } catch (std::exception& e) {
69081       {
69082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69083       };
69084     } catch (...) {
69085       {
69086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69087       };
69088     }
69089   }
69090 }
69091
69092
69093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
69094   void * jresult ;
69095   Dali::Toolkit::ItemFactory *result = 0 ;
69096
69097   {
69098     try {
69099       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
69100     } catch (std::out_of_range& e) {
69101       {
69102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69103       };
69104     } catch (std::exception& e) {
69105       {
69106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69107       };
69108     } catch (...) {
69109       {
69110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69111       };
69112     }
69113   }
69114   jresult = (void *)result;
69115   return jresult;
69116 }
69117
69118
69119 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) {
69120   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
69121   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
69122   if (director) {
69123     director->swig_connect_director(callback0, callback1, callback2);
69124   }
69125 }
69126
69127
69128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
69129   int jresult ;
69130   int result;
69131
69132   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
69133   jresult = (int)result;
69134   return jresult;
69135 }
69136
69137
69138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
69139   int jresult ;
69140   int result;
69141
69142   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
69143   jresult = (int)result;
69144   return jresult;
69145 }
69146
69147
69148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
69149   int jresult ;
69150   int result;
69151
69152   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
69153   jresult = (int)result;
69154   return jresult;
69155 }
69156
69157
69158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
69159   int jresult ;
69160   int result;
69161
69162   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
69163   jresult = (int)result;
69164   return jresult;
69165 }
69166
69167
69168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
69169   int jresult ;
69170   int result;
69171
69172   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
69173   jresult = (int)result;
69174   return jresult;
69175 }
69176
69177
69178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
69179   int jresult ;
69180   int result;
69181
69182   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
69183   jresult = (int)result;
69184   return jresult;
69185 }
69186
69187
69188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
69189   int jresult ;
69190   int result;
69191
69192   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
69193   jresult = (int)result;
69194   return jresult;
69195 }
69196
69197
69198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
69199   int jresult ;
69200   int result;
69201
69202   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
69203   jresult = (int)result;
69204   return jresult;
69205 }
69206
69207
69208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
69209   int jresult ;
69210   int result;
69211
69212   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
69213   jresult = (int)result;
69214   return jresult;
69215 }
69216
69217
69218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
69219   int jresult ;
69220   int result;
69221
69222   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
69223   jresult = (int)result;
69224   return jresult;
69225 }
69226
69227
69228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
69229   int jresult ;
69230   int result;
69231
69232   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
69233   jresult = (int)result;
69234   return jresult;
69235 }
69236
69237
69238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
69239   void * jresult ;
69240   Dali::Toolkit::ItemView::Property *result = 0 ;
69241
69242   {
69243     try {
69244       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
69245     } catch (std::out_of_range& e) {
69246       {
69247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69248       };
69249     } catch (std::exception& e) {
69250       {
69251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69252       };
69253     } catch (...) {
69254       {
69255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69256       };
69257     }
69258   }
69259   jresult = (void *)result;
69260   return jresult;
69261 }
69262
69263
69264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
69265   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
69266
69267   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
69268   {
69269     try {
69270       delete arg1;
69271     } catch (std::out_of_range& e) {
69272       {
69273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69274       };
69275     } catch (std::exception& e) {
69276       {
69277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69278       };
69279     } catch (...) {
69280       {
69281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69282       };
69283     }
69284   }
69285 }
69286
69287
69288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
69289   void * jresult ;
69290   Dali::Toolkit::ItemView *result = 0 ;
69291
69292   {
69293     try {
69294       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
69295     } catch (std::out_of_range& e) {
69296       {
69297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69298       };
69299     } catch (std::exception& e) {
69300       {
69301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69302       };
69303     } catch (...) {
69304       {
69305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69306       };
69307     }
69308   }
69309   jresult = (void *)result;
69310   return jresult;
69311 }
69312
69313
69314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
69315   void * jresult ;
69316   Dali::Toolkit::ItemView *arg1 = 0 ;
69317   Dali::Toolkit::ItemView *result = 0 ;
69318
69319   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69320   if (!arg1) {
69321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69322     return 0;
69323   }
69324   {
69325     try {
69326       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
69327     } catch (std::out_of_range& e) {
69328       {
69329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69330       };
69331     } catch (std::exception& e) {
69332       {
69333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69334       };
69335     } catch (...) {
69336       {
69337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69338       };
69339     }
69340   }
69341   jresult = (void *)result;
69342   return jresult;
69343 }
69344
69345
69346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
69347   void * jresult ;
69348   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69349   Dali::Toolkit::ItemView *arg2 = 0 ;
69350   Dali::Toolkit::ItemView *result = 0 ;
69351
69352   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69353   arg2 = (Dali::Toolkit::ItemView *)jarg2;
69354   if (!arg2) {
69355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69356     return 0;
69357   }
69358   {
69359     try {
69360       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
69361     } catch (std::out_of_range& e) {
69362       {
69363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69364       };
69365     } catch (std::exception& e) {
69366       {
69367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69368       };
69369     } catch (...) {
69370       {
69371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69372       };
69373     }
69374   }
69375   jresult = (void *)result;
69376   return jresult;
69377 }
69378
69379
69380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
69381   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69382
69383   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69384   {
69385     try {
69386       delete arg1;
69387     } catch (std::out_of_range& e) {
69388       {
69389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69390       };
69391     } catch (std::exception& e) {
69392       {
69393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69394       };
69395     } catch (...) {
69396       {
69397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69398       };
69399     }
69400   }
69401 }
69402
69403
69404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
69405   void * jresult ;
69406   Dali::Toolkit::ItemFactory *arg1 = 0 ;
69407   Dali::Toolkit::ItemView result;
69408
69409   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69410   if (!arg1) {
69411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
69412     return 0;
69413   }
69414   {
69415     try {
69416       result = Dali::Toolkit::ItemView::New(*arg1);
69417     } catch (std::out_of_range& e) {
69418       {
69419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69420       };
69421     } catch (std::exception& e) {
69422       {
69423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69424       };
69425     } catch (...) {
69426       {
69427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69428       };
69429     }
69430   }
69431   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69432   return jresult;
69433 }
69434
69435
69436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
69437   void * jresult ;
69438   Dali::BaseHandle arg1 ;
69439   Dali::BaseHandle *argp1 ;
69440   Dali::Toolkit::ItemView result;
69441
69442   argp1 = (Dali::BaseHandle *)jarg1;
69443   if (!argp1) {
69444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69445     return 0;
69446   }
69447   arg1 = *argp1;
69448   {
69449     try {
69450       result = Dali::Toolkit::ItemView::DownCast(arg1);
69451     } catch (std::out_of_range& e) {
69452       {
69453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69454       };
69455     } catch (std::exception& e) {
69456       {
69457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69458       };
69459     } catch (...) {
69460       {
69461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69462       };
69463     }
69464   }
69465   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69466   return jresult;
69467 }
69468
69469
69470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
69471   unsigned int jresult ;
69472   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69473   unsigned int result;
69474
69475   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69476   {
69477     try {
69478       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
69479     } catch (std::out_of_range& e) {
69480       {
69481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69482       };
69483     } catch (std::exception& e) {
69484       {
69485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69486       };
69487     } catch (...) {
69488       {
69489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69490       };
69491     }
69492   }
69493   jresult = result;
69494   return jresult;
69495 }
69496
69497
69498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
69499   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69500   Dali::Toolkit::ItemLayout *arg2 = 0 ;
69501
69502   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69503   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
69504   if (!arg2) {
69505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
69506     return ;
69507   }
69508   {
69509     try {
69510       (arg1)->AddLayout(*arg2);
69511     } catch (std::out_of_range& e) {
69512       {
69513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69514       };
69515     } catch (std::exception& e) {
69516       {
69517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69518       };
69519     } catch (...) {
69520       {
69521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69522       };
69523     }
69524   }
69525 }
69526
69527
69528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
69529   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69530   unsigned int arg2 ;
69531
69532   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69533   arg2 = (unsigned int)jarg2;
69534   {
69535     try {
69536       (arg1)->RemoveLayout(arg2);
69537     } catch (std::out_of_range& e) {
69538       {
69539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69540       };
69541     } catch (std::exception& e) {
69542       {
69543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69544       };
69545     } catch (...) {
69546       {
69547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69548       };
69549     }
69550   }
69551 }
69552
69553
69554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
69555   void * jresult ;
69556   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69557   unsigned int arg2 ;
69558   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69559
69560   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69561   arg2 = (unsigned int)jarg2;
69562   {
69563     try {
69564       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
69565     } catch (std::out_of_range& e) {
69566       {
69567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69568       };
69569     } catch (std::exception& e) {
69570       {
69571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69572       };
69573     } catch (...) {
69574       {
69575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69576       };
69577     }
69578   }
69579   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69580   return jresult;
69581 }
69582
69583
69584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
69585   void * jresult ;
69586   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69587   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69588
69589   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69590   {
69591     try {
69592       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
69593     } catch (std::out_of_range& e) {
69594       {
69595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69596       };
69597     } catch (std::exception& e) {
69598       {
69599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69600       };
69601     } catch (...) {
69602       {
69603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69604       };
69605     }
69606   }
69607   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69608   return jresult;
69609 }
69610
69611
69612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
69613   float jresult ;
69614   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69615   Dali::Toolkit::ItemId arg2 ;
69616   float result;
69617
69618   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69619   arg2 = (Dali::Toolkit::ItemId)jarg2;
69620   {
69621     try {
69622       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
69623     } catch (std::out_of_range& e) {
69624       {
69625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69626       };
69627     } catch (std::exception& e) {
69628       {
69629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69630       };
69631     } catch (...) {
69632       {
69633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69634       };
69635     }
69636   }
69637   jresult = result;
69638   return jresult;
69639 }
69640
69641
69642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
69643   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69644   unsigned int arg2 ;
69645   Dali::Vector3 arg3 ;
69646   float arg4 ;
69647   Dali::Vector3 *argp3 ;
69648
69649   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69650   arg2 = (unsigned int)jarg2;
69651   argp3 = (Dali::Vector3 *)jarg3;
69652   if (!argp3) {
69653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69654     return ;
69655   }
69656   arg3 = *argp3;
69657   arg4 = (float)jarg4;
69658   {
69659     try {
69660       (arg1)->ActivateLayout(arg2,arg3,arg4);
69661     } catch (std::out_of_range& e) {
69662       {
69663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69664       };
69665     } catch (std::exception& e) {
69666       {
69667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69668       };
69669     } catch (...) {
69670       {
69671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69672       };
69673     }
69674   }
69675 }
69676
69677
69678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
69679   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69680
69681   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69682   {
69683     try {
69684       (arg1)->DeactivateCurrentLayout();
69685     } catch (std::out_of_range& e) {
69686       {
69687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69688       };
69689     } catch (std::exception& e) {
69690       {
69691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69692       };
69693     } catch (...) {
69694       {
69695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69696       };
69697     }
69698   }
69699 }
69700
69701
69702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
69703   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69704   float arg2 ;
69705
69706   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69707   arg2 = (float)jarg2;
69708   {
69709     try {
69710       (arg1)->SetMinimumSwipeSpeed(arg2);
69711     } catch (std::out_of_range& e) {
69712       {
69713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69714       };
69715     } catch (std::exception& e) {
69716       {
69717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69718       };
69719     } catch (...) {
69720       {
69721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69722       };
69723     }
69724   }
69725 }
69726
69727
69728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
69729   float jresult ;
69730   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69731   float result;
69732
69733   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69734   {
69735     try {
69736       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
69737     } catch (std::out_of_range& e) {
69738       {
69739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69740       };
69741     } catch (std::exception& e) {
69742       {
69743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69744       };
69745     } catch (...) {
69746       {
69747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69748       };
69749     }
69750   }
69751   jresult = result;
69752   return jresult;
69753 }
69754
69755
69756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
69757   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69758   float arg2 ;
69759
69760   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69761   arg2 = (float)jarg2;
69762   {
69763     try {
69764       (arg1)->SetMinimumSwipeDistance(arg2);
69765     } catch (std::out_of_range& e) {
69766       {
69767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69768       };
69769     } catch (std::exception& e) {
69770       {
69771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69772       };
69773     } catch (...) {
69774       {
69775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69776       };
69777     }
69778   }
69779 }
69780
69781
69782 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
69783   float jresult ;
69784   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69785   float result;
69786
69787   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69788   {
69789     try {
69790       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
69791     } catch (std::out_of_range& e) {
69792       {
69793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69794       };
69795     } catch (std::exception& e) {
69796       {
69797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69798       };
69799     } catch (...) {
69800       {
69801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69802       };
69803     }
69804   }
69805   jresult = result;
69806   return jresult;
69807 }
69808
69809
69810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
69811   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69812   float arg2 ;
69813
69814   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69815   arg2 = (float)jarg2;
69816   {
69817     try {
69818       (arg1)->SetWheelScrollDistanceStep(arg2);
69819     } catch (std::out_of_range& e) {
69820       {
69821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69822       };
69823     } catch (std::exception& e) {
69824       {
69825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69826       };
69827     } catch (...) {
69828       {
69829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69830       };
69831     }
69832   }
69833 }
69834
69835
69836 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
69837   float jresult ;
69838   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69839   float result;
69840
69841   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69842   {
69843     try {
69844       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
69845     } catch (std::out_of_range& e) {
69846       {
69847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69848       };
69849     } catch (std::exception& e) {
69850       {
69851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69852       };
69853     } catch (...) {
69854       {
69855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69856       };
69857     }
69858   }
69859   jresult = result;
69860   return jresult;
69861 }
69862
69863
69864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
69865   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69866   bool arg2 ;
69867
69868   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69869   arg2 = jarg2 ? true : false;
69870   {
69871     try {
69872       (arg1)->SetAnchoring(arg2);
69873     } catch (std::out_of_range& e) {
69874       {
69875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69876       };
69877     } catch (std::exception& e) {
69878       {
69879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69880       };
69881     } catch (...) {
69882       {
69883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69884       };
69885     }
69886   }
69887 }
69888
69889
69890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
69891   unsigned int jresult ;
69892   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69893   bool result;
69894
69895   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69896   {
69897     try {
69898       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
69899     } catch (std::out_of_range& e) {
69900       {
69901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69902       };
69903     } catch (std::exception& e) {
69904       {
69905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69906       };
69907     } catch (...) {
69908       {
69909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69910       };
69911     }
69912   }
69913   jresult = result;
69914   return jresult;
69915 }
69916
69917
69918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
69919   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69920   float arg2 ;
69921
69922   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69923   arg2 = (float)jarg2;
69924   {
69925     try {
69926       (arg1)->SetAnchoringDuration(arg2);
69927     } catch (std::out_of_range& e) {
69928       {
69929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69930       };
69931     } catch (std::exception& e) {
69932       {
69933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69934       };
69935     } catch (...) {
69936       {
69937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69938       };
69939     }
69940   }
69941 }
69942
69943
69944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
69945   float jresult ;
69946   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69947   float result;
69948
69949   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69950   {
69951     try {
69952       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
69953     } catch (std::out_of_range& e) {
69954       {
69955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69956       };
69957     } catch (std::exception& e) {
69958       {
69959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69960       };
69961     } catch (...) {
69962       {
69963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69964       };
69965     }
69966   }
69967   jresult = result;
69968   return jresult;
69969 }
69970
69971
69972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
69973   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69974   Dali::Toolkit::ItemId arg2 ;
69975   float arg3 ;
69976
69977   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69978   arg2 = (Dali::Toolkit::ItemId)jarg2;
69979   arg3 = (float)jarg3;
69980   {
69981     try {
69982       (arg1)->ScrollToItem(arg2,arg3);
69983     } catch (std::out_of_range& e) {
69984       {
69985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69986       };
69987     } catch (std::exception& e) {
69988       {
69989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69990       };
69991     } catch (...) {
69992       {
69993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69994       };
69995     }
69996   }
69997 }
69998
69999
70000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
70001   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70002   float arg2 ;
70003
70004   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70005   arg2 = (float)jarg2;
70006   {
70007     try {
70008       (arg1)->SetRefreshInterval(arg2);
70009     } catch (std::out_of_range& e) {
70010       {
70011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70012       };
70013     } catch (std::exception& e) {
70014       {
70015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70016       };
70017     } catch (...) {
70018       {
70019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70020       };
70021     }
70022   }
70023 }
70024
70025
70026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
70027   float jresult ;
70028   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70029   float result;
70030
70031   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70032   {
70033     try {
70034       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
70035     } catch (std::out_of_range& e) {
70036       {
70037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70038       };
70039     } catch (std::exception& e) {
70040       {
70041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70042       };
70043     } catch (...) {
70044       {
70045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70046       };
70047     }
70048   }
70049   jresult = result;
70050   return jresult;
70051 }
70052
70053
70054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
70055   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70056
70057   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70058   {
70059     try {
70060       (arg1)->Refresh();
70061     } catch (std::out_of_range& e) {
70062       {
70063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70064       };
70065     } catch (std::exception& e) {
70066       {
70067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70068       };
70069     } catch (...) {
70070       {
70071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70072       };
70073     }
70074   }
70075 }
70076
70077
70078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
70079   void * jresult ;
70080   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70081   Dali::Toolkit::ItemId arg2 ;
70082   Dali::Actor result;
70083
70084   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70085   arg2 = (Dali::Toolkit::ItemId)jarg2;
70086   {
70087     try {
70088       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
70089     } catch (std::out_of_range& e) {
70090       {
70091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70092       };
70093     } catch (std::exception& e) {
70094       {
70095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70096       };
70097     } catch (...) {
70098       {
70099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70100       };
70101     }
70102   }
70103   jresult = new Dali::Actor((const Dali::Actor &)result);
70104   return jresult;
70105 }
70106
70107
70108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
70109   unsigned int jresult ;
70110   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70111   Dali::Actor arg2 ;
70112   Dali::Actor *argp2 ;
70113   Dali::Toolkit::ItemId result;
70114
70115   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70116   argp2 = (Dali::Actor *)jarg2;
70117   if (!argp2) {
70118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70119     return 0;
70120   }
70121   arg2 = *argp2;
70122   {
70123     try {
70124       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
70125     } catch (std::out_of_range& e) {
70126       {
70127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70128       };
70129     } catch (std::exception& e) {
70130       {
70131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70132       };
70133     } catch (...) {
70134       {
70135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70136       };
70137     }
70138   }
70139   jresult = result;
70140   return jresult;
70141 }
70142
70143
70144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
70145   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70146   Dali::Toolkit::Item arg2 ;
70147   float arg3 ;
70148   Dali::Toolkit::Item *argp2 ;
70149
70150   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70151   argp2 = (Dali::Toolkit::Item *)jarg2;
70152   if (!argp2) {
70153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70154     return ;
70155   }
70156   arg2 = *argp2;
70157   arg3 = (float)jarg3;
70158   {
70159     try {
70160       (arg1)->InsertItem(arg2,arg3);
70161     } catch (std::out_of_range& e) {
70162       {
70163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70164       };
70165     } catch (std::exception& e) {
70166       {
70167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70168       };
70169     } catch (...) {
70170       {
70171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70172       };
70173     }
70174   }
70175 }
70176
70177
70178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
70179   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70180   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70181   float arg3 ;
70182
70183   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70184   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70185   if (!arg2) {
70186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70187     return ;
70188   }
70189   arg3 = (float)jarg3;
70190   {
70191     try {
70192       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70193     } catch (std::out_of_range& e) {
70194       {
70195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70196       };
70197     } catch (std::exception& e) {
70198       {
70199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70200       };
70201     } catch (...) {
70202       {
70203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70204       };
70205     }
70206   }
70207 }
70208
70209
70210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
70211   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70212   Dali::Toolkit::ItemId arg2 ;
70213   float arg3 ;
70214
70215   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70216   arg2 = (Dali::Toolkit::ItemId)jarg2;
70217   arg3 = (float)jarg3;
70218   {
70219     try {
70220       (arg1)->RemoveItem(arg2,arg3);
70221     } catch (std::out_of_range& e) {
70222       {
70223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70224       };
70225     } catch (std::exception& e) {
70226       {
70227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70228       };
70229     } catch (...) {
70230       {
70231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70232       };
70233     }
70234   }
70235 }
70236
70237
70238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
70239   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70240   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
70241   float arg3 ;
70242
70243   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70244   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
70245   if (!arg2) {
70246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
70247     return ;
70248   }
70249   arg3 = (float)jarg3;
70250   {
70251     try {
70252       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
70253     } catch (std::out_of_range& e) {
70254       {
70255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70256       };
70257     } catch (std::exception& e) {
70258       {
70259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70260       };
70261     } catch (...) {
70262       {
70263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70264       };
70265     }
70266   }
70267 }
70268
70269
70270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
70271   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70272   Dali::Toolkit::Item arg2 ;
70273   float arg3 ;
70274   Dali::Toolkit::Item *argp2 ;
70275
70276   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70277   argp2 = (Dali::Toolkit::Item *)jarg2;
70278   if (!argp2) {
70279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70280     return ;
70281   }
70282   arg2 = *argp2;
70283   arg3 = (float)jarg3;
70284   {
70285     try {
70286       (arg1)->ReplaceItem(arg2,arg3);
70287     } catch (std::out_of_range& e) {
70288       {
70289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70290       };
70291     } catch (std::exception& e) {
70292       {
70293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70294       };
70295     } catch (...) {
70296       {
70297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70298       };
70299     }
70300   }
70301 }
70302
70303
70304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
70305   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70306   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70307   float arg3 ;
70308
70309   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70310   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70311   if (!arg2) {
70312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70313     return ;
70314   }
70315   arg3 = (float)jarg3;
70316   {
70317     try {
70318       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70319     } catch (std::out_of_range& e) {
70320       {
70321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70322       };
70323     } catch (std::exception& e) {
70324       {
70325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70326       };
70327     } catch (...) {
70328       {
70329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70330       };
70331     }
70332   }
70333 }
70334
70335
70336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
70337   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70338   Dali::Vector3 *arg2 = 0 ;
70339
70340   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70341   arg2 = (Dali::Vector3 *)jarg2;
70342   if (!arg2) {
70343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70344     return ;
70345   }
70346   {
70347     try {
70348       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
70349     } catch (std::out_of_range& e) {
70350       {
70351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70352       };
70353     } catch (std::exception& e) {
70354       {
70355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70356       };
70357     } catch (...) {
70358       {
70359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70360       };
70361     }
70362   }
70363 }
70364
70365
70366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
70367   void * jresult ;
70368   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70369   Dali::Vector3 result;
70370
70371   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70372   {
70373     try {
70374       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
70375     } catch (std::out_of_range& e) {
70376       {
70377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70378       };
70379     } catch (std::exception& e) {
70380       {
70381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70382       };
70383     } catch (...) {
70384       {
70385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70386       };
70387     }
70388   }
70389   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70390   return jresult;
70391 }
70392
70393
70394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
70395   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70396   Dali::Vector3 *arg2 = 0 ;
70397
70398   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70399   arg2 = (Dali::Vector3 *)jarg2;
70400   if (!arg2) {
70401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70402     return ;
70403   }
70404   {
70405     try {
70406       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
70407     } catch (std::out_of_range& e) {
70408       {
70409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70410       };
70411     } catch (std::exception& e) {
70412       {
70413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70414       };
70415     } catch (...) {
70416       {
70417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70418       };
70419     }
70420   }
70421 }
70422
70423
70424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
70425   void * jresult ;
70426   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70427   Dali::Vector3 result;
70428
70429   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70430   {
70431     try {
70432       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
70433     } catch (std::out_of_range& e) {
70434       {
70435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70436       };
70437     } catch (std::exception& e) {
70438       {
70439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70440       };
70441     } catch (...) {
70442       {
70443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70444       };
70445     }
70446   }
70447   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70448   return jresult;
70449 }
70450
70451
70452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
70453   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70454   Dali::Toolkit::ItemRange *arg2 = 0 ;
70455
70456   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70457   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
70458   if (!arg2) {
70459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
70460     return ;
70461   }
70462   {
70463     try {
70464       (arg1)->GetItemsRange(*arg2);
70465     } catch (std::out_of_range& e) {
70466       {
70467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70468       };
70469     } catch (std::exception& e) {
70470       {
70471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70472       };
70473     } catch (...) {
70474       {
70475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70476       };
70477     }
70478   }
70479 }
70480
70481
70482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
70483   void * jresult ;
70484   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70485   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
70486
70487   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70488   {
70489     try {
70490       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
70491     } catch (std::out_of_range& e) {
70492       {
70493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70494       };
70495     } catch (std::exception& e) {
70496       {
70497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70498       };
70499     } catch (...) {
70500       {
70501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70502       };
70503     }
70504   }
70505   jresult = (void *)result;
70506   return jresult;
70507 }
70508
70509
70510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
70511   Dali::Vector3 *arg1 = 0 ;
70512   PropertyInputContainer *arg2 = 0 ;
70513
70514   arg1 = (Dali::Vector3 *)jarg1;
70515   if (!arg1) {
70516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70517     return ;
70518   }
70519   arg2 = (PropertyInputContainer *)jarg2;
70520   if (!arg2) {
70521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
70522     return ;
70523   }
70524   {
70525     try {
70526       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
70527     } catch (std::out_of_range& e) {
70528       {
70529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70530       };
70531     } catch (std::exception& e) {
70532       {
70533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70534       };
70535     } catch (...) {
70536       {
70537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70538       };
70539     }
70540   }
70541 }
70542
70543
70544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
70545   Dali::Vector3 *arg1 = 0 ;
70546   PropertyInputContainer *arg2 = 0 ;
70547
70548   arg1 = (Dali::Vector3 *)jarg1;
70549   if (!arg1) {
70550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70551     return ;
70552   }
70553   arg2 = (PropertyInputContainer *)jarg2;
70554   if (!arg2) {
70555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
70556     return ;
70557   }
70558   {
70559     try {
70560       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
70561     } catch (std::out_of_range& e) {
70562       {
70563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70564       };
70565     } catch (std::exception& e) {
70566       {
70567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70568       };
70569     } catch (...) {
70570       {
70571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70572       };
70573     }
70574   }
70575 }
70576
70577
70578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
70579   void * jresult ;
70580   Dali::Toolkit::ScrollViewEffect *result = 0 ;
70581
70582   {
70583     try {
70584       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
70585     } catch (std::out_of_range& e) {
70586       {
70587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70588       };
70589     } catch (std::exception& e) {
70590       {
70591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70592       };
70593     } catch (...) {
70594       {
70595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70596       };
70597     }
70598   }
70599   jresult = (void *)result;
70600   return jresult;
70601 }
70602
70603
70604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
70605   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
70606
70607   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
70608   {
70609     try {
70610       delete arg1;
70611     } catch (std::out_of_range& e) {
70612       {
70613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70614       };
70615     } catch (std::exception& e) {
70616       {
70617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70618       };
70619     } catch (...) {
70620       {
70621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70622       };
70623     }
70624   }
70625 }
70626
70627
70628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
70629   void * jresult ;
70630   Dali::Path arg1 ;
70631   Dali::Vector3 *arg2 = 0 ;
70632   Dali::Property::Index arg3 ;
70633   Dali::Vector3 *arg4 = 0 ;
70634   unsigned int arg5 ;
70635   Dali::Path *argp1 ;
70636   Dali::Toolkit::ScrollViewPagePathEffect result;
70637
70638   argp1 = (Dali::Path *)jarg1;
70639   if (!argp1) {
70640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
70641     return 0;
70642   }
70643   arg1 = *argp1;
70644   arg2 = (Dali::Vector3 *)jarg2;
70645   if (!arg2) {
70646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70647     return 0;
70648   }
70649   arg3 = (Dali::Property::Index)jarg3;
70650   arg4 = (Dali::Vector3 *)jarg4;
70651   if (!arg4) {
70652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70653     return 0;
70654   }
70655   arg5 = (unsigned int)jarg5;
70656   {
70657     try {
70658       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
70659     } catch (std::out_of_range& e) {
70660       {
70661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70662       };
70663     } catch (std::exception& e) {
70664       {
70665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70666       };
70667     } catch (...) {
70668       {
70669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70670       };
70671     }
70672   }
70673   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
70674   return jresult;
70675 }
70676
70677
70678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
70679   void * jresult ;
70680   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
70681
70682   {
70683     try {
70684       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
70685     } catch (std::out_of_range& e) {
70686       {
70687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70688       };
70689     } catch (std::exception& e) {
70690       {
70691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70692       };
70693     } catch (...) {
70694       {
70695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70696       };
70697     }
70698   }
70699   jresult = (void *)result;
70700   return jresult;
70701 }
70702
70703
70704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
70705   void * jresult ;
70706   Dali::BaseHandle arg1 ;
70707   Dali::BaseHandle *argp1 ;
70708   Dali::Toolkit::ScrollViewPagePathEffect result;
70709
70710   argp1 = (Dali::BaseHandle *)jarg1;
70711   if (!argp1) {
70712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70713     return 0;
70714   }
70715   arg1 = *argp1;
70716   {
70717     try {
70718       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
70719     } catch (std::out_of_range& e) {
70720       {
70721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70722       };
70723     } catch (std::exception& e) {
70724       {
70725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70726       };
70727     } catch (...) {
70728       {
70729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70730       };
70731     }
70732   }
70733   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
70734   return jresult;
70735 }
70736
70737
70738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
70739   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
70740   Dali::Actor arg2 ;
70741   unsigned int arg3 ;
70742   Dali::Actor *argp2 ;
70743
70744   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
70745   argp2 = (Dali::Actor *)jarg2;
70746   if (!argp2) {
70747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70748     return ;
70749   }
70750   arg2 = *argp2;
70751   arg3 = (unsigned int)jarg3;
70752   {
70753     try {
70754       (arg1)->ApplyToPage(arg2,arg3);
70755     } catch (std::out_of_range& e) {
70756       {
70757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70758       };
70759     } catch (std::exception& e) {
70760       {
70761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70762       };
70763     } catch (...) {
70764       {
70765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70766       };
70767     }
70768   }
70769 }
70770
70771
70772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
70773   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
70774
70775   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
70776   {
70777     try {
70778       delete arg1;
70779     } catch (std::out_of_range& e) {
70780       {
70781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70782       };
70783     } catch (std::exception& e) {
70784       {
70785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70786       };
70787     } catch (...) {
70788       {
70789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70790       };
70791     }
70792   }
70793 }
70794
70795
70796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
70797   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
70798   Dali::Toolkit::ClampState arg2 ;
70799
70800   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
70801   arg2 = (Dali::Toolkit::ClampState)jarg2;
70802   if (arg1) (arg1)->x = arg2;
70803 }
70804
70805
70806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
70807   int jresult ;
70808   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
70809   Dali::Toolkit::ClampState result;
70810
70811   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
70812   result = (Dali::Toolkit::ClampState) ((arg1)->x);
70813   jresult = (int)result;
70814   return jresult;
70815 }
70816
70817
70818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
70819   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
70820   Dali::Toolkit::ClampState arg2 ;
70821
70822   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
70823   arg2 = (Dali::Toolkit::ClampState)jarg2;
70824   if (arg1) (arg1)->y = arg2;
70825 }
70826
70827
70828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
70829   int jresult ;
70830   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
70831   Dali::Toolkit::ClampState result;
70832
70833   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
70834   result = (Dali::Toolkit::ClampState) ((arg1)->y);
70835   jresult = (int)result;
70836   return jresult;
70837 }
70838
70839
70840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
70841   void * jresult ;
70842   Dali::Toolkit::ClampState2D *result = 0 ;
70843
70844   {
70845     try {
70846       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
70847     } catch (std::out_of_range& e) {
70848       {
70849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70850       };
70851     } catch (std::exception& e) {
70852       {
70853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70854       };
70855     } catch (...) {
70856       {
70857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70858       };
70859     }
70860   }
70861   jresult = (void *)result;
70862   return jresult;
70863 }
70864
70865
70866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
70867   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
70868
70869   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
70870   {
70871     try {
70872       delete arg1;
70873     } catch (std::out_of_range& e) {
70874       {
70875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70876       };
70877     } catch (std::exception& e) {
70878       {
70879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70880       };
70881     } catch (...) {
70882       {
70883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70884       };
70885     }
70886   }
70887 }
70888
70889
70890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
70891   void * jresult ;
70892   float arg1 ;
70893   float arg2 ;
70894   bool arg3 ;
70895   Dali::Toolkit::RulerDomain *result = 0 ;
70896
70897   arg1 = (float)jarg1;
70898   arg2 = (float)jarg2;
70899   arg3 = jarg3 ? true : false;
70900   {
70901     try {
70902       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
70903     } catch (std::out_of_range& e) {
70904       {
70905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70906       };
70907     } catch (std::exception& e) {
70908       {
70909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70910       };
70911     } catch (...) {
70912       {
70913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70914       };
70915     }
70916   }
70917   jresult = (void *)result;
70918   return jresult;
70919 }
70920
70921
70922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
70923   void * jresult ;
70924   float arg1 ;
70925   float arg2 ;
70926   Dali::Toolkit::RulerDomain *result = 0 ;
70927
70928   arg1 = (float)jarg1;
70929   arg2 = (float)jarg2;
70930   {
70931     try {
70932       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
70933     } catch (std::out_of_range& e) {
70934       {
70935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70936       };
70937     } catch (std::exception& e) {
70938       {
70939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70940       };
70941     } catch (...) {
70942       {
70943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70944       };
70945     }
70946   }
70947   jresult = (void *)result;
70948   return jresult;
70949 }
70950
70951
70952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
70953   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
70954   float arg2 ;
70955
70956   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
70957   arg2 = (float)jarg2;
70958   if (arg1) (arg1)->min = arg2;
70959 }
70960
70961
70962 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
70963   float jresult ;
70964   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
70965   float result;
70966
70967   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
70968   result = (float) ((arg1)->min);
70969   jresult = result;
70970   return jresult;
70971 }
70972
70973
70974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
70975   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
70976   float arg2 ;
70977
70978   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
70979   arg2 = (float)jarg2;
70980   if (arg1) (arg1)->max = arg2;
70981 }
70982
70983
70984 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
70985   float jresult ;
70986   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
70987   float result;
70988
70989   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
70990   result = (float) ((arg1)->max);
70991   jresult = result;
70992   return jresult;
70993 }
70994
70995
70996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
70997   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
70998   bool arg2 ;
70999
71000   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71001   arg2 = jarg2 ? true : false;
71002   if (arg1) (arg1)->enabled = arg2;
71003 }
71004
71005
71006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
71007   unsigned int jresult ;
71008   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71009   bool result;
71010
71011   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71012   result = (bool) ((arg1)->enabled);
71013   jresult = result;
71014   return jresult;
71015 }
71016
71017
71018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71019   float jresult ;
71020   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71021   float arg2 ;
71022   float arg3 ;
71023   float arg4 ;
71024   float result;
71025
71026   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71027   arg2 = (float)jarg2;
71028   arg3 = (float)jarg3;
71029   arg4 = (float)jarg4;
71030   {
71031     try {
71032       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
71033     } catch (std::out_of_range& e) {
71034       {
71035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71036       };
71037     } catch (std::exception& e) {
71038       {
71039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71040       };
71041     } catch (...) {
71042       {
71043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71044       };
71045     }
71046   }
71047   jresult = result;
71048   return jresult;
71049 }
71050
71051
71052 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71053   float jresult ;
71054   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71055   float arg2 ;
71056   float arg3 ;
71057   float result;
71058
71059   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71060   arg2 = (float)jarg2;
71061   arg3 = (float)jarg3;
71062   {
71063     try {
71064       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
71065     } catch (std::out_of_range& e) {
71066       {
71067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71068       };
71069     } catch (std::exception& e) {
71070       {
71071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71072       };
71073     } catch (...) {
71074       {
71075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71076       };
71077     }
71078   }
71079   jresult = result;
71080   return jresult;
71081 }
71082
71083
71084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
71085   float jresult ;
71086   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71087   float arg2 ;
71088   float result;
71089
71090   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71091   arg2 = (float)jarg2;
71092   {
71093     try {
71094       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
71095     } catch (std::out_of_range& e) {
71096       {
71097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71098       };
71099     } catch (std::exception& e) {
71100       {
71101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71102       };
71103     } catch (...) {
71104       {
71105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71106       };
71107     }
71108   }
71109   jresult = result;
71110   return jresult;
71111 }
71112
71113
71114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71115   float jresult ;
71116   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71117   float arg2 ;
71118   float arg3 ;
71119   float arg4 ;
71120   Dali::Toolkit::ClampState *arg5 = 0 ;
71121   float result;
71122
71123   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71124   arg2 = (float)jarg2;
71125   arg3 = (float)jarg3;
71126   arg4 = (float)jarg4;
71127   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71128   if (!arg5) {
71129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71130     return 0;
71131   }
71132   {
71133     try {
71134       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71135     } catch (std::out_of_range& e) {
71136       {
71137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71138       };
71139     } catch (std::exception& e) {
71140       {
71141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71142       };
71143     } catch (...) {
71144       {
71145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71146       };
71147     }
71148   }
71149   jresult = result;
71150   return jresult;
71151 }
71152
71153
71154 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
71155   float jresult ;
71156   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71157   float result;
71158
71159   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71160   {
71161     try {
71162       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
71163     } catch (std::out_of_range& e) {
71164       {
71165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71166       };
71167     } catch (std::exception& e) {
71168       {
71169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71170       };
71171     } catch (...) {
71172       {
71173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71174       };
71175     }
71176   }
71177   jresult = result;
71178   return jresult;
71179 }
71180
71181
71182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
71183   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71184
71185   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71186   {
71187     try {
71188       delete arg1;
71189     } catch (std::out_of_range& e) {
71190       {
71191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71192       };
71193     } catch (std::exception& e) {
71194       {
71195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71196       };
71197     } catch (...) {
71198       {
71199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71200       };
71201     }
71202   }
71203 }
71204
71205
71206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
71207   float jresult ;
71208   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71209   float arg2 ;
71210   float arg3 ;
71211   float result;
71212
71213   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71214   arg2 = (float)jarg2;
71215   arg3 = (float)jarg3;
71216   {
71217     try {
71218       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
71219     } catch (std::out_of_range& e) {
71220       {
71221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71222       };
71223     } catch (std::exception& e) {
71224       {
71225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71226       };
71227     } catch (...) {
71228       {
71229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71230       };
71231     }
71232   }
71233   jresult = result;
71234   return jresult;
71235 }
71236
71237
71238 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
71239   float jresult ;
71240   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71241   float arg2 ;
71242   float result;
71243
71244   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71245   arg2 = (float)jarg2;
71246   {
71247     try {
71248       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
71249     } catch (std::out_of_range& e) {
71250       {
71251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71252       };
71253     } catch (std::exception& e) {
71254       {
71255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71256       };
71257     } catch (...) {
71258       {
71259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71260       };
71261     }
71262   }
71263   jresult = result;
71264   return jresult;
71265 }
71266
71267
71268 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
71269   float jresult ;
71270   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71271   unsigned int arg2 ;
71272   unsigned int *arg3 = 0 ;
71273   bool arg4 ;
71274   float result;
71275
71276   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71277   arg2 = (unsigned int)jarg2;
71278   arg3 = (unsigned int *)jarg3;
71279   arg4 = jarg4 ? true : false;
71280   {
71281     try {
71282       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
71283     } catch (std::out_of_range& e) {
71284       {
71285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71286       };
71287     } catch (std::exception& e) {
71288       {
71289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71290       };
71291     } catch (...) {
71292       {
71293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71294       };
71295     }
71296   }
71297   jresult = result;
71298   return jresult;
71299 }
71300
71301
71302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
71303   unsigned int jresult ;
71304   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71305   float arg2 ;
71306   bool arg3 ;
71307   unsigned int result;
71308
71309   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71310   arg2 = (float)jarg2;
71311   arg3 = jarg3 ? true : false;
71312   {
71313     try {
71314       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
71315     } catch (std::out_of_range& e) {
71316       {
71317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71318       };
71319     } catch (std::exception& e) {
71320       {
71321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71322       };
71323     } catch (...) {
71324       {
71325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71326       };
71327     }
71328   }
71329   jresult = result;
71330   return jresult;
71331 }
71332
71333
71334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
71335   unsigned int jresult ;
71336   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71337   unsigned int result;
71338
71339   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71340   {
71341     try {
71342       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
71343     } catch (std::out_of_range& e) {
71344       {
71345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71346       };
71347     } catch (std::exception& e) {
71348       {
71349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71350       };
71351     } catch (...) {
71352       {
71353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71354       };
71355     }
71356   }
71357   jresult = result;
71358   return jresult;
71359 }
71360
71361
71362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
71363   int jresult ;
71364   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71365   Dali::Toolkit::Ruler::RulerType result;
71366
71367   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71368   {
71369     try {
71370       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
71371     } catch (std::out_of_range& e) {
71372       {
71373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71374       };
71375     } catch (std::exception& e) {
71376       {
71377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71378       };
71379     } catch (...) {
71380       {
71381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71382       };
71383     }
71384   }
71385   jresult = (int)result;
71386   return jresult;
71387 }
71388
71389
71390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
71391   unsigned int jresult ;
71392   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71393   bool result;
71394
71395   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71396   {
71397     try {
71398       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
71399     } catch (std::out_of_range& e) {
71400       {
71401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71402       };
71403     } catch (std::exception& e) {
71404       {
71405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71406       };
71407     } catch (...) {
71408       {
71409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71410       };
71411     }
71412   }
71413   jresult = result;
71414   return jresult;
71415 }
71416
71417
71418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
71419   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71420
71421   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71422   {
71423     try {
71424       (arg1)->Enable();
71425     } catch (std::out_of_range& e) {
71426       {
71427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71428       };
71429     } catch (std::exception& e) {
71430       {
71431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71432       };
71433     } catch (...) {
71434       {
71435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71436       };
71437     }
71438   }
71439 }
71440
71441
71442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
71443   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71444
71445   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71446   {
71447     try {
71448       (arg1)->Disable();
71449     } catch (std::out_of_range& e) {
71450       {
71451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71452       };
71453     } catch (std::exception& e) {
71454       {
71455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71456       };
71457     } catch (...) {
71458       {
71459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71460       };
71461     }
71462   }
71463 }
71464
71465
71466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
71467   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71468   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
71469   Dali::Toolkit::RulerDomain *argp2 ;
71470
71471   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71472   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
71473   if (!argp2) {
71474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
71475     return ;
71476   }
71477   arg2 = *argp2;
71478   {
71479     try {
71480       (arg1)->SetDomain(arg2);
71481     } catch (std::out_of_range& e) {
71482       {
71483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71484       };
71485     } catch (std::exception& e) {
71486       {
71487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71488       };
71489     } catch (...) {
71490       {
71491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71492       };
71493     }
71494   }
71495 }
71496
71497
71498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
71499   void * jresult ;
71500   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71501   Dali::Toolkit::RulerDomain *result = 0 ;
71502
71503   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71504   {
71505     try {
71506       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
71507     } catch (std::out_of_range& e) {
71508       {
71509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71510       };
71511     } catch (std::exception& e) {
71512       {
71513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71514       };
71515     } catch (...) {
71516       {
71517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71518       };
71519     }
71520   }
71521   jresult = (void *)result;
71522   return jresult;
71523 }
71524
71525
71526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
71527   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71528
71529   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71530   {
71531     try {
71532       (arg1)->DisableDomain();
71533     } catch (std::out_of_range& e) {
71534       {
71535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71536       };
71537     } catch (std::exception& e) {
71538       {
71539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71540       };
71541     } catch (...) {
71542       {
71543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71544       };
71545     }
71546   }
71547 }
71548
71549
71550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71551   float jresult ;
71552   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71553   float arg2 ;
71554   float arg3 ;
71555   float arg4 ;
71556   float result;
71557
71558   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71559   arg2 = (float)jarg2;
71560   arg3 = (float)jarg3;
71561   arg4 = (float)jarg4;
71562   {
71563     try {
71564       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
71565     } catch (std::out_of_range& e) {
71566       {
71567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71568       };
71569     } catch (std::exception& e) {
71570       {
71571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71572       };
71573     } catch (...) {
71574       {
71575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71576       };
71577     }
71578   }
71579   jresult = result;
71580   return jresult;
71581 }
71582
71583
71584 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71585   float jresult ;
71586   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71587   float arg2 ;
71588   float arg3 ;
71589   float result;
71590
71591   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71592   arg2 = (float)jarg2;
71593   arg3 = (float)jarg3;
71594   {
71595     try {
71596       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
71597     } catch (std::out_of_range& e) {
71598       {
71599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71600       };
71601     } catch (std::exception& e) {
71602       {
71603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71604       };
71605     } catch (...) {
71606       {
71607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71608       };
71609     }
71610   }
71611   jresult = result;
71612   return jresult;
71613 }
71614
71615
71616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
71617   float jresult ;
71618   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71619   float arg2 ;
71620   float result;
71621
71622   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71623   arg2 = (float)jarg2;
71624   {
71625     try {
71626       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
71627     } catch (std::out_of_range& e) {
71628       {
71629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71630       };
71631     } catch (std::exception& e) {
71632       {
71633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71634       };
71635     } catch (...) {
71636       {
71637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71638       };
71639     }
71640   }
71641   jresult = result;
71642   return jresult;
71643 }
71644
71645
71646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71647   float jresult ;
71648   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71649   float arg2 ;
71650   float arg3 ;
71651   float arg4 ;
71652   Dali::Toolkit::ClampState *arg5 = 0 ;
71653   float result;
71654
71655   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71656   arg2 = (float)jarg2;
71657   arg3 = (float)jarg3;
71658   arg4 = (float)jarg4;
71659   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71660   if (!arg5) {
71661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71662     return 0;
71663   }
71664   {
71665     try {
71666       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71667     } catch (std::out_of_range& e) {
71668       {
71669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71670       };
71671     } catch (std::exception& e) {
71672       {
71673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71674       };
71675     } catch (...) {
71676       {
71677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71678       };
71679     }
71680   }
71681   jresult = result;
71682   return jresult;
71683 }
71684
71685
71686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
71687   float jresult ;
71688   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71689   float arg2 ;
71690   float arg3 ;
71691   float arg4 ;
71692   float arg5 ;
71693   float result;
71694
71695   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71696   arg2 = (float)jarg2;
71697   arg3 = (float)jarg3;
71698   arg4 = (float)jarg4;
71699   arg5 = (float)jarg5;
71700   {
71701     try {
71702       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
71703     } catch (std::out_of_range& e) {
71704       {
71705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71706       };
71707     } catch (std::exception& e) {
71708       {
71709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71710       };
71711     } catch (...) {
71712       {
71713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71714       };
71715     }
71716   }
71717   jresult = result;
71718   return jresult;
71719 }
71720
71721
71722 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
71723   float jresult ;
71724   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71725   float arg2 ;
71726   float arg3 ;
71727   float arg4 ;
71728   float result;
71729
71730   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71731   arg2 = (float)jarg2;
71732   arg3 = (float)jarg3;
71733   arg4 = (float)jarg4;
71734   {
71735     try {
71736       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
71737     } catch (std::out_of_range& e) {
71738       {
71739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71740       };
71741     } catch (std::exception& e) {
71742       {
71743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71744       };
71745     } catch (...) {
71746       {
71747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71748       };
71749     }
71750   }
71751   jresult = result;
71752   return jresult;
71753 }
71754
71755
71756 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
71757   float jresult ;
71758   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71759   float arg2 ;
71760   float arg3 ;
71761   float result;
71762
71763   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71764   arg2 = (float)jarg2;
71765   arg3 = (float)jarg3;
71766   {
71767     try {
71768       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
71769     } catch (std::out_of_range& e) {
71770       {
71771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71772       };
71773     } catch (std::exception& e) {
71774       {
71775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71776       };
71777     } catch (...) {
71778       {
71779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71780       };
71781     }
71782   }
71783   jresult = result;
71784   return jresult;
71785 }
71786
71787
71788 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
71789   float jresult ;
71790   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71791   float arg2 ;
71792   float result;
71793
71794   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71795   arg2 = (float)jarg2;
71796   {
71797     try {
71798       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
71799     } catch (std::out_of_range& e) {
71800       {
71801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71802       };
71803     } catch (std::exception& e) {
71804       {
71805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71806       };
71807     } catch (...) {
71808       {
71809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71810       };
71811     }
71812   }
71813   jresult = result;
71814   return jresult;
71815 }
71816
71817
71818 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
71819   float jresult ;
71820   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71821   float arg2 ;
71822   float arg3 ;
71823   float arg4 ;
71824   float arg5 ;
71825   Dali::Toolkit::ClampState *arg6 = 0 ;
71826   float result;
71827
71828   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71829   arg2 = (float)jarg2;
71830   arg3 = (float)jarg3;
71831   arg4 = (float)jarg4;
71832   arg5 = (float)jarg5;
71833   arg6 = (Dali::Toolkit::ClampState *)jarg6;
71834   if (!arg6) {
71835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71836     return 0;
71837   }
71838   {
71839     try {
71840       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
71841     } catch (std::out_of_range& e) {
71842       {
71843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71844       };
71845     } catch (std::exception& e) {
71846       {
71847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71848       };
71849     } catch (...) {
71850       {
71851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71852       };
71853     }
71854   }
71855   jresult = result;
71856   return jresult;
71857 }
71858
71859
71860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
71861   void * jresult ;
71862   Dali::Toolkit::DefaultRuler *result = 0 ;
71863
71864   {
71865     try {
71866       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
71867     } catch (std::out_of_range& e) {
71868       {
71869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71870       };
71871     } catch (std::exception& e) {
71872       {
71873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71874       };
71875     } catch (...) {
71876       {
71877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71878       };
71879     }
71880   }
71881   jresult = (void *)result;
71882   return jresult;
71883 }
71884
71885
71886 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
71887   float jresult ;
71888   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
71889   float arg2 ;
71890   float arg3 ;
71891   float result;
71892
71893   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
71894   arg2 = (float)jarg2;
71895   arg3 = (float)jarg3;
71896   {
71897     try {
71898       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
71899     } catch (std::out_of_range& e) {
71900       {
71901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71902       };
71903     } catch (std::exception& e) {
71904       {
71905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71906       };
71907     } catch (...) {
71908       {
71909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71910       };
71911     }
71912   }
71913   jresult = result;
71914   return jresult;
71915 }
71916
71917
71918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
71919   float jresult ;
71920   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
71921   unsigned int arg2 ;
71922   unsigned int *arg3 = 0 ;
71923   bool arg4 ;
71924   float result;
71925
71926   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
71927   arg2 = (unsigned int)jarg2;
71928   arg3 = (unsigned int *)jarg3;
71929   arg4 = jarg4 ? true : false;
71930   {
71931     try {
71932       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
71933     } catch (std::out_of_range& e) {
71934       {
71935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71936       };
71937     } catch (std::exception& e) {
71938       {
71939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71940       };
71941     } catch (...) {
71942       {
71943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71944       };
71945     }
71946   }
71947   jresult = result;
71948   return jresult;
71949 }
71950
71951
71952 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
71953   unsigned int jresult ;
71954   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
71955   float arg2 ;
71956   bool arg3 ;
71957   unsigned int result;
71958
71959   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
71960   arg2 = (float)jarg2;
71961   arg3 = jarg3 ? true : false;
71962   {
71963     try {
71964       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
71965     } catch (std::out_of_range& e) {
71966       {
71967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71968       };
71969     } catch (std::exception& e) {
71970       {
71971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71972       };
71973     } catch (...) {
71974       {
71975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71976       };
71977     }
71978   }
71979   jresult = result;
71980   return jresult;
71981 }
71982
71983
71984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
71985   unsigned int jresult ;
71986   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
71987   unsigned int result;
71988
71989   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
71990   {
71991     try {
71992       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
71993     } catch (std::out_of_range& e) {
71994       {
71995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71996       };
71997     } catch (std::exception& e) {
71998       {
71999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72000       };
72001     } catch (...) {
72002       {
72003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72004       };
72005     }
72006   }
72007   jresult = result;
72008   return jresult;
72009 }
72010
72011
72012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
72013   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72014
72015   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72016   {
72017     try {
72018       delete arg1;
72019     } catch (std::out_of_range& e) {
72020       {
72021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72022       };
72023     } catch (std::exception& e) {
72024       {
72025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72026       };
72027     } catch (...) {
72028       {
72029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72030       };
72031     }
72032   }
72033 }
72034
72035
72036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
72037   void * jresult ;
72038   float arg1 ;
72039   Dali::Toolkit::FixedRuler *result = 0 ;
72040
72041   arg1 = (float)jarg1;
72042   {
72043     try {
72044       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
72045     } catch (std::out_of_range& e) {
72046       {
72047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72048       };
72049     } catch (std::exception& e) {
72050       {
72051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72052       };
72053     } catch (...) {
72054       {
72055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72056       };
72057     }
72058   }
72059   jresult = (void *)result;
72060   return jresult;
72061 }
72062
72063
72064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
72065   void * jresult ;
72066   Dali::Toolkit::FixedRuler *result = 0 ;
72067
72068   {
72069     try {
72070       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
72071     } catch (std::out_of_range& e) {
72072       {
72073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72074       };
72075     } catch (std::exception& e) {
72076       {
72077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72078       };
72079     } catch (...) {
72080       {
72081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72082       };
72083     }
72084   }
72085   jresult = (void *)result;
72086   return jresult;
72087 }
72088
72089
72090 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72091   float jresult ;
72092   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72093   float arg2 ;
72094   float arg3 ;
72095   float result;
72096
72097   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72098   arg2 = (float)jarg2;
72099   arg3 = (float)jarg3;
72100   {
72101     try {
72102       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
72103     } catch (std::out_of_range& e) {
72104       {
72105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72106       };
72107     } catch (std::exception& e) {
72108       {
72109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72110       };
72111     } catch (...) {
72112       {
72113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72114       };
72115     }
72116   }
72117   jresult = result;
72118   return jresult;
72119 }
72120
72121
72122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72123   float jresult ;
72124   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72125   unsigned int arg2 ;
72126   unsigned int *arg3 = 0 ;
72127   bool arg4 ;
72128   float result;
72129
72130   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72131   arg2 = (unsigned int)jarg2;
72132   arg3 = (unsigned int *)jarg3;
72133   arg4 = jarg4 ? true : false;
72134   {
72135     try {
72136       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72137     } catch (std::out_of_range& e) {
72138       {
72139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72140       };
72141     } catch (std::exception& e) {
72142       {
72143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72144       };
72145     } catch (...) {
72146       {
72147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72148       };
72149     }
72150   }
72151   jresult = result;
72152   return jresult;
72153 }
72154
72155
72156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72157   unsigned int jresult ;
72158   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72159   float arg2 ;
72160   bool arg3 ;
72161   unsigned int result;
72162
72163   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72164   arg2 = (float)jarg2;
72165   arg3 = jarg3 ? true : false;
72166   {
72167     try {
72168       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72169     } catch (std::out_of_range& e) {
72170       {
72171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72172       };
72173     } catch (std::exception& e) {
72174       {
72175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72176       };
72177     } catch (...) {
72178       {
72179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72180       };
72181     }
72182   }
72183   jresult = result;
72184   return jresult;
72185 }
72186
72187
72188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
72189   unsigned int jresult ;
72190   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72191   unsigned int result;
72192
72193   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72194   {
72195     try {
72196       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
72197     } catch (std::out_of_range& e) {
72198       {
72199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72200       };
72201     } catch (std::exception& e) {
72202       {
72203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72204       };
72205     } catch (...) {
72206       {
72207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72208       };
72209     }
72210   }
72211   jresult = result;
72212   return jresult;
72213 }
72214
72215
72216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
72217   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72218
72219   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72220   {
72221     try {
72222       delete arg1;
72223     } catch (std::out_of_range& e) {
72224       {
72225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72226       };
72227     } catch (std::exception& e) {
72228       {
72229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72230       };
72231     } catch (...) {
72232       {
72233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72234       };
72235     }
72236   }
72237 }
72238
72239
72240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
72241   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72242   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72243
72244   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72245   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72246   if (arg1) (arg1)->scale = *arg2;
72247 }
72248
72249
72250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
72251   void * jresult ;
72252   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72253   Dali::Toolkit::ClampState2D *result = 0 ;
72254
72255   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72256   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
72257   jresult = (void *)result;
72258   return jresult;
72259 }
72260
72261
72262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
72263   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72264   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72265
72266   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72267   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72268   if (arg1) (arg1)->position = *arg2;
72269 }
72270
72271
72272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
72273   void * jresult ;
72274   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72275   Dali::Toolkit::ClampState2D *result = 0 ;
72276
72277   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72278   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
72279   jresult = (void *)result;
72280   return jresult;
72281 }
72282
72283
72284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
72285   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72286   Dali::Toolkit::ClampState arg2 ;
72287
72288   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72289   arg2 = (Dali::Toolkit::ClampState)jarg2;
72290   if (arg1) (arg1)->rotation = arg2;
72291 }
72292
72293
72294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
72295   int jresult ;
72296   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72297   Dali::Toolkit::ClampState result;
72298
72299   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72300   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
72301   jresult = (int)result;
72302   return jresult;
72303 }
72304
72305
72306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
72307   void * jresult ;
72308   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
72309
72310   {
72311     try {
72312       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
72313     } catch (std::out_of_range& e) {
72314       {
72315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72316       };
72317     } catch (std::exception& e) {
72318       {
72319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72320       };
72321     } catch (...) {
72322       {
72323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72324       };
72325     }
72326   }
72327   jresult = (void *)result;
72328   return jresult;
72329 }
72330
72331
72332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
72333   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72334
72335   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72336   {
72337     try {
72338       delete arg1;
72339     } catch (std::out_of_range& e) {
72340       {
72341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72342       };
72343     } catch (std::exception& e) {
72344       {
72345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72346       };
72347     } catch (...) {
72348       {
72349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72350       };
72351     }
72352   }
72353 }
72354
72355
72356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
72357   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72358   Dali::Toolkit::SnapType arg2 ;
72359
72360   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72361   arg2 = (Dali::Toolkit::SnapType)jarg2;
72362   if (arg1) (arg1)->type = arg2;
72363 }
72364
72365
72366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
72367   int jresult ;
72368   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72369   Dali::Toolkit::SnapType result;
72370
72371   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72372   result = (Dali::Toolkit::SnapType) ((arg1)->type);
72373   jresult = (int)result;
72374   return jresult;
72375 }
72376
72377
72378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
72379   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72380   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
72381
72382   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72383   arg2 = (Dali::Vector2 *)jarg2;
72384   if (arg1) (arg1)->position = *arg2;
72385 }
72386
72387
72388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
72389   void * jresult ;
72390   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72391   Dali::Vector2 *result = 0 ;
72392
72393   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72394   result = (Dali::Vector2 *)& ((arg1)->position);
72395   jresult = (void *)result;
72396   return jresult;
72397 }
72398
72399
72400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
72401   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72402   float arg2 ;
72403
72404   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72405   arg2 = (float)jarg2;
72406   if (arg1) (arg1)->duration = arg2;
72407 }
72408
72409
72410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
72411   float jresult ;
72412   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72413   float result;
72414
72415   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72416   result = (float) ((arg1)->duration);
72417   jresult = result;
72418   return jresult;
72419 }
72420
72421
72422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
72423   void * jresult ;
72424   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
72425
72426   {
72427     try {
72428       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
72429     } catch (std::out_of_range& e) {
72430       {
72431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72432       };
72433     } catch (std::exception& e) {
72434       {
72435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72436       };
72437     } catch (...) {
72438       {
72439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72440       };
72441     }
72442   }
72443   jresult = (void *)result;
72444   return jresult;
72445 }
72446
72447
72448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
72449   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72450
72451   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72452   {
72453     try {
72454       delete arg1;
72455     } catch (std::out_of_range& e) {
72456       {
72457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72458       };
72459     } catch (std::exception& e) {
72460       {
72461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72462       };
72463     } catch (...) {
72464       {
72465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72466       };
72467     }
72468   }
72469 }
72470
72471
72472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
72473   int jresult ;
72474   int result;
72475
72476   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
72477   jresult = (int)result;
72478   return jresult;
72479 }
72480
72481
72482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
72483   int jresult ;
72484   int result;
72485
72486   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
72487   jresult = (int)result;
72488   return jresult;
72489 }
72490
72491
72492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
72493   int jresult ;
72494   int result;
72495
72496   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
72497   jresult = (int)result;
72498   return jresult;
72499 }
72500
72501
72502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
72503   int jresult ;
72504   int result;
72505
72506   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
72507   jresult = (int)result;
72508   return jresult;
72509 }
72510
72511
72512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
72513   int jresult ;
72514   int result;
72515
72516   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
72517   jresult = (int)result;
72518   return jresult;
72519 }
72520
72521
72522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
72523   int jresult ;
72524   int result;
72525
72526   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
72527   jresult = (int)result;
72528   return jresult;
72529 }
72530
72531
72532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
72533   int jresult ;
72534   int result;
72535
72536   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
72537   jresult = (int)result;
72538   return jresult;
72539 }
72540
72541
72542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
72543   int jresult ;
72544   int result;
72545
72546   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
72547   jresult = (int)result;
72548   return jresult;
72549 }
72550
72551
72552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
72553   int jresult ;
72554   int result;
72555
72556   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
72557   jresult = (int)result;
72558   return jresult;
72559 }
72560
72561
72562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
72563   int jresult ;
72564   int result;
72565
72566   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
72567   jresult = (int)result;
72568   return jresult;
72569 }
72570
72571
72572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
72573   int jresult ;
72574   int result;
72575
72576   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
72577   jresult = (int)result;
72578   return jresult;
72579 }
72580
72581
72582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
72583   int jresult ;
72584   int result;
72585
72586   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
72587   jresult = (int)result;
72588   return jresult;
72589 }
72590
72591
72592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
72593   int jresult ;
72594   int result;
72595
72596   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
72597   jresult = (int)result;
72598   return jresult;
72599 }
72600
72601
72602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
72603   int jresult ;
72604   int result;
72605
72606   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
72607   jresult = (int)result;
72608   return jresult;
72609 }
72610
72611
72612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
72613   int jresult ;
72614   int result;
72615
72616   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
72617   jresult = (int)result;
72618   return jresult;
72619 }
72620
72621
72622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
72623   int jresult ;
72624   int result;
72625
72626   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
72627   jresult = (int)result;
72628   return jresult;
72629 }
72630
72631
72632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
72633   int jresult ;
72634   int result;
72635
72636   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
72637   jresult = (int)result;
72638   return jresult;
72639 }
72640
72641
72642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
72643   int jresult ;
72644   int result;
72645
72646   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
72647   jresult = (int)result;
72648   return jresult;
72649 }
72650
72651
72652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
72653   int jresult ;
72654   int result;
72655
72656   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
72657   jresult = (int)result;
72658   return jresult;
72659 }
72660
72661
72662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
72663   int jresult ;
72664   int result;
72665
72666   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
72667   jresult = (int)result;
72668   return jresult;
72669 }
72670
72671
72672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
72673   int jresult ;
72674   int result;
72675
72676   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
72677   jresult = (int)result;
72678   return jresult;
72679 }
72680
72681
72682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
72683   int jresult ;
72684   int result;
72685
72686   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
72687   jresult = (int)result;
72688   return jresult;
72689 }
72690
72691
72692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
72693   int jresult ;
72694   int result;
72695
72696   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
72697   jresult = (int)result;
72698   return jresult;
72699 }
72700
72701
72702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
72703   int jresult ;
72704   int result;
72705
72706   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
72707   jresult = (int)result;
72708   return jresult;
72709 }
72710
72711
72712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
72713   int jresult ;
72714   int result;
72715
72716   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
72717   jresult = (int)result;
72718   return jresult;
72719 }
72720
72721
72722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
72723   void * jresult ;
72724   Dali::Toolkit::ScrollView::Property *result = 0 ;
72725
72726   {
72727     try {
72728       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
72729     } catch (std::out_of_range& e) {
72730       {
72731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72732       };
72733     } catch (std::exception& e) {
72734       {
72735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72736       };
72737     } catch (...) {
72738       {
72739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72740       };
72741     }
72742   }
72743   jresult = (void *)result;
72744   return jresult;
72745 }
72746
72747
72748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
72749   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
72750
72751   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
72752   {
72753     try {
72754       delete arg1;
72755     } catch (std::out_of_range& e) {
72756       {
72757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72758       };
72759     } catch (std::exception& e) {
72760       {
72761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72762       };
72763     } catch (...) {
72764       {
72765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72766       };
72767     }
72768   }
72769 }
72770
72771
72772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
72773   void * jresult ;
72774   Dali::Toolkit::ScrollView *result = 0 ;
72775
72776   {
72777     try {
72778       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
72779     } catch (std::out_of_range& e) {
72780       {
72781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72782       };
72783     } catch (std::exception& e) {
72784       {
72785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72786       };
72787     } catch (...) {
72788       {
72789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72790       };
72791     }
72792   }
72793   jresult = (void *)result;
72794   return jresult;
72795 }
72796
72797
72798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
72799   void * jresult ;
72800   Dali::Toolkit::ScrollView *arg1 = 0 ;
72801   Dali::Toolkit::ScrollView *result = 0 ;
72802
72803   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72804   if (!arg1) {
72805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
72806     return 0;
72807   }
72808   {
72809     try {
72810       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
72811     } catch (std::out_of_range& e) {
72812       {
72813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72814       };
72815     } catch (std::exception& e) {
72816       {
72817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72818       };
72819     } catch (...) {
72820       {
72821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72822       };
72823     }
72824   }
72825   jresult = (void *)result;
72826   return jresult;
72827 }
72828
72829
72830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
72831   void * jresult ;
72832   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72833   Dali::Toolkit::ScrollView *arg2 = 0 ;
72834   Dali::Toolkit::ScrollView *result = 0 ;
72835
72836   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72837   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
72838   if (!arg2) {
72839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
72840     return 0;
72841   }
72842   {
72843     try {
72844       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
72845     } catch (std::out_of_range& e) {
72846       {
72847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72848       };
72849     } catch (std::exception& e) {
72850       {
72851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72852       };
72853     } catch (...) {
72854       {
72855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72856       };
72857     }
72858   }
72859   jresult = (void *)result;
72860   return jresult;
72861 }
72862
72863
72864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
72865   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72866
72867   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72868   {
72869     try {
72870       delete arg1;
72871     } catch (std::out_of_range& e) {
72872       {
72873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72874       };
72875     } catch (std::exception& e) {
72876       {
72877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72878       };
72879     } catch (...) {
72880       {
72881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72882       };
72883     }
72884   }
72885 }
72886
72887
72888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
72889   void * jresult ;
72890   Dali::Toolkit::ScrollView result;
72891
72892   {
72893     try {
72894       result = Dali::Toolkit::ScrollView::New();
72895     } catch (std::out_of_range& e) {
72896       {
72897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72898       };
72899     } catch (std::exception& e) {
72900       {
72901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72902       };
72903     } catch (...) {
72904       {
72905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72906       };
72907     }
72908   }
72909   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
72910   return jresult;
72911 }
72912
72913
72914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
72915   void * jresult ;
72916   Dali::BaseHandle arg1 ;
72917   Dali::BaseHandle *argp1 ;
72918   Dali::Toolkit::ScrollView result;
72919
72920   argp1 = (Dali::BaseHandle *)jarg1;
72921   if (!argp1) {
72922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72923     return 0;
72924   }
72925   arg1 = *argp1;
72926   {
72927     try {
72928       result = Dali::Toolkit::ScrollView::DownCast(arg1);
72929     } catch (std::out_of_range& e) {
72930       {
72931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72932       };
72933     } catch (std::exception& e) {
72934       {
72935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72936       };
72937     } catch (...) {
72938       {
72939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72940       };
72941     }
72942   }
72943   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
72944   return jresult;
72945 }
72946
72947
72948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
72949   void * jresult ;
72950   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72951   Dali::AlphaFunction result;
72952
72953   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72954   {
72955     try {
72956       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
72957     } catch (std::out_of_range& e) {
72958       {
72959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72960       };
72961     } catch (std::exception& e) {
72962       {
72963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72964       };
72965     } catch (...) {
72966       {
72967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72968       };
72969     }
72970   }
72971   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
72972   return jresult;
72973 }
72974
72975
72976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
72977   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
72978   Dali::AlphaFunction arg2 ;
72979   Dali::AlphaFunction *argp2 ;
72980
72981   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
72982   argp2 = (Dali::AlphaFunction *)jarg2;
72983   if (!argp2) {
72984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
72985     return ;
72986   }
72987   arg2 = *argp2;
72988   {
72989     try {
72990       (arg1)->SetScrollSnapAlphaFunction(arg2);
72991     } catch (std::out_of_range& e) {
72992       {
72993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72994       };
72995     } catch (std::exception& e) {
72996       {
72997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72998       };
72999     } catch (...) {
73000       {
73001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73002       };
73003     }
73004   }
73005 }
73006
73007
73008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
73009   void * jresult ;
73010   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73011   Dali::AlphaFunction result;
73012
73013   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73014   {
73015     try {
73016       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
73017     } catch (std::out_of_range& e) {
73018       {
73019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73020       };
73021     } catch (std::exception& e) {
73022       {
73023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73024       };
73025     } catch (...) {
73026       {
73027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73028       };
73029     }
73030   }
73031   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73032   return jresult;
73033 }
73034
73035
73036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
73037   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73038   Dali::AlphaFunction arg2 ;
73039   Dali::AlphaFunction *argp2 ;
73040
73041   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73042   argp2 = (Dali::AlphaFunction *)jarg2;
73043   if (!argp2) {
73044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73045     return ;
73046   }
73047   arg2 = *argp2;
73048   {
73049     try {
73050       (arg1)->SetScrollFlickAlphaFunction(arg2);
73051     } catch (std::out_of_range& e) {
73052       {
73053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73054       };
73055     } catch (std::exception& e) {
73056       {
73057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73058       };
73059     } catch (...) {
73060       {
73061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73062       };
73063     }
73064   }
73065 }
73066
73067
73068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
73069   float jresult ;
73070   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73071   float result;
73072
73073   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73074   {
73075     try {
73076       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
73077     } catch (std::out_of_range& e) {
73078       {
73079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73080       };
73081     } catch (std::exception& e) {
73082       {
73083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73084       };
73085     } catch (...) {
73086       {
73087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73088       };
73089     }
73090   }
73091   jresult = result;
73092   return jresult;
73093 }
73094
73095
73096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
73097   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73098   float arg2 ;
73099
73100   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73101   arg2 = (float)jarg2;
73102   {
73103     try {
73104       (arg1)->SetScrollSnapDuration(arg2);
73105     } catch (std::out_of_range& e) {
73106       {
73107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73108       };
73109     } catch (std::exception& e) {
73110       {
73111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73112       };
73113     } catch (...) {
73114       {
73115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73116       };
73117     }
73118   }
73119 }
73120
73121
73122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
73123   float jresult ;
73124   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73125   float result;
73126
73127   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73128   {
73129     try {
73130       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
73131     } catch (std::out_of_range& e) {
73132       {
73133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73134       };
73135     } catch (std::exception& e) {
73136       {
73137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73138       };
73139     } catch (...) {
73140       {
73141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73142       };
73143     }
73144   }
73145   jresult = result;
73146   return jresult;
73147 }
73148
73149
73150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
73151   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73152   float arg2 ;
73153
73154   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73155   arg2 = (float)jarg2;
73156   {
73157     try {
73158       (arg1)->SetScrollFlickDuration(arg2);
73159     } catch (std::out_of_range& e) {
73160       {
73161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73162       };
73163     } catch (std::exception& e) {
73164       {
73165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73166       };
73167     } catch (...) {
73168       {
73169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73170       };
73171     }
73172   }
73173 }
73174
73175
73176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
73177   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73178   Dali::Toolkit::RulerPtr arg2 ;
73179   Dali::Toolkit::RulerPtr *argp2 ;
73180
73181   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73182   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73183   if (!argp2) {
73184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73185     return ;
73186   }
73187   arg2 = *argp2;
73188   {
73189     try {
73190       (arg1)->SetRulerX(arg2);
73191     } catch (std::out_of_range& e) {
73192       {
73193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73194       };
73195     } catch (std::exception& e) {
73196       {
73197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73198       };
73199     } catch (...) {
73200       {
73201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73202       };
73203     }
73204   }
73205 }
73206
73207
73208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
73209   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73210   Dali::Toolkit::RulerPtr arg2 ;
73211   Dali::Toolkit::RulerPtr *argp2 ;
73212
73213   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73214   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73215   if (!argp2) {
73216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73217     return ;
73218   }
73219   arg2 = *argp2;
73220   {
73221     try {
73222       (arg1)->SetRulerY(arg2);
73223     } catch (std::out_of_range& e) {
73224       {
73225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73226       };
73227     } catch (std::exception& e) {
73228       {
73229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73230       };
73231     } catch (...) {
73232       {
73233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73234       };
73235     }
73236   }
73237 }
73238
73239
73240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
73241   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73242   bool arg2 ;
73243
73244   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73245   arg2 = jarg2 ? true : false;
73246   {
73247     try {
73248       (arg1)->SetScrollSensitive(arg2);
73249     } catch (std::out_of_range& e) {
73250       {
73251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73252       };
73253     } catch (std::exception& e) {
73254       {
73255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73256       };
73257     } catch (...) {
73258       {
73259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73260       };
73261     }
73262   }
73263 }
73264
73265
73266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
73267   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73268   float arg2 ;
73269   float arg3 ;
73270
73271   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73272   arg2 = (float)jarg2;
73273   arg3 = (float)jarg3;
73274   {
73275     try {
73276       (arg1)->SetMaxOvershoot(arg2,arg3);
73277     } catch (std::out_of_range& e) {
73278       {
73279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73280       };
73281     } catch (std::exception& e) {
73282       {
73283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73284       };
73285     } catch (...) {
73286       {
73287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73288       };
73289     }
73290   }
73291 }
73292
73293
73294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
73295   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73296   Dali::AlphaFunction arg2 ;
73297   Dali::AlphaFunction *argp2 ;
73298
73299   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73300   argp2 = (Dali::AlphaFunction *)jarg2;
73301   if (!argp2) {
73302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73303     return ;
73304   }
73305   arg2 = *argp2;
73306   {
73307     try {
73308       (arg1)->SetSnapOvershootAlphaFunction(arg2);
73309     } catch (std::out_of_range& e) {
73310       {
73311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73312       };
73313     } catch (std::exception& e) {
73314       {
73315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73316       };
73317     } catch (...) {
73318       {
73319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73320       };
73321     }
73322   }
73323 }
73324
73325
73326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
73327   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73328   float arg2 ;
73329
73330   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73331   arg2 = (float)jarg2;
73332   {
73333     try {
73334       (arg1)->SetSnapOvershootDuration(arg2);
73335     } catch (std::out_of_range& e) {
73336       {
73337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73338       };
73339     } catch (std::exception& e) {
73340       {
73341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73342       };
73343     } catch (...) {
73344       {
73345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73346       };
73347     }
73348   }
73349 }
73350
73351
73352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
73353   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73354   bool arg2 ;
73355
73356   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73357   arg2 = jarg2 ? true : false;
73358   {
73359     try {
73360       (arg1)->SetActorAutoSnap(arg2);
73361     } catch (std::out_of_range& e) {
73362       {
73363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73364       };
73365     } catch (std::exception& e) {
73366       {
73367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73368       };
73369     } catch (...) {
73370       {
73371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73372       };
73373     }
73374   }
73375 }
73376
73377
73378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
73379   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73380   bool arg2 ;
73381
73382   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73383   arg2 = jarg2 ? true : false;
73384   {
73385     try {
73386       (arg1)->SetWrapMode(arg2);
73387     } catch (std::out_of_range& e) {
73388       {
73389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73390       };
73391     } catch (std::exception& e) {
73392       {
73393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73394       };
73395     } catch (...) {
73396       {
73397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73398       };
73399     }
73400   }
73401 }
73402
73403
73404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
73405   int jresult ;
73406   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73407   int result;
73408
73409   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73410   {
73411     try {
73412       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
73413     } catch (std::out_of_range& e) {
73414       {
73415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73416       };
73417     } catch (std::exception& e) {
73418       {
73419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73420       };
73421     } catch (...) {
73422       {
73423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73424       };
73425     }
73426   }
73427   jresult = result;
73428   return jresult;
73429 }
73430
73431
73432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
73433   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73434   int arg2 ;
73435
73436   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73437   arg2 = (int)jarg2;
73438   {
73439     try {
73440       (arg1)->SetScrollUpdateDistance(arg2);
73441     } catch (std::out_of_range& e) {
73442       {
73443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73444       };
73445     } catch (std::exception& e) {
73446       {
73447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73448       };
73449     } catch (...) {
73450       {
73451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73452       };
73453     }
73454   }
73455 }
73456
73457
73458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
73459   unsigned int jresult ;
73460   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73461   bool result;
73462
73463   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73464   {
73465     try {
73466       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
73467     } catch (std::out_of_range& e) {
73468       {
73469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73470       };
73471     } catch (std::exception& e) {
73472       {
73473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73474       };
73475     } catch (...) {
73476       {
73477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73478       };
73479     }
73480   }
73481   jresult = result;
73482   return jresult;
73483 }
73484
73485
73486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
73487   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73488   bool arg2 ;
73489
73490   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73491   arg2 = jarg2 ? true : false;
73492   {
73493     try {
73494       (arg1)->SetAxisAutoLock(arg2);
73495     } catch (std::out_of_range& e) {
73496       {
73497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73498       };
73499     } catch (std::exception& e) {
73500       {
73501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73502       };
73503     } catch (...) {
73504       {
73505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73506       };
73507     }
73508   }
73509 }
73510
73511
73512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
73513   float jresult ;
73514   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73515   float result;
73516
73517   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73518   {
73519     try {
73520       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
73521     } catch (std::out_of_range& e) {
73522       {
73523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73524       };
73525     } catch (std::exception& e) {
73526       {
73527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73528       };
73529     } catch (...) {
73530       {
73531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73532       };
73533     }
73534   }
73535   jresult = result;
73536   return jresult;
73537 }
73538
73539
73540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
73541   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73542   float arg2 ;
73543
73544   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73545   arg2 = (float)jarg2;
73546   {
73547     try {
73548       (arg1)->SetAxisAutoLockGradient(arg2);
73549     } catch (std::out_of_range& e) {
73550       {
73551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73552       };
73553     } catch (std::exception& e) {
73554       {
73555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73556       };
73557     } catch (...) {
73558       {
73559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73560       };
73561     }
73562   }
73563 }
73564
73565
73566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
73567   float jresult ;
73568   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73569   float result;
73570
73571   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73572   {
73573     try {
73574       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
73575     } catch (std::out_of_range& e) {
73576       {
73577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73578       };
73579     } catch (std::exception& e) {
73580       {
73581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73582       };
73583     } catch (...) {
73584       {
73585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73586       };
73587     }
73588   }
73589   jresult = result;
73590   return jresult;
73591 }
73592
73593
73594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
73595   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73596   float arg2 ;
73597
73598   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73599   arg2 = (float)jarg2;
73600   {
73601     try {
73602       (arg1)->SetFrictionCoefficient(arg2);
73603     } catch (std::out_of_range& e) {
73604       {
73605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73606       };
73607     } catch (std::exception& e) {
73608       {
73609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73610       };
73611     } catch (...) {
73612       {
73613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73614       };
73615     }
73616   }
73617 }
73618
73619
73620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
73621   float jresult ;
73622   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73623   float result;
73624
73625   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73626   {
73627     try {
73628       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
73629     } catch (std::out_of_range& e) {
73630       {
73631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73632       };
73633     } catch (std::exception& e) {
73634       {
73635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73636       };
73637     } catch (...) {
73638       {
73639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73640       };
73641     }
73642   }
73643   jresult = result;
73644   return jresult;
73645 }
73646
73647
73648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
73649   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73650   float arg2 ;
73651
73652   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73653   arg2 = (float)jarg2;
73654   {
73655     try {
73656       (arg1)->SetFlickSpeedCoefficient(arg2);
73657     } catch (std::out_of_range& e) {
73658       {
73659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73660       };
73661     } catch (std::exception& e) {
73662       {
73663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73664       };
73665     } catch (...) {
73666       {
73667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73668       };
73669     }
73670   }
73671 }
73672
73673
73674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
73675   void * jresult ;
73676   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73677   Dali::Vector2 result;
73678
73679   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73680   {
73681     try {
73682       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
73683     } catch (std::out_of_range& e) {
73684       {
73685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73686       };
73687     } catch (std::exception& e) {
73688       {
73689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73690       };
73691     } catch (...) {
73692       {
73693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73694       };
73695     }
73696   }
73697   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
73698   return jresult;
73699 }
73700
73701
73702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
73703   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73704   Dali::Vector2 *arg2 = 0 ;
73705
73706   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73707   arg2 = (Dali::Vector2 *)jarg2;
73708   if (!arg2) {
73709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
73710     return ;
73711   }
73712   {
73713     try {
73714       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
73715     } catch (std::out_of_range& e) {
73716       {
73717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73718       };
73719     } catch (std::exception& e) {
73720       {
73721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73722       };
73723     } catch (...) {
73724       {
73725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73726       };
73727     }
73728   }
73729 }
73730
73731
73732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
73733   float jresult ;
73734   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73735   float result;
73736
73737   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73738   {
73739     try {
73740       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
73741     } catch (std::out_of_range& e) {
73742       {
73743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73744       };
73745     } catch (std::exception& e) {
73746       {
73747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73748       };
73749     } catch (...) {
73750       {
73751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73752       };
73753     }
73754   }
73755   jresult = result;
73756   return jresult;
73757 }
73758
73759
73760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
73761   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73762   float arg2 ;
73763
73764   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73765   arg2 = (float)jarg2;
73766   {
73767     try {
73768       (arg1)->SetMinimumSpeedForFlick(arg2);
73769     } catch (std::out_of_range& e) {
73770       {
73771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73772       };
73773     } catch (std::exception& e) {
73774       {
73775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73776       };
73777     } catch (...) {
73778       {
73779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73780       };
73781     }
73782   }
73783 }
73784
73785
73786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
73787   float jresult ;
73788   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73789   float result;
73790
73791   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73792   {
73793     try {
73794       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
73795     } catch (std::out_of_range& e) {
73796       {
73797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73798       };
73799     } catch (std::exception& e) {
73800       {
73801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73802       };
73803     } catch (...) {
73804       {
73805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73806       };
73807     }
73808   }
73809   jresult = result;
73810   return jresult;
73811 }
73812
73813
73814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
73815   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73816   float arg2 ;
73817
73818   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73819   arg2 = (float)jarg2;
73820   {
73821     try {
73822       (arg1)->SetMaxFlickSpeed(arg2);
73823     } catch (std::out_of_range& e) {
73824       {
73825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73826       };
73827     } catch (std::exception& e) {
73828       {
73829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73830       };
73831     } catch (...) {
73832       {
73833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73834       };
73835     }
73836   }
73837 }
73838
73839
73840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
73841   void * jresult ;
73842   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73843   Dali::Vector2 result;
73844
73845   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73846   {
73847     try {
73848       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
73849     } catch (std::out_of_range& e) {
73850       {
73851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73852       };
73853     } catch (std::exception& e) {
73854       {
73855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73856       };
73857     } catch (...) {
73858       {
73859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73860       };
73861     }
73862   }
73863   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
73864   return jresult;
73865 }
73866
73867
73868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
73869   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73870   Dali::Vector2 arg2 ;
73871   Dali::Vector2 *argp2 ;
73872
73873   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73874   argp2 = (Dali::Vector2 *)jarg2;
73875   if (!argp2) {
73876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
73877     return ;
73878   }
73879   arg2 = *argp2;
73880   {
73881     try {
73882       (arg1)->SetWheelScrollDistanceStep(arg2);
73883     } catch (std::out_of_range& e) {
73884       {
73885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73886       };
73887     } catch (std::exception& e) {
73888       {
73889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73890       };
73891     } catch (...) {
73892       {
73893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73894       };
73895     }
73896   }
73897 }
73898
73899
73900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
73901   void * jresult ;
73902   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73903   Dali::Vector2 result;
73904
73905   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73906   {
73907     try {
73908       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
73909     } catch (std::out_of_range& e) {
73910       {
73911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73912       };
73913     } catch (std::exception& e) {
73914       {
73915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73916       };
73917     } catch (...) {
73918       {
73919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73920       };
73921     }
73922   }
73923   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
73924   return jresult;
73925 }
73926
73927
73928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
73929   unsigned int jresult ;
73930   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73931   unsigned int result;
73932
73933   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73934   {
73935     try {
73936       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
73937     } catch (std::out_of_range& e) {
73938       {
73939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73940       };
73941     } catch (std::exception& e) {
73942       {
73943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73944       };
73945     } catch (...) {
73946       {
73947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73948       };
73949     }
73950   }
73951   jresult = result;
73952   return jresult;
73953 }
73954
73955
73956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
73957   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73958   Dali::Vector2 *arg2 = 0 ;
73959
73960   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73961   arg2 = (Dali::Vector2 *)jarg2;
73962   if (!arg2) {
73963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
73964     return ;
73965   }
73966   {
73967     try {
73968       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
73969     } catch (std::out_of_range& e) {
73970       {
73971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73972       };
73973     } catch (std::exception& e) {
73974       {
73975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73976       };
73977     } catch (...) {
73978       {
73979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73980       };
73981     }
73982   }
73983 }
73984
73985
73986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
73987   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73988   Dali::Vector2 *arg2 = 0 ;
73989   float arg3 ;
73990
73991   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73992   arg2 = (Dali::Vector2 *)jarg2;
73993   if (!arg2) {
73994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
73995     return ;
73996   }
73997   arg3 = (float)jarg3;
73998   {
73999     try {
74000       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
74001     } catch (std::out_of_range& e) {
74002       {
74003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74004       };
74005     } catch (std::exception& e) {
74006       {
74007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74008       };
74009     } catch (...) {
74010       {
74011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74012       };
74013     }
74014   }
74015 }
74016
74017
74018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
74019   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74020   Dali::Vector2 *arg2 = 0 ;
74021   float arg3 ;
74022   Dali::AlphaFunction arg4 ;
74023   Dali::AlphaFunction *argp4 ;
74024
74025   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74026   arg2 = (Dali::Vector2 *)jarg2;
74027   if (!arg2) {
74028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74029     return ;
74030   }
74031   arg3 = (float)jarg3;
74032   argp4 = (Dali::AlphaFunction *)jarg4;
74033   if (!argp4) {
74034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74035     return ;
74036   }
74037   arg4 = *argp4;
74038   {
74039     try {
74040       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
74041     } catch (std::out_of_range& e) {
74042       {
74043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74044       };
74045     } catch (std::exception& e) {
74046       {
74047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74048       };
74049     } catch (...) {
74050       {
74051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74052       };
74053     }
74054   }
74055 }
74056
74057
74058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
74059   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74060   Dali::Vector2 *arg2 = 0 ;
74061   float arg3 ;
74062   Dali::Toolkit::DirectionBias arg4 ;
74063   Dali::Toolkit::DirectionBias arg5 ;
74064
74065   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74066   arg2 = (Dali::Vector2 *)jarg2;
74067   if (!arg2) {
74068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74069     return ;
74070   }
74071   arg3 = (float)jarg3;
74072   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74073   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74074   {
74075     try {
74076       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
74077     } catch (std::out_of_range& e) {
74078       {
74079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74080       };
74081     } catch (std::exception& e) {
74082       {
74083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74084       };
74085     } catch (...) {
74086       {
74087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74088       };
74089     }
74090   }
74091 }
74092
74093
74094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
74095   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74096   Dali::Vector2 *arg2 = 0 ;
74097   float arg3 ;
74098   Dali::AlphaFunction arg4 ;
74099   Dali::Toolkit::DirectionBias arg5 ;
74100   Dali::Toolkit::DirectionBias arg6 ;
74101   Dali::AlphaFunction *argp4 ;
74102
74103   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74104   arg2 = (Dali::Vector2 *)jarg2;
74105   if (!arg2) {
74106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74107     return ;
74108   }
74109   arg3 = (float)jarg3;
74110   argp4 = (Dali::AlphaFunction *)jarg4;
74111   if (!argp4) {
74112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74113     return ;
74114   }
74115   arg4 = *argp4;
74116   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74117   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
74118   {
74119     try {
74120       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
74121     } catch (std::out_of_range& e) {
74122       {
74123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74124       };
74125     } catch (std::exception& e) {
74126       {
74127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74128       };
74129     } catch (...) {
74130       {
74131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74132       };
74133     }
74134   }
74135 }
74136
74137
74138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
74139   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74140   unsigned int arg2 ;
74141
74142   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74143   arg2 = (unsigned int)jarg2;
74144   {
74145     try {
74146       (arg1)->ScrollTo(arg2);
74147     } catch (std::out_of_range& e) {
74148       {
74149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74150       };
74151     } catch (std::exception& e) {
74152       {
74153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74154       };
74155     } catch (...) {
74156       {
74157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74158       };
74159     }
74160   }
74161 }
74162
74163
74164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
74165   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74166   unsigned int arg2 ;
74167   float arg3 ;
74168
74169   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74170   arg2 = (unsigned int)jarg2;
74171   arg3 = (float)jarg3;
74172   {
74173     try {
74174       (arg1)->ScrollTo(arg2,arg3);
74175     } catch (std::out_of_range& e) {
74176       {
74177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74178       };
74179     } catch (std::exception& e) {
74180       {
74181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74182       };
74183     } catch (...) {
74184       {
74185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74186       };
74187     }
74188   }
74189 }
74190
74191
74192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
74193   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74194   unsigned int arg2 ;
74195   float arg3 ;
74196   Dali::Toolkit::DirectionBias arg4 ;
74197
74198   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74199   arg2 = (unsigned int)jarg2;
74200   arg3 = (float)jarg3;
74201   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74202   {
74203     try {
74204       (arg1)->ScrollTo(arg2,arg3,arg4);
74205     } catch (std::out_of_range& e) {
74206       {
74207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74208       };
74209     } catch (std::exception& e) {
74210       {
74211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74212       };
74213     } catch (...) {
74214       {
74215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74216       };
74217     }
74218   }
74219 }
74220
74221
74222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
74223   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74224   Dali::Actor *arg2 = 0 ;
74225
74226   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74227   arg2 = (Dali::Actor *)jarg2;
74228   if (!arg2) {
74229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74230     return ;
74231   }
74232   {
74233     try {
74234       (arg1)->ScrollTo(*arg2);
74235     } catch (std::out_of_range& e) {
74236       {
74237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74238       };
74239     } catch (std::exception& e) {
74240       {
74241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74242       };
74243     } catch (...) {
74244       {
74245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74246       };
74247     }
74248   }
74249 }
74250
74251
74252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
74253   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74254   Dali::Actor *arg2 = 0 ;
74255   float arg3 ;
74256
74257   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74258   arg2 = (Dali::Actor *)jarg2;
74259   if (!arg2) {
74260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74261     return ;
74262   }
74263   arg3 = (float)jarg3;
74264   {
74265     try {
74266       (arg1)->ScrollTo(*arg2,arg3);
74267     } catch (std::out_of_range& e) {
74268       {
74269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74270       };
74271     } catch (std::exception& e) {
74272       {
74273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74274       };
74275     } catch (...) {
74276       {
74277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74278       };
74279     }
74280   }
74281 }
74282
74283
74284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
74285   unsigned int jresult ;
74286   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74287   bool result;
74288
74289   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74290   {
74291     try {
74292       result = (bool)(arg1)->ScrollToSnapPoint();
74293     } catch (std::out_of_range& e) {
74294       {
74295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74296       };
74297     } catch (std::exception& e) {
74298       {
74299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74300       };
74301     } catch (...) {
74302       {
74303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74304       };
74305     }
74306   }
74307   jresult = result;
74308   return jresult;
74309 }
74310
74311
74312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
74313   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74314   Dali::Constraint arg2 ;
74315   Dali::Constraint *argp2 ;
74316
74317   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74318   argp2 = (Dali::Constraint *)jarg2;
74319   if (!argp2) {
74320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
74321     return ;
74322   }
74323   arg2 = *argp2;
74324   {
74325     try {
74326       (arg1)->ApplyConstraintToChildren(arg2);
74327     } catch (std::out_of_range& e) {
74328       {
74329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74330       };
74331     } catch (std::exception& e) {
74332       {
74333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74334       };
74335     } catch (...) {
74336       {
74337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74338       };
74339     }
74340   }
74341 }
74342
74343
74344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
74345   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74346
74347   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74348   {
74349     try {
74350       (arg1)->RemoveConstraintsFromChildren();
74351     } catch (std::out_of_range& e) {
74352       {
74353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74354       };
74355     } catch (std::exception& e) {
74356       {
74357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74358       };
74359     } catch (...) {
74360       {
74361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74362       };
74363     }
74364   }
74365 }
74366
74367
74368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
74369   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74370   Dali::Toolkit::ScrollViewEffect arg2 ;
74371   Dali::Toolkit::ScrollViewEffect *argp2 ;
74372
74373   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74374   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74375   if (!argp2) {
74376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74377     return ;
74378   }
74379   arg2 = *argp2;
74380   {
74381     try {
74382       (arg1)->ApplyEffect(arg2);
74383     } catch (std::out_of_range& e) {
74384       {
74385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74386       };
74387     } catch (std::exception& e) {
74388       {
74389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74390       };
74391     } catch (...) {
74392       {
74393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74394       };
74395     }
74396   }
74397 }
74398
74399
74400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
74401   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74402   Dali::Toolkit::ScrollViewEffect arg2 ;
74403   Dali::Toolkit::ScrollViewEffect *argp2 ;
74404
74405   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74406   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74407   if (!argp2) {
74408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74409     return ;
74410   }
74411   arg2 = *argp2;
74412   {
74413     try {
74414       (arg1)->RemoveEffect(arg2);
74415     } catch (std::out_of_range& e) {
74416       {
74417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74418       };
74419     } catch (std::exception& e) {
74420       {
74421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74422       };
74423     } catch (...) {
74424       {
74425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74426       };
74427     }
74428   }
74429 }
74430
74431
74432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
74433   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74434
74435   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74436   {
74437     try {
74438       (arg1)->RemoveAllEffects();
74439     } catch (std::out_of_range& e) {
74440       {
74441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74442       };
74443     } catch (std::exception& e) {
74444       {
74445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74446       };
74447     } catch (...) {
74448       {
74449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74450       };
74451     }
74452   }
74453 }
74454
74455
74456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
74457   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74458   Dali::Actor arg2 ;
74459   Dali::Actor *argp2 ;
74460
74461   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74462   argp2 = (Dali::Actor *)jarg2;
74463   if (!argp2) {
74464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74465     return ;
74466   }
74467   arg2 = *argp2;
74468   {
74469     try {
74470       (arg1)->BindActor(arg2);
74471     } catch (std::out_of_range& e) {
74472       {
74473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74474       };
74475     } catch (std::exception& e) {
74476       {
74477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74478       };
74479     } catch (...) {
74480       {
74481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74482       };
74483     }
74484   }
74485 }
74486
74487
74488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
74489   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74490   Dali::Actor arg2 ;
74491   Dali::Actor *argp2 ;
74492
74493   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74494   argp2 = (Dali::Actor *)jarg2;
74495   if (!argp2) {
74496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74497     return ;
74498   }
74499   arg2 = *argp2;
74500   {
74501     try {
74502       (arg1)->UnbindActor(arg2);
74503     } catch (std::out_of_range& e) {
74504       {
74505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74506       };
74507     } catch (std::exception& e) {
74508       {
74509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74510       };
74511     } catch (...) {
74512       {
74513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74514       };
74515     }
74516   }
74517 }
74518
74519
74520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
74521   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74522   Dali::Radian arg2 ;
74523   Dali::Radian arg3 ;
74524   Dali::Radian *argp2 ;
74525   Dali::Radian *argp3 ;
74526
74527   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74528   argp2 = (Dali::Radian *)jarg2;
74529   if (!argp2) {
74530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74531     return ;
74532   }
74533   arg2 = *argp2;
74534   argp3 = (Dali::Radian *)jarg3;
74535   if (!argp3) {
74536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74537     return ;
74538   }
74539   arg3 = *argp3;
74540   {
74541     try {
74542       (arg1)->SetScrollingDirection(arg2,arg3);
74543     } catch (std::out_of_range& e) {
74544       {
74545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74546       };
74547     } catch (std::exception& e) {
74548       {
74549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74550       };
74551     } catch (...) {
74552       {
74553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74554       };
74555     }
74556   }
74557 }
74558
74559
74560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
74561   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74562   Dali::Radian arg2 ;
74563   Dali::Radian *argp2 ;
74564
74565   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74566   argp2 = (Dali::Radian *)jarg2;
74567   if (!argp2) {
74568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74569     return ;
74570   }
74571   arg2 = *argp2;
74572   {
74573     try {
74574       (arg1)->SetScrollingDirection(arg2);
74575     } catch (std::out_of_range& e) {
74576       {
74577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74578       };
74579     } catch (std::exception& e) {
74580       {
74581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74582       };
74583     } catch (...) {
74584       {
74585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74586       };
74587     }
74588   }
74589 }
74590
74591
74592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
74593   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74594   Dali::Radian arg2 ;
74595   Dali::Radian *argp2 ;
74596
74597   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74598   argp2 = (Dali::Radian *)jarg2;
74599   if (!argp2) {
74600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74601     return ;
74602   }
74603   arg2 = *argp2;
74604   {
74605     try {
74606       (arg1)->RemoveScrollingDirection(arg2);
74607     } catch (std::out_of_range& e) {
74608       {
74609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74610       };
74611     } catch (std::exception& e) {
74612       {
74613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74614       };
74615     } catch (...) {
74616       {
74617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74618       };
74619     }
74620   }
74621 }
74622
74623
74624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
74625   void * jresult ;
74626   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74627   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
74628
74629   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74630   {
74631     try {
74632       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
74633     } catch (std::out_of_range& e) {
74634       {
74635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74636       };
74637     } catch (std::exception& e) {
74638       {
74639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74640       };
74641     } catch (...) {
74642       {
74643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74644       };
74645     }
74646   }
74647   jresult = (void *)result;
74648   return jresult;
74649 }
74650
74651
74652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
74653   int jresult ;
74654   int result;
74655
74656   result = (int)Dali::Toolkit::TableView::Property::ROWS;
74657   jresult = (int)result;
74658   return jresult;
74659 }
74660
74661
74662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
74663   int jresult ;
74664   int result;
74665
74666   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
74667   jresult = (int)result;
74668   return jresult;
74669 }
74670
74671
74672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
74673   int jresult ;
74674   int result;
74675
74676   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
74677   jresult = (int)result;
74678   return jresult;
74679 }
74680
74681
74682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
74683   int jresult ;
74684   int result;
74685
74686   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
74687   jresult = (int)result;
74688   return jresult;
74689 }
74690
74691
74692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
74693   int jresult ;
74694   int result;
74695
74696   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
74697   jresult = (int)result;
74698   return jresult;
74699 }
74700
74701
74702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
74703   void * jresult ;
74704   Dali::Toolkit::TableView::Property *result = 0 ;
74705
74706   {
74707     try {
74708       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
74709     } catch (std::out_of_range& e) {
74710       {
74711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74712       };
74713     } catch (std::exception& e) {
74714       {
74715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74716       };
74717     } catch (...) {
74718       {
74719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74720       };
74721     }
74722   }
74723   jresult = (void *)result;
74724   return jresult;
74725 }
74726
74727
74728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
74729   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
74730
74731   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
74732   {
74733     try {
74734       delete arg1;
74735     } catch (std::out_of_range& e) {
74736       {
74737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74738       };
74739     } catch (std::exception& e) {
74740       {
74741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74742       };
74743     } catch (...) {
74744       {
74745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74746       };
74747     }
74748   }
74749 }
74750
74751
74752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
74753   int jresult ;
74754   int result;
74755
74756   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
74757   jresult = (int)result;
74758   return jresult;
74759 }
74760
74761
74762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
74763   int jresult ;
74764   int result;
74765
74766   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
74767   jresult = (int)result;
74768   return jresult;
74769 }
74770
74771
74772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
74773   int jresult ;
74774   int result;
74775
74776   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
74777   jresult = (int)result;
74778   return jresult;
74779 }
74780
74781
74782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
74783   int jresult ;
74784   int result;
74785
74786   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
74787   jresult = (int)result;
74788   return jresult;
74789 }
74790
74791
74792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
74793   int jresult ;
74794   int result;
74795
74796   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
74797   jresult = (int)result;
74798   return jresult;
74799 }
74800
74801
74802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
74803   void * jresult ;
74804   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
74805
74806   {
74807     try {
74808       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
74809     } catch (std::out_of_range& e) {
74810       {
74811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74812       };
74813     } catch (std::exception& e) {
74814       {
74815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74816       };
74817     } catch (...) {
74818       {
74819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74820       };
74821     }
74822   }
74823   jresult = (void *)result;
74824   return jresult;
74825 }
74826
74827
74828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
74829   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
74830
74831   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
74832   {
74833     try {
74834       delete arg1;
74835     } catch (std::out_of_range& e) {
74836       {
74837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74838       };
74839     } catch (std::exception& e) {
74840       {
74841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74842       };
74843     } catch (...) {
74844       {
74845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74846       };
74847     }
74848   }
74849 }
74850
74851
74852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
74853   void * jresult ;
74854   unsigned int arg1 ;
74855   unsigned int arg2 ;
74856   unsigned int arg3 ;
74857   unsigned int arg4 ;
74858   Dali::Toolkit::TableView::CellPosition *result = 0 ;
74859
74860   arg1 = (unsigned int)jarg1;
74861   arg2 = (unsigned int)jarg2;
74862   arg3 = (unsigned int)jarg3;
74863   arg4 = (unsigned int)jarg4;
74864   {
74865     try {
74866       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
74867     } catch (std::out_of_range& e) {
74868       {
74869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74870       };
74871     } catch (std::exception& e) {
74872       {
74873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74874       };
74875     } catch (...) {
74876       {
74877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74878       };
74879     }
74880   }
74881   jresult = (void *)result;
74882   return jresult;
74883 }
74884
74885
74886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
74887   void * jresult ;
74888   unsigned int arg1 ;
74889   unsigned int arg2 ;
74890   unsigned int arg3 ;
74891   Dali::Toolkit::TableView::CellPosition *result = 0 ;
74892
74893   arg1 = (unsigned int)jarg1;
74894   arg2 = (unsigned int)jarg2;
74895   arg3 = (unsigned int)jarg3;
74896   {
74897     try {
74898       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
74899     } catch (std::out_of_range& e) {
74900       {
74901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74902       };
74903     } catch (std::exception& e) {
74904       {
74905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74906       };
74907     } catch (...) {
74908       {
74909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74910       };
74911     }
74912   }
74913   jresult = (void *)result;
74914   return jresult;
74915 }
74916
74917
74918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
74919   void * jresult ;
74920   unsigned int arg1 ;
74921   unsigned int arg2 ;
74922   Dali::Toolkit::TableView::CellPosition *result = 0 ;
74923
74924   arg1 = (unsigned int)jarg1;
74925   arg2 = (unsigned int)jarg2;
74926   {
74927     try {
74928       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
74929     } catch (std::out_of_range& e) {
74930       {
74931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74932       };
74933     } catch (std::exception& e) {
74934       {
74935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74936       };
74937     } catch (...) {
74938       {
74939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74940       };
74941     }
74942   }
74943   jresult = (void *)result;
74944   return jresult;
74945 }
74946
74947
74948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
74949   void * jresult ;
74950   unsigned int arg1 ;
74951   Dali::Toolkit::TableView::CellPosition *result = 0 ;
74952
74953   arg1 = (unsigned int)jarg1;
74954   {
74955     try {
74956       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
74957     } catch (std::out_of_range& e) {
74958       {
74959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74960       };
74961     } catch (std::exception& e) {
74962       {
74963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74964       };
74965     } catch (...) {
74966       {
74967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74968       };
74969     }
74970   }
74971   jresult = (void *)result;
74972   return jresult;
74973 }
74974
74975
74976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
74977   void * jresult ;
74978   Dali::Toolkit::TableView::CellPosition *result = 0 ;
74979
74980   {
74981     try {
74982       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
74983     } catch (std::out_of_range& e) {
74984       {
74985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74986       };
74987     } catch (std::exception& e) {
74988       {
74989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74990       };
74991     } catch (...) {
74992       {
74993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74994       };
74995     }
74996   }
74997   jresult = (void *)result;
74998   return jresult;
74999 }
75000
75001
75002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
75003   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75004   unsigned int arg2 ;
75005
75006   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75007   arg2 = (unsigned int)jarg2;
75008   if (arg1) (arg1)->rowIndex = arg2;
75009 }
75010
75011
75012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
75013   unsigned int jresult ;
75014   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75015   unsigned int result;
75016
75017   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75018   result = (unsigned int) ((arg1)->rowIndex);
75019   jresult = result;
75020   return jresult;
75021 }
75022
75023
75024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
75025   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75026   unsigned int arg2 ;
75027
75028   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75029   arg2 = (unsigned int)jarg2;
75030   if (arg1) (arg1)->columnIndex = arg2;
75031 }
75032
75033
75034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
75035   unsigned int jresult ;
75036   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75037   unsigned int result;
75038
75039   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75040   result = (unsigned int) ((arg1)->columnIndex);
75041   jresult = result;
75042   return jresult;
75043 }
75044
75045
75046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
75047   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75048   unsigned int arg2 ;
75049
75050   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75051   arg2 = (unsigned int)jarg2;
75052   if (arg1) (arg1)->rowSpan = arg2;
75053 }
75054
75055
75056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
75057   unsigned int jresult ;
75058   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75059   unsigned int result;
75060
75061   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75062   result = (unsigned int) ((arg1)->rowSpan);
75063   jresult = result;
75064   return jresult;
75065 }
75066
75067
75068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
75069   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75070   unsigned int arg2 ;
75071
75072   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75073   arg2 = (unsigned int)jarg2;
75074   if (arg1) (arg1)->columnSpan = arg2;
75075 }
75076
75077
75078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
75079   unsigned int jresult ;
75080   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75081   unsigned int result;
75082
75083   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75084   result = (unsigned int) ((arg1)->columnSpan);
75085   jresult = result;
75086   return jresult;
75087 }
75088
75089
75090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
75091   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75092
75093   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75094   {
75095     try {
75096       delete arg1;
75097     } catch (std::out_of_range& e) {
75098       {
75099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75100       };
75101     } catch (std::exception& e) {
75102       {
75103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75104       };
75105     } catch (...) {
75106       {
75107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75108       };
75109     }
75110   }
75111 }
75112
75113
75114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
75115   void * jresult ;
75116   Dali::Toolkit::TableView *result = 0 ;
75117
75118   {
75119     try {
75120       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
75121     } catch (std::out_of_range& e) {
75122       {
75123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75124       };
75125     } catch (std::exception& e) {
75126       {
75127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75128       };
75129     } catch (...) {
75130       {
75131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75132       };
75133     }
75134   }
75135   jresult = (void *)result;
75136   return jresult;
75137 }
75138
75139
75140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
75141   void * jresult ;
75142   Dali::Toolkit::TableView *arg1 = 0 ;
75143   Dali::Toolkit::TableView *result = 0 ;
75144
75145   arg1 = (Dali::Toolkit::TableView *)jarg1;
75146   if (!arg1) {
75147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75148     return 0;
75149   }
75150   {
75151     try {
75152       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
75153     } catch (std::out_of_range& e) {
75154       {
75155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75156       };
75157     } catch (std::exception& e) {
75158       {
75159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75160       };
75161     } catch (...) {
75162       {
75163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75164       };
75165     }
75166   }
75167   jresult = (void *)result;
75168   return jresult;
75169 }
75170
75171
75172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
75173   void * jresult ;
75174   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75175   Dali::Toolkit::TableView *arg2 = 0 ;
75176   Dali::Toolkit::TableView *result = 0 ;
75177
75178   arg1 = (Dali::Toolkit::TableView *)jarg1;
75179   arg2 = (Dali::Toolkit::TableView *)jarg2;
75180   if (!arg2) {
75181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75182     return 0;
75183   }
75184   {
75185     try {
75186       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
75187     } catch (std::out_of_range& e) {
75188       {
75189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75190       };
75191     } catch (std::exception& e) {
75192       {
75193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75194       };
75195     } catch (...) {
75196       {
75197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75198       };
75199     }
75200   }
75201   jresult = (void *)result;
75202   return jresult;
75203 }
75204
75205
75206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
75207   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75208
75209   arg1 = (Dali::Toolkit::TableView *)jarg1;
75210   {
75211     try {
75212       delete arg1;
75213     } catch (std::out_of_range& e) {
75214       {
75215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75216       };
75217     } catch (std::exception& e) {
75218       {
75219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75220       };
75221     } catch (...) {
75222       {
75223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75224       };
75225     }
75226   }
75227 }
75228
75229
75230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
75231   void * jresult ;
75232   unsigned int arg1 ;
75233   unsigned int arg2 ;
75234   Dali::Toolkit::TableView result;
75235
75236   arg1 = (unsigned int)jarg1;
75237   arg2 = (unsigned int)jarg2;
75238   {
75239     try {
75240       result = Dali::Toolkit::TableView::New(arg1,arg2);
75241     } catch (std::out_of_range& e) {
75242       {
75243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75244       };
75245     } catch (std::exception& e) {
75246       {
75247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75248       };
75249     } catch (...) {
75250       {
75251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75252       };
75253     }
75254   }
75255   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75256   return jresult;
75257 }
75258
75259
75260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
75261   void * jresult ;
75262   Dali::BaseHandle arg1 ;
75263   Dali::BaseHandle *argp1 ;
75264   Dali::Toolkit::TableView result;
75265
75266   argp1 = (Dali::BaseHandle *)jarg1;
75267   if (!argp1) {
75268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75269     return 0;
75270   }
75271   arg1 = *argp1;
75272   {
75273     try {
75274       result = Dali::Toolkit::TableView::DownCast(arg1);
75275     } catch (std::out_of_range& e) {
75276       {
75277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75278       };
75279     } catch (std::exception& e) {
75280       {
75281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75282       };
75283     } catch (...) {
75284       {
75285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75286       };
75287     }
75288   }
75289   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75290   return jresult;
75291 }
75292
75293
75294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
75295   unsigned int jresult ;
75296   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75297   Dali::Actor arg2 ;
75298   Dali::Toolkit::TableView::CellPosition arg3 ;
75299   Dali::Actor *argp2 ;
75300   Dali::Toolkit::TableView::CellPosition *argp3 ;
75301   bool result;
75302
75303   arg1 = (Dali::Toolkit::TableView *)jarg1;
75304   argp2 = (Dali::Actor *)jarg2;
75305   if (!argp2) {
75306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75307     return 0;
75308   }
75309   arg2 = *argp2;
75310   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75311   if (!argp3) {
75312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75313     return 0;
75314   }
75315   arg3 = *argp3;
75316   {
75317     try {
75318       result = (bool)(arg1)->AddChild(arg2,arg3);
75319     } catch (std::out_of_range& e) {
75320       {
75321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75322       };
75323     } catch (std::exception& e) {
75324       {
75325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75326       };
75327     } catch (...) {
75328       {
75329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75330       };
75331     }
75332   }
75333   jresult = result;
75334   return jresult;
75335 }
75336
75337
75338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
75339   void * jresult ;
75340   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75341   Dali::Toolkit::TableView::CellPosition arg2 ;
75342   Dali::Toolkit::TableView::CellPosition *argp2 ;
75343   Dali::Actor result;
75344
75345   arg1 = (Dali::Toolkit::TableView *)jarg1;
75346   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75347   if (!argp2) {
75348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75349     return 0;
75350   }
75351   arg2 = *argp2;
75352   {
75353     try {
75354       result = (arg1)->GetChildAt(arg2);
75355     } catch (std::out_of_range& e) {
75356       {
75357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75358       };
75359     } catch (std::exception& e) {
75360       {
75361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75362       };
75363     } catch (...) {
75364       {
75365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75366       };
75367     }
75368   }
75369   jresult = new Dali::Actor((const Dali::Actor &)result);
75370   return jresult;
75371 }
75372
75373
75374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
75375   void * jresult ;
75376   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75377   Dali::Toolkit::TableView::CellPosition arg2 ;
75378   Dali::Toolkit::TableView::CellPosition *argp2 ;
75379   Dali::Actor result;
75380
75381   arg1 = (Dali::Toolkit::TableView *)jarg1;
75382   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75383   if (!argp2) {
75384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75385     return 0;
75386   }
75387   arg2 = *argp2;
75388   {
75389     try {
75390       result = (arg1)->RemoveChildAt(arg2);
75391     } catch (std::out_of_range& e) {
75392       {
75393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75394       };
75395     } catch (std::exception& e) {
75396       {
75397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75398       };
75399     } catch (...) {
75400       {
75401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75402       };
75403     }
75404   }
75405   jresult = new Dali::Actor((const Dali::Actor &)result);
75406   return jresult;
75407 }
75408
75409
75410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
75411   unsigned int jresult ;
75412   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75413   Dali::Actor arg2 ;
75414   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
75415   Dali::Actor *argp2 ;
75416   bool result;
75417
75418   arg1 = (Dali::Toolkit::TableView *)jarg1;
75419   argp2 = (Dali::Actor *)jarg2;
75420   if (!argp2) {
75421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75422     return 0;
75423   }
75424   arg2 = *argp2;
75425   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75426   if (!arg3) {
75427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
75428     return 0;
75429   }
75430   {
75431     try {
75432       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
75433     } catch (std::out_of_range& e) {
75434       {
75435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75436       };
75437     } catch (std::exception& e) {
75438       {
75439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75440       };
75441     } catch (...) {
75442       {
75443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75444       };
75445     }
75446   }
75447   jresult = result;
75448   return jresult;
75449 }
75450
75451
75452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
75453   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75454   unsigned int arg2 ;
75455
75456   arg1 = (Dali::Toolkit::TableView *)jarg1;
75457   arg2 = (unsigned int)jarg2;
75458   {
75459     try {
75460       (arg1)->InsertRow(arg2);
75461     } catch (std::out_of_range& e) {
75462       {
75463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75464       };
75465     } catch (std::exception& e) {
75466       {
75467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75468       };
75469     } catch (...) {
75470       {
75471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75472       };
75473     }
75474   }
75475 }
75476
75477
75478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
75479   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75480   unsigned int arg2 ;
75481
75482   arg1 = (Dali::Toolkit::TableView *)jarg1;
75483   arg2 = (unsigned int)jarg2;
75484   {
75485     try {
75486       (arg1)->DeleteRow(arg2);
75487     } catch (std::out_of_range& e) {
75488       {
75489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75490       };
75491     } catch (std::exception& e) {
75492       {
75493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75494       };
75495     } catch (...) {
75496       {
75497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75498       };
75499     }
75500   }
75501 }
75502
75503
75504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75505   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75506   unsigned int arg2 ;
75507   std::vector< Dali::Actor > *arg3 = 0 ;
75508
75509   arg1 = (Dali::Toolkit::TableView *)jarg1;
75510   arg2 = (unsigned int)jarg2;
75511   arg3 = (std::vector< Dali::Actor > *)jarg3;
75512   if (!arg3) {
75513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75514     return ;
75515   }
75516   {
75517     try {
75518       (arg1)->DeleteRow(arg2,*arg3);
75519     } catch (std::out_of_range& e) {
75520       {
75521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75522       };
75523     } catch (std::exception& e) {
75524       {
75525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75526       };
75527     } catch (...) {
75528       {
75529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75530       };
75531     }
75532   }
75533 }
75534
75535
75536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
75537   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75538   unsigned int arg2 ;
75539
75540   arg1 = (Dali::Toolkit::TableView *)jarg1;
75541   arg2 = (unsigned int)jarg2;
75542   {
75543     try {
75544       (arg1)->InsertColumn(arg2);
75545     } catch (std::out_of_range& e) {
75546       {
75547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75548       };
75549     } catch (std::exception& e) {
75550       {
75551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75552       };
75553     } catch (...) {
75554       {
75555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75556       };
75557     }
75558   }
75559 }
75560
75561
75562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
75563   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75564   unsigned int arg2 ;
75565
75566   arg1 = (Dali::Toolkit::TableView *)jarg1;
75567   arg2 = (unsigned int)jarg2;
75568   {
75569     try {
75570       (arg1)->DeleteColumn(arg2);
75571     } catch (std::out_of_range& e) {
75572       {
75573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75574       };
75575     } catch (std::exception& e) {
75576       {
75577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75578       };
75579     } catch (...) {
75580       {
75581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75582       };
75583     }
75584   }
75585 }
75586
75587
75588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75589   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75590   unsigned int arg2 ;
75591   std::vector< Dali::Actor > *arg3 = 0 ;
75592
75593   arg1 = (Dali::Toolkit::TableView *)jarg1;
75594   arg2 = (unsigned int)jarg2;
75595   arg3 = (std::vector< Dali::Actor > *)jarg3;
75596   if (!arg3) {
75597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75598     return ;
75599   }
75600   {
75601     try {
75602       (arg1)->DeleteColumn(arg2,*arg3);
75603     } catch (std::out_of_range& e) {
75604       {
75605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75606       };
75607     } catch (std::exception& e) {
75608       {
75609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75610       };
75611     } catch (...) {
75612       {
75613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75614       };
75615     }
75616   }
75617 }
75618
75619
75620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
75621   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75622   unsigned int arg2 ;
75623   unsigned int arg3 ;
75624
75625   arg1 = (Dali::Toolkit::TableView *)jarg1;
75626   arg2 = (unsigned int)jarg2;
75627   arg3 = (unsigned int)jarg3;
75628   {
75629     try {
75630       (arg1)->Resize(arg2,arg3);
75631     } catch (std::out_of_range& e) {
75632       {
75633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75634       };
75635     } catch (std::exception& e) {
75636       {
75637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75638       };
75639     } catch (...) {
75640       {
75641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75642       };
75643     }
75644   }
75645 }
75646
75647
75648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
75649   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75650   unsigned int arg2 ;
75651   unsigned int arg3 ;
75652   std::vector< Dali::Actor > *arg4 = 0 ;
75653
75654   arg1 = (Dali::Toolkit::TableView *)jarg1;
75655   arg2 = (unsigned int)jarg2;
75656   arg3 = (unsigned int)jarg3;
75657   arg4 = (std::vector< Dali::Actor > *)jarg4;
75658   if (!arg4) {
75659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75660     return ;
75661   }
75662   {
75663     try {
75664       (arg1)->Resize(arg2,arg3,*arg4);
75665     } catch (std::out_of_range& e) {
75666       {
75667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75668       };
75669     } catch (std::exception& e) {
75670       {
75671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75672       };
75673     } catch (...) {
75674       {
75675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75676       };
75677     }
75678   }
75679 }
75680
75681
75682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
75683   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75684   Dali::Size arg2 ;
75685   Dali::Size *argp2 ;
75686
75687   arg1 = (Dali::Toolkit::TableView *)jarg1;
75688   argp2 = (Dali::Size *)jarg2;
75689   if (!argp2) {
75690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
75691     return ;
75692   }
75693   arg2 = *argp2;
75694   {
75695     try {
75696       (arg1)->SetCellPadding(arg2);
75697     } catch (std::out_of_range& e) {
75698       {
75699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75700       };
75701     } catch (std::exception& e) {
75702       {
75703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75704       };
75705     } catch (...) {
75706       {
75707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75708       };
75709     }
75710   }
75711 }
75712
75713
75714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
75715   void * jresult ;
75716   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75717   Dali::Size result;
75718
75719   arg1 = (Dali::Toolkit::TableView *)jarg1;
75720   {
75721     try {
75722       result = (arg1)->GetCellPadding();
75723     } catch (std::out_of_range& e) {
75724       {
75725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75726       };
75727     } catch (std::exception& e) {
75728       {
75729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75730       };
75731     } catch (...) {
75732       {
75733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75734       };
75735     }
75736   }
75737   jresult = new Dali::Size((const Dali::Size &)result);
75738   return jresult;
75739 }
75740
75741
75742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
75743   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75744   unsigned int arg2 ;
75745
75746   arg1 = (Dali::Toolkit::TableView *)jarg1;
75747   arg2 = (unsigned int)jarg2;
75748   {
75749     try {
75750       (arg1)->SetFitHeight(arg2);
75751     } catch (std::out_of_range& e) {
75752       {
75753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75754       };
75755     } catch (std::exception& e) {
75756       {
75757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75758       };
75759     } catch (...) {
75760       {
75761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75762       };
75763     }
75764   }
75765 }
75766
75767
75768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
75769   unsigned int jresult ;
75770   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75771   unsigned int arg2 ;
75772   bool result;
75773
75774   arg1 = (Dali::Toolkit::TableView *)jarg1;
75775   arg2 = (unsigned int)jarg2;
75776   {
75777     try {
75778       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
75779     } catch (std::out_of_range& e) {
75780       {
75781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75782       };
75783     } catch (std::exception& e) {
75784       {
75785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75786       };
75787     } catch (...) {
75788       {
75789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75790       };
75791     }
75792   }
75793   jresult = result;
75794   return jresult;
75795 }
75796
75797
75798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
75799   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75800   unsigned int arg2 ;
75801
75802   arg1 = (Dali::Toolkit::TableView *)jarg1;
75803   arg2 = (unsigned int)jarg2;
75804   {
75805     try {
75806       (arg1)->SetFitWidth(arg2);
75807     } catch (std::out_of_range& e) {
75808       {
75809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75810       };
75811     } catch (std::exception& e) {
75812       {
75813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75814       };
75815     } catch (...) {
75816       {
75817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75818       };
75819     }
75820   }
75821 }
75822
75823
75824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
75825   unsigned int jresult ;
75826   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75827   unsigned int arg2 ;
75828   bool result;
75829
75830   arg1 = (Dali::Toolkit::TableView *)jarg1;
75831   arg2 = (unsigned int)jarg2;
75832   {
75833     try {
75834       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
75835     } catch (std::out_of_range& e) {
75836       {
75837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75838       };
75839     } catch (std::exception& e) {
75840       {
75841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75842       };
75843     } catch (...) {
75844       {
75845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75846       };
75847     }
75848   }
75849   jresult = result;
75850   return jresult;
75851 }
75852
75853
75854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
75855   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75856   unsigned int arg2 ;
75857   float arg3 ;
75858
75859   arg1 = (Dali::Toolkit::TableView *)jarg1;
75860   arg2 = (unsigned int)jarg2;
75861   arg3 = (float)jarg3;
75862   {
75863     try {
75864       (arg1)->SetFixedHeight(arg2,arg3);
75865     } catch (std::out_of_range& e) {
75866       {
75867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75868       };
75869     } catch (std::exception& e) {
75870       {
75871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75872       };
75873     } catch (...) {
75874       {
75875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75876       };
75877     }
75878   }
75879 }
75880
75881
75882 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
75883   float jresult ;
75884   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75885   unsigned int arg2 ;
75886   float result;
75887
75888   arg1 = (Dali::Toolkit::TableView *)jarg1;
75889   arg2 = (unsigned int)jarg2;
75890   {
75891     try {
75892       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
75893     } catch (std::out_of_range& e) {
75894       {
75895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75896       };
75897     } catch (std::exception& e) {
75898       {
75899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75900       };
75901     } catch (...) {
75902       {
75903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75904       };
75905     }
75906   }
75907   jresult = result;
75908   return jresult;
75909 }
75910
75911
75912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
75913   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75914   unsigned int arg2 ;
75915   float arg3 ;
75916
75917   arg1 = (Dali::Toolkit::TableView *)jarg1;
75918   arg2 = (unsigned int)jarg2;
75919   arg3 = (float)jarg3;
75920   {
75921     try {
75922       (arg1)->SetRelativeHeight(arg2,arg3);
75923     } catch (std::out_of_range& e) {
75924       {
75925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75926       };
75927     } catch (std::exception& e) {
75928       {
75929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75930       };
75931     } catch (...) {
75932       {
75933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75934       };
75935     }
75936   }
75937 }
75938
75939
75940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
75941   float jresult ;
75942   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75943   unsigned int arg2 ;
75944   float result;
75945
75946   arg1 = (Dali::Toolkit::TableView *)jarg1;
75947   arg2 = (unsigned int)jarg2;
75948   {
75949     try {
75950       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
75951     } catch (std::out_of_range& e) {
75952       {
75953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75954       };
75955     } catch (std::exception& e) {
75956       {
75957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75958       };
75959     } catch (...) {
75960       {
75961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75962       };
75963     }
75964   }
75965   jresult = result;
75966   return jresult;
75967 }
75968
75969
75970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
75971   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75972   unsigned int arg2 ;
75973   float arg3 ;
75974
75975   arg1 = (Dali::Toolkit::TableView *)jarg1;
75976   arg2 = (unsigned int)jarg2;
75977   arg3 = (float)jarg3;
75978   {
75979     try {
75980       (arg1)->SetFixedWidth(arg2,arg3);
75981     } catch (std::out_of_range& e) {
75982       {
75983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75984       };
75985     } catch (std::exception& e) {
75986       {
75987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75988       };
75989     } catch (...) {
75990       {
75991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75992       };
75993     }
75994   }
75995 }
75996
75997
75998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
75999   float jresult ;
76000   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76001   unsigned int arg2 ;
76002   float result;
76003
76004   arg1 = (Dali::Toolkit::TableView *)jarg1;
76005   arg2 = (unsigned int)jarg2;
76006   {
76007     try {
76008       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
76009     } catch (std::out_of_range& e) {
76010       {
76011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76012       };
76013     } catch (std::exception& e) {
76014       {
76015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76016       };
76017     } catch (...) {
76018       {
76019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76020       };
76021     }
76022   }
76023   jresult = result;
76024   return jresult;
76025 }
76026
76027
76028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76029   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76030   unsigned int arg2 ;
76031   float arg3 ;
76032
76033   arg1 = (Dali::Toolkit::TableView *)jarg1;
76034   arg2 = (unsigned int)jarg2;
76035   arg3 = (float)jarg3;
76036   {
76037     try {
76038       (arg1)->SetRelativeWidth(arg2,arg3);
76039     } catch (std::out_of_range& e) {
76040       {
76041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76042       };
76043     } catch (std::exception& e) {
76044       {
76045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76046       };
76047     } catch (...) {
76048       {
76049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76050       };
76051     }
76052   }
76053 }
76054
76055
76056 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
76057   float jresult ;
76058   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76059   unsigned int arg2 ;
76060   float result;
76061
76062   arg1 = (Dali::Toolkit::TableView *)jarg1;
76063   arg2 = (unsigned int)jarg2;
76064   {
76065     try {
76066       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
76067     } catch (std::out_of_range& e) {
76068       {
76069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76070       };
76071     } catch (std::exception& e) {
76072       {
76073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76074       };
76075     } catch (...) {
76076       {
76077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76078       };
76079     }
76080   }
76081   jresult = result;
76082   return jresult;
76083 }
76084
76085
76086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
76087   unsigned int jresult ;
76088   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76089   unsigned int result;
76090
76091   arg1 = (Dali::Toolkit::TableView *)jarg1;
76092   {
76093     try {
76094       result = (unsigned int)(arg1)->GetRows();
76095     } catch (std::out_of_range& e) {
76096       {
76097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76098       };
76099     } catch (std::exception& e) {
76100       {
76101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76102       };
76103     } catch (...) {
76104       {
76105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76106       };
76107     }
76108   }
76109   jresult = result;
76110   return jresult;
76111 }
76112
76113
76114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
76115   unsigned int jresult ;
76116   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76117   unsigned int result;
76118
76119   arg1 = (Dali::Toolkit::TableView *)jarg1;
76120   {
76121     try {
76122       result = (unsigned int)(arg1)->GetColumns();
76123     } catch (std::out_of_range& e) {
76124       {
76125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76126       };
76127     } catch (std::exception& e) {
76128       {
76129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76130       };
76131     } catch (...) {
76132       {
76133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76134       };
76135     }
76136   }
76137   jresult = result;
76138   return jresult;
76139 }
76140
76141
76142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
76143   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76144   Dali::Toolkit::TableView::CellPosition arg2 ;
76145   Dali::HorizontalAlignment::Type arg3 ;
76146   Dali::VerticalAlignment::Type arg4 ;
76147   Dali::Toolkit::TableView::CellPosition *argp2 ;
76148
76149   arg1 = (Dali::Toolkit::TableView *)jarg1;
76150   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76151   if (!argp2) {
76152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76153     return ;
76154   }
76155   arg2 = *argp2;
76156   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
76157   arg4 = (Dali::VerticalAlignment::Type)jarg4;
76158   {
76159     try {
76160       (arg1)->SetCellAlignment(arg2,arg3,arg4);
76161     } catch (std::out_of_range& e) {
76162       {
76163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76164       };
76165     } catch (std::exception& e) {
76166       {
76167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76168       };
76169     } catch (...) {
76170       {
76171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76172       };
76173     }
76174   }
76175 }
76176
76177
76178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
76179   unsigned int jresult ;
76180   unsigned int result;
76181
76182   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
76183   jresult = result;
76184   return jresult;
76185 }
76186
76187
76188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
76189   int jresult ;
76190   int result;
76191
76192   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
76193   jresult = (int)result;
76194   return jresult;
76195 }
76196
76197
76198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
76199   int jresult ;
76200   int result;
76201
76202   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
76203   jresult = (int)result;
76204   return jresult;
76205 }
76206
76207
76208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
76209   int jresult ;
76210   int result;
76211
76212   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
76213   jresult = (int)result;
76214   return jresult;
76215 }
76216
76217
76218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
76219   int jresult ;
76220   int result;
76221
76222   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
76223   jresult = (int)result;
76224   return jresult;
76225 }
76226
76227
76228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
76229   int jresult ;
76230   int result;
76231
76232   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
76233   jresult = (int)result;
76234   return jresult;
76235 }
76236
76237
76238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
76239   int jresult ;
76240   int result;
76241
76242   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
76243   jresult = (int)result;
76244   return jresult;
76245 }
76246
76247
76248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
76249   int jresult ;
76250   int result;
76251
76252   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
76253   jresult = (int)result;
76254   return jresult;
76255 }
76256
76257
76258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
76259   int jresult ;
76260   int result;
76261
76262   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
76263   jresult = (int)result;
76264   return jresult;
76265 }
76266
76267
76268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
76269   int jresult ;
76270   int result;
76271
76272   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
76273   jresult = (int)result;
76274   return jresult;
76275 }
76276
76277
76278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
76279   int jresult ;
76280   int result;
76281
76282   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
76283   jresult = (int)result;
76284   return jresult;
76285 }
76286
76287
76288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
76289   int jresult ;
76290   int result;
76291
76292   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
76293   jresult = (int)result;
76294   return jresult;
76295 }
76296
76297
76298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
76299   int jresult ;
76300   int result;
76301
76302   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
76303   jresult = (int)result;
76304   return jresult;
76305 }
76306
76307
76308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
76309   int jresult ;
76310   int result;
76311
76312   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
76313   jresult = (int)result;
76314   return jresult;
76315 }
76316
76317
76318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
76319   int jresult ;
76320   int result;
76321
76322   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
76323   jresult = (int)result;
76324   return jresult;
76325 }
76326
76327
76328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
76329   int jresult ;
76330   int result;
76331
76332   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
76333   jresult = (int)result;
76334   return jresult;
76335 }
76336
76337
76338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
76339   int jresult ;
76340   int result;
76341
76342   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
76343   jresult = (int)result;
76344   return jresult;
76345 }
76346
76347
76348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
76349   int jresult ;
76350   int result;
76351
76352   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
76353   jresult = (int)result;
76354   return jresult;
76355 }
76356
76357
76358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
76359   int jresult ;
76360   int result;
76361
76362   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
76363   jresult = (int)result;
76364   return jresult;
76365 }
76366
76367
76368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
76369   int jresult ;
76370   int result;
76371
76372   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
76373   jresult = (int)result;
76374   return jresult;
76375 }
76376
76377
76378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
76379   int jresult ;
76380   int result;
76381
76382   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
76383   jresult = (int)result;
76384   return jresult;
76385 }
76386
76387
76388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
76389   int jresult ;
76390   int result;
76391
76392   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
76393   jresult = (int)result;
76394   return jresult;
76395 }
76396
76397
76398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
76399   int jresult ;
76400   int result;
76401
76402   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
76403   jresult = (int)result;
76404   return jresult;
76405 }
76406
76407
76408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
76409   int jresult ;
76410   int result;
76411
76412   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
76413   jresult = (int)result;
76414   return jresult;
76415 }
76416
76417
76418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
76419   int jresult ;
76420   int result;
76421
76422   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
76423   jresult = (int)result;
76424   return jresult;
76425 }
76426
76427
76428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
76429   int jresult ;
76430   int result;
76431
76432   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
76433   jresult = (int)result;
76434   return jresult;
76435 }
76436
76437
76438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
76439   int jresult ;
76440   int result;
76441
76442   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
76443   jresult = (int)result;
76444   return jresult;
76445 }
76446
76447
76448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
76449   int jresult ;
76450   int result;
76451
76452   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
76453   jresult = (int)result;
76454   return jresult;
76455 }
76456
76457
76458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
76459   int jresult ;
76460   int result;
76461
76462   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
76463   jresult = (int)result;
76464   return jresult;
76465 }
76466
76467
76468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
76469   int jresult ;
76470   int result;
76471
76472   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
76473   jresult = (int)result;
76474   return jresult;
76475 }
76476
76477
76478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
76479   int jresult ;
76480   int result;
76481
76482   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
76483   jresult = (int)result;
76484   return jresult;
76485 }
76486
76487
76488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
76489   int jresult ;
76490   int result;
76491
76492   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
76493   jresult = (int)result;
76494   return jresult;
76495 }
76496
76497
76498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
76499   int jresult ;
76500   int result;
76501
76502   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
76503   jresult = (int)result;
76504   return jresult;
76505 }
76506
76507
76508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
76509   int jresult ;
76510   int result;
76511
76512   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
76513   jresult = (int)result;
76514   return jresult;
76515 }
76516
76517
76518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
76519   int jresult ;
76520   int result;
76521
76522   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
76523   jresult = (int)result;
76524   return jresult;
76525 }
76526
76527
76528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
76529   int jresult ;
76530   int result;
76531
76532   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
76533   jresult = (int)result;
76534   return jresult;
76535 }
76536
76537
76538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
76539   int jresult ;
76540   int result;
76541
76542   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
76543   jresult = (int)result;
76544   return jresult;
76545 }
76546
76547
76548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
76549   int jresult ;
76550   int result;
76551
76552   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
76553   jresult = (int)result;
76554   return jresult;
76555 }
76556
76557
76558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
76559   int jresult ;
76560   int result;
76561
76562   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
76563   jresult = (int)result;
76564   return jresult;
76565 }
76566
76567
76568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
76569   int jresult ;
76570   int result;
76571
76572   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
76573   jresult = (int)result;
76574   return jresult;
76575 }
76576
76577
76578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
76579   int jresult ;
76580   int result;
76581
76582   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
76583   jresult = (int)result;
76584   return jresult;
76585 }
76586
76587
76588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
76589   void * jresult ;
76590   Dali::Toolkit::TextEditor::Property *result = 0 ;
76591
76592   {
76593     try {
76594       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
76595     } catch (std::out_of_range& e) {
76596       {
76597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76598       };
76599     } catch (std::exception& e) {
76600       {
76601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76602       };
76603     } catch (...) {
76604       {
76605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76606       };
76607     }
76608   }
76609   jresult = (void *)result;
76610   return jresult;
76611 }
76612
76613
76614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
76615   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
76616
76617   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
76618   {
76619     try {
76620       delete arg1;
76621     } catch (std::out_of_range& e) {
76622       {
76623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76624       };
76625     } catch (std::exception& e) {
76626       {
76627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76628       };
76629     } catch (...) {
76630       {
76631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76632       };
76633     }
76634   }
76635 }
76636
76637
76638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
76639   void * jresult ;
76640   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
76641
76642   {
76643     try {
76644       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
76645     } catch (std::out_of_range& e) {
76646       {
76647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76648       };
76649     } catch (std::exception& e) {
76650       {
76651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76652       };
76653     } catch (...) {
76654       {
76655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76656       };
76657     }
76658   }
76659   jresult = (void *)result;
76660   return jresult;
76661 }
76662
76663
76664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
76665   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
76666
76667   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
76668   {
76669     try {
76670       delete arg1;
76671     } catch (std::out_of_range& e) {
76672       {
76673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76674       };
76675     } catch (std::exception& e) {
76676       {
76677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76678       };
76679     } catch (...) {
76680       {
76681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76682       };
76683     }
76684   }
76685 }
76686
76687
76688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
76689   void * jresult ;
76690   Dali::Toolkit::TextEditor result;
76691
76692   {
76693     try {
76694       result = Dali::Toolkit::TextEditor::New();
76695     } catch (std::out_of_range& e) {
76696       {
76697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76698       };
76699     } catch (std::exception& e) {
76700       {
76701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76702       };
76703     } catch (...) {
76704       {
76705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76706       };
76707     }
76708   }
76709   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
76710   return jresult;
76711 }
76712
76713
76714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
76715   void * jresult ;
76716   Dali::Toolkit::TextEditor *result = 0 ;
76717
76718   {
76719     try {
76720       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
76721     } catch (std::out_of_range& e) {
76722       {
76723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76724       };
76725     } catch (std::exception& e) {
76726       {
76727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76728       };
76729     } catch (...) {
76730       {
76731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76732       };
76733     }
76734   }
76735   jresult = (void *)result;
76736   return jresult;
76737 }
76738
76739
76740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
76741   void * jresult ;
76742   Dali::Toolkit::TextEditor *arg1 = 0 ;
76743   Dali::Toolkit::TextEditor *result = 0 ;
76744
76745   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
76746   if (!arg1) {
76747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
76748     return 0;
76749   }
76750   {
76751     try {
76752       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
76753     } catch (std::out_of_range& e) {
76754       {
76755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76756       };
76757     } catch (std::exception& e) {
76758       {
76759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76760       };
76761     } catch (...) {
76762       {
76763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76764       };
76765     }
76766   }
76767   jresult = (void *)result;
76768   return jresult;
76769 }
76770
76771
76772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
76773   void * jresult ;
76774   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
76775   Dali::Toolkit::TextEditor *arg2 = 0 ;
76776   Dali::Toolkit::TextEditor *result = 0 ;
76777
76778   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
76779   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
76780   if (!arg2) {
76781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
76782     return 0;
76783   }
76784   {
76785     try {
76786       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
76787     } catch (std::out_of_range& e) {
76788       {
76789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76790       };
76791     } catch (std::exception& e) {
76792       {
76793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76794       };
76795     } catch (...) {
76796       {
76797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76798       };
76799     }
76800   }
76801   jresult = (void *)result;
76802   return jresult;
76803 }
76804
76805
76806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
76807   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
76808
76809   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
76810   {
76811     try {
76812       delete arg1;
76813     } catch (std::out_of_range& e) {
76814       {
76815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76816       };
76817     } catch (std::exception& e) {
76818       {
76819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76820       };
76821     } catch (...) {
76822       {
76823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76824       };
76825     }
76826   }
76827 }
76828
76829
76830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
76831   void * jresult ;
76832   Dali::BaseHandle arg1 ;
76833   Dali::BaseHandle *argp1 ;
76834   Dali::Toolkit::TextEditor result;
76835
76836   argp1 = (Dali::BaseHandle *)jarg1;
76837   if (!argp1) {
76838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76839     return 0;
76840   }
76841   arg1 = *argp1;
76842   {
76843     try {
76844       result = Dali::Toolkit::TextEditor::DownCast(arg1);
76845     } catch (std::out_of_range& e) {
76846       {
76847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76848       };
76849     } catch (std::exception& e) {
76850       {
76851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76852       };
76853     } catch (...) {
76854       {
76855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76856       };
76857     }
76858   }
76859   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
76860   return jresult;
76861 }
76862
76863
76864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
76865   void * jresult ;
76866   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
76867   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
76868
76869   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
76870   {
76871     try {
76872       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
76873     } catch (std::out_of_range& e) {
76874       {
76875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76876       };
76877     } catch (std::exception& e) {
76878       {
76879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76880       };
76881     } catch (...) {
76882       {
76883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76884       };
76885     }
76886   }
76887   jresult = (void *)result;
76888   return jresult;
76889 }
76890
76891
76892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
76893   void * jresult ;
76894   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
76895   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
76896
76897   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
76898   {
76899     try {
76900       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
76901     } catch (std::out_of_range& e) {
76902       {
76903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76904       };
76905     } catch (std::exception& e) {
76906       {
76907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76908       };
76909     } catch (...) {
76910       {
76911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76912       };
76913     }
76914   }
76915   jresult = (void *)result;
76916   return jresult;
76917 }
76918
76919
76920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
76921   int jresult ;
76922   int result;
76923
76924   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
76925   jresult = (int)result;
76926   return jresult;
76927 }
76928
76929
76930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
76931   int jresult ;
76932   int result;
76933
76934   result = (int)Dali::Toolkit::TextField::Property::TEXT;
76935   jresult = (int)result;
76936   return jresult;
76937 }
76938
76939
76940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
76941   int jresult ;
76942   int result;
76943
76944   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
76945   jresult = (int)result;
76946   return jresult;
76947 }
76948
76949
76950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
76951   int jresult ;
76952   int result;
76953
76954   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
76955   jresult = (int)result;
76956   return jresult;
76957 }
76958
76959
76960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
76961   int jresult ;
76962   int result;
76963
76964   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
76965   jresult = (int)result;
76966   return jresult;
76967 }
76968
76969
76970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
76971   int jresult ;
76972   int result;
76973
76974   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
76975   jresult = (int)result;
76976   return jresult;
76977 }
76978
76979
76980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
76981   int jresult ;
76982   int result;
76983
76984   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
76985   jresult = (int)result;
76986   return jresult;
76987 }
76988
76989
76990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
76991   int jresult ;
76992   int result;
76993
76994   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
76995   jresult = (int)result;
76996   return jresult;
76997 }
76998
76999
77000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
77001   int jresult ;
77002   int result;
77003
77004   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
77005   jresult = (int)result;
77006   return jresult;
77007 }
77008
77009
77010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
77011   int jresult ;
77012   int result;
77013
77014   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
77015   jresult = (int)result;
77016   return jresult;
77017 }
77018
77019
77020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
77021   int jresult ;
77022   int result;
77023
77024   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
77025   jresult = (int)result;
77026   return jresult;
77027 }
77028
77029
77030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
77031   int jresult ;
77032   int result;
77033
77034   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
77035   jresult = (int)result;
77036   return jresult;
77037 }
77038
77039
77040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
77041   int jresult ;
77042   int result;
77043
77044   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
77045   jresult = (int)result;
77046   return jresult;
77047 }
77048
77049
77050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
77051   int jresult ;
77052   int result;
77053
77054   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
77055   jresult = (int)result;
77056   return jresult;
77057 }
77058
77059
77060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
77061   int jresult ;
77062   int result;
77063
77064   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
77065   jresult = (int)result;
77066   return jresult;
77067 }
77068
77069
77070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
77071   int jresult ;
77072   int result;
77073
77074   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
77075   jresult = (int)result;
77076   return jresult;
77077 }
77078
77079
77080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
77081   int jresult ;
77082   int result;
77083
77084   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
77085   jresult = (int)result;
77086   return jresult;
77087 }
77088
77089
77090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
77091   int jresult ;
77092   int result;
77093
77094   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
77095   jresult = (int)result;
77096   return jresult;
77097 }
77098
77099
77100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
77101   int jresult ;
77102   int result;
77103
77104   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
77105   jresult = (int)result;
77106   return jresult;
77107 }
77108
77109
77110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
77111   int jresult ;
77112   int result;
77113
77114   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
77115   jresult = (int)result;
77116   return jresult;
77117 }
77118
77119
77120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
77121   int jresult ;
77122   int result;
77123
77124   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
77125   jresult = (int)result;
77126   return jresult;
77127 }
77128
77129
77130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
77131   int jresult ;
77132   int result;
77133
77134   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
77135   jresult = (int)result;
77136   return jresult;
77137 }
77138
77139
77140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77141   int jresult ;
77142   int result;
77143
77144   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
77145   jresult = (int)result;
77146   return jresult;
77147 }
77148
77149
77150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
77151   int jresult ;
77152   int result;
77153
77154   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
77155   jresult = (int)result;
77156   return jresult;
77157 }
77158
77159
77160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
77161   int jresult ;
77162   int result;
77163
77164   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
77165   jresult = (int)result;
77166   return jresult;
77167 }
77168
77169
77170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77171   int jresult ;
77172   int result;
77173
77174   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
77175   jresult = (int)result;
77176   return jresult;
77177 }
77178
77179
77180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77181   int jresult ;
77182   int result;
77183
77184   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77185   jresult = (int)result;
77186   return jresult;
77187 }
77188
77189
77190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77191   int jresult ;
77192   int result;
77193
77194   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77195   jresult = (int)result;
77196   return jresult;
77197 }
77198
77199
77200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77201   int jresult ;
77202   int result;
77203
77204   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77205   jresult = (int)result;
77206   return jresult;
77207 }
77208
77209
77210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77211   int jresult ;
77212   int result;
77213
77214   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77215   jresult = (int)result;
77216   return jresult;
77217 }
77218
77219
77220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77221   int jresult ;
77222   int result;
77223
77224   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77225   jresult = (int)result;
77226   return jresult;
77227 }
77228
77229
77230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77231   int jresult ;
77232   int result;
77233
77234   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
77235   jresult = (int)result;
77236   return jresult;
77237 }
77238
77239
77240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
77241   int jresult ;
77242   int result;
77243
77244   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
77245   jresult = (int)result;
77246   return jresult;
77247 }
77248
77249
77250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
77251   int jresult ;
77252   int result;
77253
77254   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
77255   jresult = (int)result;
77256   return jresult;
77257 }
77258
77259
77260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
77261   int jresult ;
77262   int result;
77263
77264   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
77265   jresult = (int)result;
77266   return jresult;
77267 }
77268
77269
77270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
77271   int jresult ;
77272   int result;
77273
77274   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
77275   jresult = (int)result;
77276   return jresult;
77277 }
77278
77279
77280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
77281   int jresult ;
77282   int result;
77283
77284   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
77285   jresult = (int)result;
77286   return jresult;
77287 }
77288
77289
77290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
77291   int jresult ;
77292   int result;
77293
77294   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
77295   jresult = (int)result;
77296   return jresult;
77297 }
77298
77299
77300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
77301   int jresult ;
77302   int result;
77303
77304   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
77305   jresult = (int)result;
77306   return jresult;
77307 }
77308
77309
77310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
77311   int jresult ;
77312   int result;
77313
77314   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
77315   jresult = (int)result;
77316   return jresult;
77317 }
77318
77319
77320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
77321   int jresult ;
77322   int result;
77323
77324   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
77325   jresult = (int)result;
77326   return jresult;
77327 }
77328
77329
77330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
77331   int jresult ;
77332   int result;
77333
77334   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
77335   jresult = (int)result;
77336   return jresult;
77337 }
77338
77339
77340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
77341   int jresult ;
77342   int result;
77343
77344   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
77345   jresult = (int)result;
77346   return jresult;
77347 }
77348
77349
77350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
77351   int jresult ;
77352   int result;
77353
77354   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
77355   jresult = (int)result;
77356   return jresult;
77357 }
77358
77359
77360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
77361   int jresult ;
77362   int result;
77363
77364   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
77365   jresult = (int)result;
77366   return jresult;
77367 }
77368
77369
77370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
77371   int jresult ;
77372   int result;
77373
77374   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
77375   jresult = (int)result;
77376   return jresult;
77377 }
77378
77379
77380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
77381   int jresult ;
77382   int result;
77383
77384   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
77385   jresult = (int)result;
77386   return jresult;
77387 }
77388
77389
77390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
77391   void * jresult ;
77392   Dali::Toolkit::TextField::Property *result = 0 ;
77393
77394   {
77395     try {
77396       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
77397     } catch (std::out_of_range& e) {
77398       {
77399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77400       };
77401     } catch (std::exception& e) {
77402       {
77403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77404       };
77405     } catch (...) {
77406       {
77407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77408       };
77409     }
77410   }
77411   jresult = (void *)result;
77412   return jresult;
77413 }
77414
77415
77416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
77417   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
77418
77419   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
77420   {
77421     try {
77422       delete arg1;
77423     } catch (std::out_of_range& e) {
77424       {
77425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77426       };
77427     } catch (std::exception& e) {
77428       {
77429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77430       };
77431     } catch (...) {
77432       {
77433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77434       };
77435     }
77436   }
77437 }
77438
77439
77440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
77441   void * jresult ;
77442   Dali::Toolkit::TextField::InputStyle *result = 0 ;
77443
77444   {
77445     try {
77446       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
77447     } catch (std::out_of_range& e) {
77448       {
77449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77450       };
77451     } catch (std::exception& e) {
77452       {
77453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77454       };
77455     } catch (...) {
77456       {
77457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77458       };
77459     }
77460   }
77461   jresult = (void *)result;
77462   return jresult;
77463 }
77464
77465
77466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
77467   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
77468
77469   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
77470   {
77471     try {
77472       delete arg1;
77473     } catch (std::out_of_range& e) {
77474       {
77475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77476       };
77477     } catch (std::exception& e) {
77478       {
77479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77480       };
77481     } catch (...) {
77482       {
77483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77484       };
77485     }
77486   }
77487 }
77488
77489
77490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
77491   void * jresult ;
77492   Dali::Toolkit::TextField result;
77493
77494   {
77495     try {
77496       result = Dali::Toolkit::TextField::New();
77497     } catch (std::out_of_range& e) {
77498       {
77499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77500       };
77501     } catch (std::exception& e) {
77502       {
77503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77504       };
77505     } catch (...) {
77506       {
77507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77508       };
77509     }
77510   }
77511   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
77512   return jresult;
77513 }
77514
77515
77516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
77517   void * jresult ;
77518   Dali::Toolkit::TextField *result = 0 ;
77519
77520   {
77521     try {
77522       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
77523     } catch (std::out_of_range& e) {
77524       {
77525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77526       };
77527     } catch (std::exception& e) {
77528       {
77529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77530       };
77531     } catch (...) {
77532       {
77533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77534       };
77535     }
77536   }
77537   jresult = (void *)result;
77538   return jresult;
77539 }
77540
77541
77542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
77543   void * jresult ;
77544   Dali::Toolkit::TextField *arg1 = 0 ;
77545   Dali::Toolkit::TextField *result = 0 ;
77546
77547   arg1 = (Dali::Toolkit::TextField *)jarg1;
77548   if (!arg1) {
77549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
77550     return 0;
77551   }
77552   {
77553     try {
77554       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
77555     } catch (std::out_of_range& e) {
77556       {
77557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77558       };
77559     } catch (std::exception& e) {
77560       {
77561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77562       };
77563     } catch (...) {
77564       {
77565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77566       };
77567     }
77568   }
77569   jresult = (void *)result;
77570   return jresult;
77571 }
77572
77573
77574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
77575   void * jresult ;
77576   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77577   Dali::Toolkit::TextField *arg2 = 0 ;
77578   Dali::Toolkit::TextField *result = 0 ;
77579
77580   arg1 = (Dali::Toolkit::TextField *)jarg1;
77581   arg2 = (Dali::Toolkit::TextField *)jarg2;
77582   if (!arg2) {
77583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
77584     return 0;
77585   }
77586   {
77587     try {
77588       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
77589     } catch (std::out_of_range& e) {
77590       {
77591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77592       };
77593     } catch (std::exception& e) {
77594       {
77595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77596       };
77597     } catch (...) {
77598       {
77599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77600       };
77601     }
77602   }
77603   jresult = (void *)result;
77604   return jresult;
77605 }
77606
77607
77608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
77609   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77610
77611   arg1 = (Dali::Toolkit::TextField *)jarg1;
77612   {
77613     try {
77614       delete arg1;
77615     } catch (std::out_of_range& e) {
77616       {
77617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77618       };
77619     } catch (std::exception& e) {
77620       {
77621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77622       };
77623     } catch (...) {
77624       {
77625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77626       };
77627     }
77628   }
77629 }
77630
77631
77632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
77633   void * jresult ;
77634   Dali::BaseHandle arg1 ;
77635   Dali::BaseHandle *argp1 ;
77636   Dali::Toolkit::TextField result;
77637
77638   argp1 = (Dali::BaseHandle *)jarg1;
77639   if (!argp1) {
77640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77641     return 0;
77642   }
77643   arg1 = *argp1;
77644   {
77645     try {
77646       result = Dali::Toolkit::TextField::DownCast(arg1);
77647     } catch (std::out_of_range& e) {
77648       {
77649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77650       };
77651     } catch (std::exception& e) {
77652       {
77653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77654       };
77655     } catch (...) {
77656       {
77657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77658       };
77659     }
77660   }
77661   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
77662   return jresult;
77663 }
77664
77665
77666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
77667   void * jresult ;
77668   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77669   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
77670
77671   arg1 = (Dali::Toolkit::TextField *)jarg1;
77672   {
77673     try {
77674       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
77675     } catch (std::out_of_range& e) {
77676       {
77677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77678       };
77679     } catch (std::exception& e) {
77680       {
77681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77682       };
77683     } catch (...) {
77684       {
77685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77686       };
77687     }
77688   }
77689   jresult = (void *)result;
77690   return jresult;
77691 }
77692
77693
77694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
77695   void * jresult ;
77696   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77697   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
77698
77699   arg1 = (Dali::Toolkit::TextField *)jarg1;
77700   {
77701     try {
77702       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
77703     } catch (std::out_of_range& e) {
77704       {
77705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77706       };
77707     } catch (std::exception& e) {
77708       {
77709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77710       };
77711     } catch (...) {
77712       {
77713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77714       };
77715     }
77716   }
77717   jresult = (void *)result;
77718   return jresult;
77719 }
77720
77721
77722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
77723   void * jresult ;
77724   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77725   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
77726
77727   arg1 = (Dali::Toolkit::TextField *)jarg1;
77728   {
77729     try {
77730       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
77731     } catch (std::out_of_range& e) {
77732       {
77733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77734       };
77735     } catch (std::exception& e) {
77736       {
77737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77738       };
77739     } catch (...) {
77740       {
77741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77742       };
77743     }
77744   }
77745   jresult = (void *)result;
77746   return jresult;
77747 }
77748
77749
77750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
77751   int jresult ;
77752   int result;
77753
77754   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
77755   jresult = (int)result;
77756   return jresult;
77757 }
77758
77759
77760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
77761   int jresult ;
77762   int result;
77763
77764   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
77765   jresult = (int)result;
77766   return jresult;
77767 }
77768
77769
77770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
77771   int jresult ;
77772   int result;
77773
77774   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
77775   jresult = (int)result;
77776   return jresult;
77777 }
77778
77779
77780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
77781   int jresult ;
77782   int result;
77783
77784   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
77785   jresult = (int)result;
77786   return jresult;
77787 }
77788
77789
77790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
77791   int jresult ;
77792   int result;
77793
77794   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
77795   jresult = (int)result;
77796   return jresult;
77797 }
77798
77799
77800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
77801   int jresult ;
77802   int result;
77803
77804   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
77805   jresult = (int)result;
77806   return jresult;
77807 }
77808
77809
77810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
77811   int jresult ;
77812   int result;
77813
77814   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
77815   jresult = (int)result;
77816   return jresult;
77817 }
77818
77819
77820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
77821   int jresult ;
77822   int result;
77823
77824   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
77825   jresult = (int)result;
77826   return jresult;
77827 }
77828
77829
77830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
77831   int jresult ;
77832   int result;
77833
77834   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
77835   jresult = (int)result;
77836   return jresult;
77837 }
77838
77839
77840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
77841   int jresult ;
77842   int result;
77843
77844   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
77845   jresult = (int)result;
77846   return jresult;
77847 }
77848
77849
77850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
77851   int jresult ;
77852   int result;
77853
77854   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
77855   jresult = (int)result;
77856   return jresult;
77857 }
77858
77859
77860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
77861   int jresult ;
77862   int result;
77863
77864   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
77865   jresult = (int)result;
77866   return jresult;
77867 }
77868
77869
77870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
77871   int jresult ;
77872   int result;
77873
77874   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
77875   jresult = (int)result;
77876   return jresult;
77877 }
77878
77879
77880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
77881   int jresult ;
77882   int result;
77883
77884   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
77885   jresult = (int)result;
77886   return jresult;
77887 }
77888
77889
77890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
77891   int jresult ;
77892   int result;
77893
77894   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
77895   jresult = (int)result;
77896   return jresult;
77897 }
77898
77899
77900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
77901   int jresult ;
77902   int result;
77903
77904   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
77905   jresult = (int)result;
77906   return jresult;
77907 }
77908
77909
77910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
77911   int jresult ;
77912   int result;
77913
77914   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
77915   jresult = (int)result;
77916   return jresult;
77917 }
77918
77919
77920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
77921   int jresult ;
77922   int result;
77923
77924   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
77925   jresult = (int)result;
77926   return jresult;
77927 }
77928
77929
77930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
77931   int jresult ;
77932   int result;
77933
77934   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
77935   jresult = (int)result;
77936   return jresult;
77937 }
77938
77939
77940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
77941   int jresult ;
77942   int result;
77943
77944   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
77945   jresult = (int)result;
77946   return jresult;
77947 }
77948
77949
77950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
77951   int jresult ;
77952   int result;
77953
77954   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
77955   jresult = (int)result;
77956   return jresult;
77957 }
77958
77959
77960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
77961   int jresult ;
77962   int result;
77963
77964   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
77965   jresult = (int)result;
77966   return jresult;
77967 }
77968
77969
77970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
77971   int jresult ;
77972   int result;
77973
77974   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
77975   jresult = (int)result;
77976   return jresult;
77977 }
77978
77979
77980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
77981   int jresult ;
77982   int result;
77983
77984   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
77985   jresult = (int)result;
77986   return jresult;
77987 }
77988
77989
77990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
77991   void * jresult ;
77992   Dali::Toolkit::TextLabel::Property *result = 0 ;
77993
77994   {
77995     try {
77996       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
77997     } catch (std::out_of_range& e) {
77998       {
77999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78000       };
78001     } catch (std::exception& e) {
78002       {
78003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78004       };
78005     } catch (...) {
78006       {
78007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78008       };
78009     }
78010   }
78011   jresult = (void *)result;
78012   return jresult;
78013 }
78014
78015
78016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78017   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78018
78019   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78020   {
78021     try {
78022       delete arg1;
78023     } catch (std::out_of_range& e) {
78024       {
78025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78026       };
78027     } catch (std::exception& e) {
78028       {
78029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78030       };
78031     } catch (...) {
78032       {
78033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78034       };
78035     }
78036   }
78037 }
78038
78039
78040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78041   void * jresult ;
78042   Dali::Toolkit::TextLabel result;
78043
78044   {
78045     try {
78046       result = Dali::Toolkit::TextLabel::New();
78047     } catch (std::out_of_range& e) {
78048       {
78049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78050       };
78051     } catch (std::exception& e) {
78052       {
78053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78054       };
78055     } catch (...) {
78056       {
78057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78058       };
78059     }
78060   }
78061   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78062   return jresult;
78063 }
78064
78065
78066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78067   void * jresult ;
78068   std::string *arg1 = 0 ;
78069   Dali::Toolkit::TextLabel result;
78070
78071   if (!jarg1) {
78072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78073     return 0;
78074   }
78075   std::string arg1_str(jarg1);
78076   arg1 = &arg1_str;
78077   {
78078     try {
78079       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78080     } catch (std::out_of_range& e) {
78081       {
78082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78083       };
78084     } catch (std::exception& e) {
78085       {
78086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78087       };
78088     } catch (...) {
78089       {
78090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78091       };
78092     }
78093   }
78094   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78095
78096   //argout typemap for const std::string&
78097
78098   return jresult;
78099 }
78100
78101
78102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78103   void * jresult ;
78104   Dali::Toolkit::TextLabel *result = 0 ;
78105
78106   {
78107     try {
78108       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78109     } catch (std::out_of_range& e) {
78110       {
78111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78112       };
78113     } catch (std::exception& e) {
78114       {
78115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78116       };
78117     } catch (...) {
78118       {
78119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78120       };
78121     }
78122   }
78123   jresult = (void *)result;
78124   return jresult;
78125 }
78126
78127
78128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78129   void * jresult ;
78130   Dali::Toolkit::TextLabel *arg1 = 0 ;
78131   Dali::Toolkit::TextLabel *result = 0 ;
78132
78133   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78134   if (!arg1) {
78135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78136     return 0;
78137   }
78138   {
78139     try {
78140       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78141     } catch (std::out_of_range& e) {
78142       {
78143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78144       };
78145     } catch (std::exception& e) {
78146       {
78147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78148       };
78149     } catch (...) {
78150       {
78151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78152       };
78153     }
78154   }
78155   jresult = (void *)result;
78156   return jresult;
78157 }
78158
78159
78160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78161   void * jresult ;
78162   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78163   Dali::Toolkit::TextLabel *arg2 = 0 ;
78164   Dali::Toolkit::TextLabel *result = 0 ;
78165
78166   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78167   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78168   if (!arg2) {
78169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78170     return 0;
78171   }
78172   {
78173     try {
78174       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78175     } catch (std::out_of_range& e) {
78176       {
78177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78178       };
78179     } catch (std::exception& e) {
78180       {
78181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78182       };
78183     } catch (...) {
78184       {
78185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78186       };
78187     }
78188   }
78189   jresult = (void *)result;
78190   return jresult;
78191 }
78192
78193
78194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78195   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78196
78197   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78198   {
78199     try {
78200       delete arg1;
78201     } catch (std::out_of_range& e) {
78202       {
78203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78204       };
78205     } catch (std::exception& e) {
78206       {
78207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78208       };
78209     } catch (...) {
78210       {
78211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78212       };
78213     }
78214   }
78215 }
78216
78217
78218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78219   void * jresult ;
78220   Dali::BaseHandle arg1 ;
78221   Dali::BaseHandle *argp1 ;
78222   Dali::Toolkit::TextLabel result;
78223
78224   argp1 = (Dali::BaseHandle *)jarg1;
78225   if (!argp1) {
78226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78227     return 0;
78228   }
78229   arg1 = *argp1;
78230   {
78231     try {
78232       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78233     } catch (std::out_of_range& e) {
78234       {
78235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78236       };
78237     } catch (std::exception& e) {
78238       {
78239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78240       };
78241     } catch (...) {
78242       {
78243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78244       };
78245     }
78246   }
78247   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78248   return jresult;
78249 }
78250
78251
78252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78253   void * jresult ;
78254   Dali::Toolkit::AccessibilityManager *result = 0 ;
78255
78256   {
78257     try {
78258       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78259     } catch (std::out_of_range& e) {
78260       {
78261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78262       };
78263     } catch (std::exception& e) {
78264       {
78265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78266       };
78267     } catch (...) {
78268       {
78269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78270       };
78271     }
78272   }
78273   jresult = (void *)result;
78274   return jresult;
78275 }
78276
78277
78278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78279   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78280
78281   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78282   {
78283     try {
78284       delete arg1;
78285     } catch (std::out_of_range& e) {
78286       {
78287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78288       };
78289     } catch (std::exception& e) {
78290       {
78291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78292       };
78293     } catch (...) {
78294       {
78295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78296       };
78297     }
78298   }
78299 }
78300
78301
78302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78303   void * jresult ;
78304   Dali::Toolkit::AccessibilityManager result;
78305
78306   {
78307     try {
78308       result = Dali::Toolkit::AccessibilityManager::Get();
78309     } catch (std::out_of_range& e) {
78310       {
78311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78312       };
78313     } catch (std::exception& e) {
78314       {
78315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78316       };
78317     } catch (...) {
78318       {
78319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78320       };
78321     }
78322   }
78323   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78324   return jresult;
78325 }
78326
78327
78328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78329   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78330   Dali::Actor arg2 ;
78331   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78332   std::string *arg4 = 0 ;
78333   Dali::Actor *argp2 ;
78334
78335   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78336   argp2 = (Dali::Actor *)jarg2;
78337   if (!argp2) {
78338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78339     return ;
78340   }
78341   arg2 = *argp2;
78342   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78343   if (!jarg4) {
78344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78345     return ;
78346   }
78347   std::string arg4_str(jarg4);
78348   arg4 = &arg4_str;
78349   {
78350     try {
78351       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
78352     } catch (std::out_of_range& e) {
78353       {
78354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78355       };
78356     } catch (std::exception& e) {
78357       {
78358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78359       };
78360     } catch (...) {
78361       {
78362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78363       };
78364     }
78365   }
78366
78367   //argout typemap for const std::string&
78368
78369 }
78370
78371
78372 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
78373   char * jresult ;
78374   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78375   Dali::Actor arg2 ;
78376   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78377   Dali::Actor *argp2 ;
78378   std::string result;
78379
78380   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78381   argp2 = (Dali::Actor *)jarg2;
78382   if (!argp2) {
78383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78384     return 0;
78385   }
78386   arg2 = *argp2;
78387   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78388   {
78389     try {
78390       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
78391     } catch (std::out_of_range& e) {
78392       {
78393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78394       };
78395     } catch (std::exception& e) {
78396       {
78397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78398       };
78399     } catch (...) {
78400       {
78401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78402       };
78403     }
78404   }
78405   jresult = SWIG_csharp_string_callback((&result)->c_str());
78406   return jresult;
78407 }
78408
78409
78410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
78411   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78412   Dali::Actor arg2 ;
78413   unsigned int arg3 ;
78414   Dali::Actor *argp2 ;
78415
78416   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78417   argp2 = (Dali::Actor *)jarg2;
78418   if (!argp2) {
78419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78420     return ;
78421   }
78422   arg2 = *argp2;
78423   arg3 = (unsigned int)jarg3;
78424   {
78425     try {
78426       (arg1)->SetFocusOrder(arg2,arg3);
78427     } catch (std::out_of_range& e) {
78428       {
78429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78430       };
78431     } catch (std::exception& e) {
78432       {
78433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78434       };
78435     } catch (...) {
78436       {
78437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78438       };
78439     }
78440   }
78441 }
78442
78443
78444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
78445   unsigned int jresult ;
78446   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78447   Dali::Actor arg2 ;
78448   Dali::Actor *argp2 ;
78449   unsigned int result;
78450
78451   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78452   argp2 = (Dali::Actor *)jarg2;
78453   if (!argp2) {
78454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78455     return 0;
78456   }
78457   arg2 = *argp2;
78458   {
78459     try {
78460       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
78461     } catch (std::out_of_range& e) {
78462       {
78463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78464       };
78465     } catch (std::exception& e) {
78466       {
78467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78468       };
78469     } catch (...) {
78470       {
78471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78472       };
78473     }
78474   }
78475   jresult = result;
78476   return jresult;
78477 }
78478
78479
78480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
78481   unsigned int jresult ;
78482   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78483   unsigned int result;
78484
78485   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78486   {
78487     try {
78488       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
78489     } catch (std::out_of_range& e) {
78490       {
78491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78492       };
78493     } catch (std::exception& e) {
78494       {
78495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78496       };
78497     } catch (...) {
78498       {
78499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78500       };
78501     }
78502   }
78503   jresult = result;
78504   return jresult;
78505 }
78506
78507
78508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
78509   void * jresult ;
78510   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78511   unsigned int arg2 ;
78512   Dali::Actor result;
78513
78514   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78515   arg2 = (unsigned int)jarg2;
78516   {
78517     try {
78518       result = (arg1)->GetActorByFocusOrder(arg2);
78519     } catch (std::out_of_range& e) {
78520       {
78521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78522       };
78523     } catch (std::exception& e) {
78524       {
78525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78526       };
78527     } catch (...) {
78528       {
78529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78530       };
78531     }
78532   }
78533   jresult = new Dali::Actor((const Dali::Actor &)result);
78534   return jresult;
78535 }
78536
78537
78538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
78539   unsigned int jresult ;
78540   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78541   Dali::Actor arg2 ;
78542   Dali::Actor *argp2 ;
78543   bool result;
78544
78545   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78546   argp2 = (Dali::Actor *)jarg2;
78547   if (!argp2) {
78548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78549     return 0;
78550   }
78551   arg2 = *argp2;
78552   {
78553     try {
78554       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
78555     } catch (std::out_of_range& e) {
78556       {
78557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78558       };
78559     } catch (std::exception& e) {
78560       {
78561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78562       };
78563     } catch (...) {
78564       {
78565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78566       };
78567     }
78568   }
78569   jresult = result;
78570   return jresult;
78571 }
78572
78573
78574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
78575   void * jresult ;
78576   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78577   Dali::Actor result;
78578
78579   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78580   {
78581     try {
78582       result = (arg1)->GetCurrentFocusActor();
78583     } catch (std::out_of_range& e) {
78584       {
78585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78586       };
78587     } catch (std::exception& e) {
78588       {
78589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78590       };
78591     } catch (...) {
78592       {
78593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78594       };
78595     }
78596   }
78597   jresult = new Dali::Actor((const Dali::Actor &)result);
78598   return jresult;
78599 }
78600
78601
78602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
78603   void * jresult ;
78604   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78605   Dali::Actor result;
78606
78607   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78608   {
78609     try {
78610       result = (arg1)->GetCurrentFocusGroup();
78611     } catch (std::out_of_range& e) {
78612       {
78613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78614       };
78615     } catch (std::exception& e) {
78616       {
78617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78618       };
78619     } catch (...) {
78620       {
78621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78622       };
78623     }
78624   }
78625   jresult = new Dali::Actor((const Dali::Actor &)result);
78626   return jresult;
78627 }
78628
78629
78630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
78631   unsigned int jresult ;
78632   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78633   unsigned int result;
78634
78635   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78636   {
78637     try {
78638       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
78639     } catch (std::out_of_range& e) {
78640       {
78641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78642       };
78643     } catch (std::exception& e) {
78644       {
78645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78646       };
78647     } catch (...) {
78648       {
78649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78650       };
78651     }
78652   }
78653   jresult = result;
78654   return jresult;
78655 }
78656
78657
78658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
78659   unsigned int jresult ;
78660   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78661   bool result;
78662
78663   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78664   {
78665     try {
78666       result = (bool)(arg1)->MoveFocusForward();
78667     } catch (std::out_of_range& e) {
78668       {
78669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78670       };
78671     } catch (std::exception& e) {
78672       {
78673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78674       };
78675     } catch (...) {
78676       {
78677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78678       };
78679     }
78680   }
78681   jresult = result;
78682   return jresult;
78683 }
78684
78685
78686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
78687   unsigned int jresult ;
78688   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78689   bool result;
78690
78691   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78692   {
78693     try {
78694       result = (bool)(arg1)->MoveFocusBackward();
78695     } catch (std::out_of_range& e) {
78696       {
78697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78698       };
78699     } catch (std::exception& e) {
78700       {
78701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78702       };
78703     } catch (...) {
78704       {
78705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78706       };
78707     }
78708   }
78709   jresult = result;
78710   return jresult;
78711 }
78712
78713
78714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
78715   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78716
78717   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78718   {
78719     try {
78720       (arg1)->ClearFocus();
78721     } catch (std::out_of_range& e) {
78722       {
78723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78724       };
78725     } catch (std::exception& e) {
78726       {
78727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78728       };
78729     } catch (...) {
78730       {
78731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78732       };
78733     }
78734   }
78735 }
78736
78737
78738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
78739   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78740
78741   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78742   {
78743     try {
78744       (arg1)->Reset();
78745     } catch (std::out_of_range& e) {
78746       {
78747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78748       };
78749     } catch (std::exception& e) {
78750       {
78751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78752       };
78753     } catch (...) {
78754       {
78755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78756       };
78757     }
78758   }
78759 }
78760
78761
78762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
78763   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78764   Dali::Actor arg2 ;
78765   bool arg3 ;
78766   Dali::Actor *argp2 ;
78767
78768   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78769   argp2 = (Dali::Actor *)jarg2;
78770   if (!argp2) {
78771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78772     return ;
78773   }
78774   arg2 = *argp2;
78775   arg3 = jarg3 ? true : false;
78776   {
78777     try {
78778       (arg1)->SetFocusGroup(arg2,arg3);
78779     } catch (std::out_of_range& e) {
78780       {
78781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78782       };
78783     } catch (std::exception& e) {
78784       {
78785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78786       };
78787     } catch (...) {
78788       {
78789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78790       };
78791     }
78792   }
78793 }
78794
78795
78796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
78797   unsigned int jresult ;
78798   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78799   Dali::Actor arg2 ;
78800   Dali::Actor *argp2 ;
78801   bool result;
78802
78803   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78804   argp2 = (Dali::Actor *)jarg2;
78805   if (!argp2) {
78806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78807     return 0;
78808   }
78809   arg2 = *argp2;
78810   {
78811     try {
78812       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
78813     } catch (std::out_of_range& e) {
78814       {
78815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78816       };
78817     } catch (std::exception& e) {
78818       {
78819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78820       };
78821     } catch (...) {
78822       {
78823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78824       };
78825     }
78826   }
78827   jresult = result;
78828   return jresult;
78829 }
78830
78831
78832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
78833   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78834   bool arg2 ;
78835
78836   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78837   arg2 = jarg2 ? true : false;
78838   {
78839     try {
78840       (arg1)->SetGroupMode(arg2);
78841     } catch (std::out_of_range& e) {
78842       {
78843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78844       };
78845     } catch (std::exception& e) {
78846       {
78847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78848       };
78849     } catch (...) {
78850       {
78851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78852       };
78853     }
78854   }
78855 }
78856
78857
78858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
78859   unsigned int jresult ;
78860   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78861   bool result;
78862
78863   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78864   {
78865     try {
78866       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
78867     } catch (std::out_of_range& e) {
78868       {
78869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78870       };
78871     } catch (std::exception& e) {
78872       {
78873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78874       };
78875     } catch (...) {
78876       {
78877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78878       };
78879     }
78880   }
78881   jresult = result;
78882   return jresult;
78883 }
78884
78885
78886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
78887   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78888   bool arg2 ;
78889
78890   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78891   arg2 = jarg2 ? true : false;
78892   {
78893     try {
78894       (arg1)->SetWrapMode(arg2);
78895     } catch (std::out_of_range& e) {
78896       {
78897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78898       };
78899     } catch (std::exception& e) {
78900       {
78901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78902       };
78903     } catch (...) {
78904       {
78905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78906       };
78907     }
78908   }
78909 }
78910
78911
78912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
78913   unsigned int jresult ;
78914   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78915   bool result;
78916
78917   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78918   {
78919     try {
78920       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
78921     } catch (std::out_of_range& e) {
78922       {
78923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78924       };
78925     } catch (std::exception& e) {
78926       {
78927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78928       };
78929     } catch (...) {
78930       {
78931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78932       };
78933     }
78934   }
78935   jresult = result;
78936   return jresult;
78937 }
78938
78939
78940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
78941   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78942   Dali::Actor arg2 ;
78943   Dali::Actor *argp2 ;
78944
78945   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78946   argp2 = (Dali::Actor *)jarg2;
78947   if (!argp2) {
78948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78949     return ;
78950   }
78951   arg2 = *argp2;
78952   {
78953     try {
78954       (arg1)->SetFocusIndicatorActor(arg2);
78955     } catch (std::out_of_range& e) {
78956       {
78957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78958       };
78959     } catch (std::exception& e) {
78960       {
78961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78962       };
78963     } catch (...) {
78964       {
78965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78966       };
78967     }
78968   }
78969 }
78970
78971
78972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
78973   void * jresult ;
78974   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78975   Dali::Actor result;
78976
78977   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78978   {
78979     try {
78980       result = (arg1)->GetFocusIndicatorActor();
78981     } catch (std::out_of_range& e) {
78982       {
78983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78984       };
78985     } catch (std::exception& e) {
78986       {
78987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78988       };
78989     } catch (...) {
78990       {
78991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78992       };
78993     }
78994   }
78995   jresult = new Dali::Actor((const Dali::Actor &)result);
78996   return jresult;
78997 }
78998
78999
79000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79001   void * jresult ;
79002   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79003   Dali::Actor arg2 ;
79004   Dali::Actor *argp2 ;
79005   Dali::Actor result;
79006
79007   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79008   argp2 = (Dali::Actor *)jarg2;
79009   if (!argp2) {
79010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79011     return 0;
79012   }
79013   arg2 = *argp2;
79014   {
79015     try {
79016       result = (arg1)->GetFocusGroup(arg2);
79017     } catch (std::out_of_range& e) {
79018       {
79019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79020       };
79021     } catch (std::exception& e) {
79022       {
79023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79024       };
79025     } catch (...) {
79026       {
79027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79028       };
79029     }
79030   }
79031   jresult = new Dali::Actor((const Dali::Actor &)result);
79032   return jresult;
79033 }
79034
79035
79036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79037   void * jresult ;
79038   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79039   Dali::Vector2 result;
79040
79041   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79042   {
79043     try {
79044       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79045     } catch (std::out_of_range& e) {
79046       {
79047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79048       };
79049     } catch (std::exception& e) {
79050       {
79051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79052       };
79053     } catch (...) {
79054       {
79055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79056       };
79057     }
79058   }
79059   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79060   return jresult;
79061 }
79062
79063
79064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79065   void * jresult ;
79066   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79067   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79068
79069   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79070   {
79071     try {
79072       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79073     } catch (std::out_of_range& e) {
79074       {
79075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79076       };
79077     } catch (std::exception& e) {
79078       {
79079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79080       };
79081     } catch (...) {
79082       {
79083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79084       };
79085     }
79086   }
79087   jresult = (void *)result;
79088   return jresult;
79089 }
79090
79091
79092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79093   void * jresult ;
79094   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79095   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79096
79097   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79098   {
79099     try {
79100       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79101     } catch (std::out_of_range& e) {
79102       {
79103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79104       };
79105     } catch (std::exception& e) {
79106       {
79107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79108       };
79109     } catch (...) {
79110       {
79111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79112       };
79113     }
79114   }
79115   jresult = (void *)result;
79116   return jresult;
79117 }
79118
79119
79120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79121   void * jresult ;
79122   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79123   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79124
79125   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79126   {
79127     try {
79128       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79129     } catch (std::out_of_range& e) {
79130       {
79131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79132       };
79133     } catch (std::exception& e) {
79134       {
79135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79136       };
79137     } catch (...) {
79138       {
79139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79140       };
79141     }
79142   }
79143   jresult = (void *)result;
79144   return jresult;
79145 }
79146
79147
79148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79149   void * jresult ;
79150   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79151   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79152
79153   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79154   {
79155     try {
79156       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79157     } catch (std::out_of_range& e) {
79158       {
79159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79160       };
79161     } catch (std::exception& e) {
79162       {
79163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79164       };
79165     } catch (...) {
79166       {
79167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79168       };
79169     }
79170   }
79171   jresult = (void *)result;
79172   return jresult;
79173 }
79174
79175
79176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79177   void * jresult ;
79178   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79179   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79180
79181   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79182   {
79183     try {
79184       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79185     } catch (std::out_of_range& e) {
79186       {
79187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79188       };
79189     } catch (std::exception& e) {
79190       {
79191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79192       };
79193     } catch (...) {
79194       {
79195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79196       };
79197     }
79198   }
79199   jresult = (void *)result;
79200   return jresult;
79201 }
79202
79203
79204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
79205   void * jresult ;
79206   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79207   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79208
79209   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79210   {
79211     try {
79212       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
79213     } catch (std::out_of_range& e) {
79214       {
79215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79216       };
79217     } catch (std::exception& e) {
79218       {
79219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79220       };
79221     } catch (...) {
79222       {
79223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79224       };
79225     }
79226   }
79227   jresult = (void *)result;
79228   return jresult;
79229 }
79230
79231
79232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
79233   void * jresult ;
79234   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79235   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79236
79237   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79238   {
79239     try {
79240       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
79241     } catch (std::out_of_range& e) {
79242       {
79243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79244       };
79245     } catch (std::exception& e) {
79246       {
79247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79248       };
79249     } catch (...) {
79250       {
79251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79252       };
79253     }
79254   }
79255   jresult = (void *)result;
79256   return jresult;
79257 }
79258
79259
79260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
79261   void * jresult ;
79262   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79263   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79264
79265   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79266   {
79267     try {
79268       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
79269     } catch (std::out_of_range& e) {
79270       {
79271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79272       };
79273     } catch (std::exception& e) {
79274       {
79275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79276       };
79277     } catch (...) {
79278       {
79279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79280       };
79281     }
79282   }
79283   jresult = (void *)result;
79284   return jresult;
79285 }
79286
79287
79288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
79289   void * jresult ;
79290   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79291   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79292
79293   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79294   {
79295     try {
79296       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
79297     } catch (std::out_of_range& e) {
79298       {
79299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79300       };
79301     } catch (std::exception& e) {
79302       {
79303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79304       };
79305     } catch (...) {
79306       {
79307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79308       };
79309     }
79310   }
79311   jresult = (void *)result;
79312   return jresult;
79313 }
79314
79315
79316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
79317   void * jresult ;
79318   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79319   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79320
79321   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79322   {
79323     try {
79324       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
79325     } catch (std::out_of_range& e) {
79326       {
79327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79328       };
79329     } catch (std::exception& e) {
79330       {
79331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79332       };
79333     } catch (...) {
79334       {
79335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79336       };
79337     }
79338   }
79339   jresult = (void *)result;
79340   return jresult;
79341 }
79342
79343
79344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
79345   void * jresult ;
79346   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79347   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79348
79349   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79350   {
79351     try {
79352       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
79353     } catch (std::out_of_range& e) {
79354       {
79355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79356       };
79357     } catch (std::exception& e) {
79358       {
79359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79360       };
79361     } catch (...) {
79362       {
79363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79364       };
79365     }
79366   }
79367   jresult = (void *)result;
79368   return jresult;
79369 }
79370
79371
79372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
79373   void * jresult ;
79374   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79375   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79376
79377   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79378   {
79379     try {
79380       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
79381     } catch (std::out_of_range& e) {
79382       {
79383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79384       };
79385     } catch (std::exception& e) {
79386       {
79387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79388       };
79389     } catch (...) {
79390       {
79391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79392       };
79393     }
79394   }
79395   jresult = (void *)result;
79396   return jresult;
79397 }
79398
79399
79400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
79401   void * jresult ;
79402   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79403   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79404
79405   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79406   {
79407     try {
79408       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
79409     } catch (std::out_of_range& e) {
79410       {
79411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79412       };
79413     } catch (std::exception& e) {
79414       {
79415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79416       };
79417     } catch (...) {
79418       {
79419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79420       };
79421     }
79422   }
79423   jresult = (void *)result;
79424   return jresult;
79425 }
79426
79427
79428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
79429   void * jresult ;
79430   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79431   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79432
79433   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79434   {
79435     try {
79436       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
79437     } catch (std::out_of_range& e) {
79438       {
79439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79440       };
79441     } catch (std::exception& e) {
79442       {
79443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79444       };
79445     } catch (...) {
79446       {
79447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79448       };
79449     }
79450   }
79451   jresult = (void *)result;
79452   return jresult;
79453 }
79454
79455
79456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
79457   void * jresult ;
79458   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79459   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79460
79461   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79462   {
79463     try {
79464       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
79465     } catch (std::out_of_range& e) {
79466       {
79467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79468       };
79469     } catch (std::exception& e) {
79470       {
79471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79472       };
79473     } catch (...) {
79474       {
79475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79476       };
79477     }
79478   }
79479   jresult = (void *)result;
79480   return jresult;
79481 }
79482
79483
79484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
79485   void * jresult ;
79486   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79487   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79488
79489   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79490   {
79491     try {
79492       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
79493     } catch (std::out_of_range& e) {
79494       {
79495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79496       };
79497     } catch (std::exception& e) {
79498       {
79499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79500       };
79501     } catch (...) {
79502       {
79503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79504       };
79505     }
79506   }
79507   jresult = (void *)result;
79508   return jresult;
79509 }
79510
79511
79512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
79513   void * jresult ;
79514   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79515   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79516
79517   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79518   {
79519     try {
79520       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
79521     } catch (std::out_of_range& e) {
79522       {
79523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79524       };
79525     } catch (std::exception& e) {
79526       {
79527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79528       };
79529     } catch (...) {
79530       {
79531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79532       };
79533     }
79534   }
79535   jresult = (void *)result;
79536   return jresult;
79537 }
79538
79539
79540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
79541   void * jresult ;
79542   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79543   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79544
79545   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79546   {
79547     try {
79548       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
79549     } catch (std::out_of_range& e) {
79550       {
79551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79552       };
79553     } catch (std::exception& e) {
79554       {
79555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79556       };
79557     } catch (...) {
79558       {
79559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79560       };
79561     }
79562   }
79563   jresult = (void *)result;
79564   return jresult;
79565 }
79566
79567
79568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
79569   void * jresult ;
79570   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79571   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79572
79573   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79574   {
79575     try {
79576       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
79577     } catch (std::out_of_range& e) {
79578       {
79579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79580       };
79581     } catch (std::exception& e) {
79582       {
79583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79584       };
79585     } catch (...) {
79586       {
79587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79588       };
79589     }
79590   }
79591   jresult = (void *)result;
79592   return jresult;
79593 }
79594
79595
79596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
79597   void * jresult ;
79598   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79599   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79600
79601   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79602   {
79603     try {
79604       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
79605     } catch (std::out_of_range& e) {
79606       {
79607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79608       };
79609     } catch (std::exception& e) {
79610       {
79611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79612       };
79613     } catch (...) {
79614       {
79615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79616       };
79617     }
79618   }
79619   jresult = (void *)result;
79620   return jresult;
79621 }
79622
79623
79624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
79625   void * jresult ;
79626   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79627   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79628
79629   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79630   {
79631     try {
79632       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
79633     } catch (std::out_of_range& e) {
79634       {
79635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79636       };
79637     } catch (std::exception& e) {
79638       {
79639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79640       };
79641     } catch (...) {
79642       {
79643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79644       };
79645     }
79646   }
79647   jresult = (void *)result;
79648   return jresult;
79649 }
79650
79651
79652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
79653   void * jresult ;
79654   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79655   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79656
79657   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79658   {
79659     try {
79660       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
79661     } catch (std::out_of_range& e) {
79662       {
79663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79664       };
79665     } catch (std::exception& e) {
79666       {
79667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79668       };
79669     } catch (...) {
79670       {
79671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79672       };
79673     }
79674   }
79675   jresult = (void *)result;
79676   return jresult;
79677 }
79678
79679
79680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
79681   void * jresult ;
79682   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79683   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79684
79685   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79686   {
79687     try {
79688       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
79689     } catch (std::out_of_range& e) {
79690       {
79691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79692       };
79693     } catch (std::exception& e) {
79694       {
79695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79696       };
79697     } catch (...) {
79698       {
79699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79700       };
79701     }
79702   }
79703   jresult = (void *)result;
79704   return jresult;
79705 }
79706
79707
79708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
79709   void * jresult ;
79710   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79711   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79712
79713   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79714   {
79715     try {
79716       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
79717     } catch (std::out_of_range& e) {
79718       {
79719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79720       };
79721     } catch (std::exception& e) {
79722       {
79723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79724       };
79725     } catch (...) {
79726       {
79727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79728       };
79729     }
79730   }
79731   jresult = (void *)result;
79732   return jresult;
79733 }
79734
79735
79736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
79737   void * jresult ;
79738   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79739   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79740
79741   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79742   {
79743     try {
79744       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
79745     } catch (std::out_of_range& e) {
79746       {
79747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79748       };
79749     } catch (std::exception& e) {
79750       {
79751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79752       };
79753     } catch (...) {
79754       {
79755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79756       };
79757     }
79758   }
79759   jresult = (void *)result;
79760   return jresult;
79761 }
79762
79763
79764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
79765   void * jresult ;
79766   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79767   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79768
79769   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79770   {
79771     try {
79772       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
79773     } catch (std::out_of_range& e) {
79774       {
79775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79776       };
79777     } catch (std::exception& e) {
79778       {
79779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79780       };
79781     } catch (...) {
79782       {
79783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79784       };
79785     }
79786   }
79787   jresult = (void *)result;
79788   return jresult;
79789 }
79790
79791
79792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
79793   void * jresult ;
79794   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79795   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79796
79797   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79798   {
79799     try {
79800       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
79801     } catch (std::out_of_range& e) {
79802       {
79803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79804       };
79805     } catch (std::exception& e) {
79806       {
79807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79808       };
79809     } catch (...) {
79810       {
79811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79812       };
79813     }
79814   }
79815   jresult = (void *)result;
79816   return jresult;
79817 }
79818
79819
79820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
79821   void * jresult ;
79822   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79823   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79824
79825   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79826   {
79827     try {
79828       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
79829     } catch (std::out_of_range& e) {
79830       {
79831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79832       };
79833     } catch (std::exception& e) {
79834       {
79835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79836       };
79837     } catch (...) {
79838       {
79839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79840       };
79841     }
79842   }
79843   jresult = (void *)result;
79844   return jresult;
79845 }
79846
79847
79848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
79849   void * jresult ;
79850   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79851   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79852
79853   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79854   {
79855     try {
79856       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
79857     } catch (std::out_of_range& e) {
79858       {
79859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79860       };
79861     } catch (std::exception& e) {
79862       {
79863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79864       };
79865     } catch (...) {
79866       {
79867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79868       };
79869     }
79870   }
79871   jresult = (void *)result;
79872   return jresult;
79873 }
79874
79875
79876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
79877   void * jresult ;
79878   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79879   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
79880
79881   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79882   {
79883     try {
79884       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
79885     } catch (std::out_of_range& e) {
79886       {
79887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79888       };
79889     } catch (std::exception& e) {
79890       {
79891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79892       };
79893     } catch (...) {
79894       {
79895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79896       };
79897     }
79898   }
79899   jresult = (void *)result;
79900   return jresult;
79901 }
79902
79903
79904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
79905   void * jresult ;
79906   Dali::Toolkit::StyleManager *result = 0 ;
79907
79908   {
79909     try {
79910       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
79911     } catch (std::out_of_range& e) {
79912       {
79913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79914       };
79915     } catch (std::exception& e) {
79916       {
79917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79918       };
79919     } catch (...) {
79920       {
79921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79922       };
79923     }
79924   }
79925   jresult = (void *)result;
79926   return jresult;
79927 }
79928
79929
79930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
79931   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
79932
79933   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
79934   {
79935     try {
79936       delete arg1;
79937     } catch (std::out_of_range& e) {
79938       {
79939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79940       };
79941     } catch (std::exception& e) {
79942       {
79943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79944       };
79945     } catch (...) {
79946       {
79947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79948       };
79949     }
79950   }
79951 }
79952
79953
79954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
79955   void * jresult ;
79956   Dali::Toolkit::StyleManager result;
79957
79958   {
79959     try {
79960       result = Dali::Toolkit::StyleManager::Get();
79961     } catch (std::out_of_range& e) {
79962       {
79963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79964       };
79965     } catch (std::exception& e) {
79966       {
79967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79968       };
79969     } catch (...) {
79970       {
79971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79972       };
79973     }
79974   }
79975   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
79976   return jresult;
79977 }
79978
79979
79980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
79981   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
79982   std::string *arg2 = 0 ;
79983
79984   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
79985   if (!jarg2) {
79986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79987     return ;
79988   }
79989   std::string arg2_str(jarg2);
79990   arg2 = &arg2_str;
79991   {
79992     try {
79993       (arg1)->ApplyTheme((std::string const &)*arg2);
79994     } catch (std::out_of_range& e) {
79995       {
79996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79997       };
79998     } catch (std::exception& e) {
79999       {
80000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80001       };
80002     } catch (...) {
80003       {
80004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80005       };
80006     }
80007   }
80008
80009   //argout typemap for const std::string&
80010
80011 }
80012
80013
80014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80015   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80016
80017   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80018   {
80019     try {
80020       (arg1)->ApplyDefaultTheme();
80021     } catch (std::out_of_range& e) {
80022       {
80023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80024       };
80025     } catch (std::exception& e) {
80026       {
80027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80028       };
80029     } catch (...) {
80030       {
80031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80032       };
80033     }
80034   }
80035 }
80036
80037
80038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80039   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80040   std::string *arg2 = 0 ;
80041   Dali::Property::Value *arg3 = 0 ;
80042
80043   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80044   if (!jarg2) {
80045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80046     return ;
80047   }
80048   std::string arg2_str(jarg2);
80049   arg2 = &arg2_str;
80050   arg3 = (Dali::Property::Value *)jarg3;
80051   if (!arg3) {
80052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80053     return ;
80054   }
80055   {
80056     try {
80057       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80058     } catch (std::out_of_range& e) {
80059       {
80060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80061       };
80062     } catch (std::exception& e) {
80063       {
80064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80065       };
80066     } catch (...) {
80067       {
80068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80069       };
80070     }
80071   }
80072
80073   //argout typemap for const std::string&
80074
80075 }
80076
80077
80078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80079   unsigned int jresult ;
80080   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80081   std::string *arg2 = 0 ;
80082   Dali::Property::Value *arg3 = 0 ;
80083   bool result;
80084
80085   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80086   if (!jarg2) {
80087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80088     return 0;
80089   }
80090   std::string arg2_str(jarg2);
80091   arg2 = &arg2_str;
80092   arg3 = (Dali::Property::Value *)jarg3;
80093   if (!arg3) {
80094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
80095     return 0;
80096   }
80097   {
80098     try {
80099       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
80100     } catch (std::out_of_range& e) {
80101       {
80102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80103       };
80104     } catch (std::exception& e) {
80105       {
80106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80107       };
80108     } catch (...) {
80109       {
80110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80111       };
80112     }
80113   }
80114   jresult = result;
80115
80116   //argout typemap for const std::string&
80117
80118   return jresult;
80119 }
80120
80121
80122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
80123   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80124   Dali::Toolkit::Control arg2 ;
80125   std::string *arg3 = 0 ;
80126   std::string *arg4 = 0 ;
80127   Dali::Toolkit::Control *argp2 ;
80128
80129   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80130   argp2 = (Dali::Toolkit::Control *)jarg2;
80131   if (!argp2) {
80132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
80133     return ;
80134   }
80135   arg2 = *argp2;
80136   if (!jarg3) {
80137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80138     return ;
80139   }
80140   std::string arg3_str(jarg3);
80141   arg3 = &arg3_str;
80142   if (!jarg4) {
80143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80144     return ;
80145   }
80146   std::string arg4_str(jarg4);
80147   arg4 = &arg4_str;
80148   {
80149     try {
80150       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
80151     } catch (std::out_of_range& e) {
80152       {
80153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80154       };
80155     } catch (std::exception& e) {
80156       {
80157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80158       };
80159     } catch (...) {
80160       {
80161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80162       };
80163     }
80164   }
80165
80166   //argout typemap for const std::string&
80167
80168
80169   //argout typemap for const std::string&
80170
80171 }
80172
80173
80174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
80175   void * jresult ;
80176   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80177   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
80178
80179   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80180   {
80181     try {
80182       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
80183     } catch (std::out_of_range& e) {
80184       {
80185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80186       };
80187     } catch (std::exception& e) {
80188       {
80189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80190       };
80191     } catch (...) {
80192       {
80193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80194       };
80195     }
80196   }
80197   jresult = (void *)result;
80198   return jresult;
80199 }
80200
80201
80202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
80203   int jresult ;
80204   int result;
80205
80206   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
80207   jresult = (int)result;
80208   return jresult;
80209 }
80210
80211
80212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
80213   int jresult ;
80214   int result;
80215
80216   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
80217   jresult = (int)result;
80218   return jresult;
80219 }
80220
80221
80222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
80223   int jresult ;
80224   int result;
80225
80226   result = (int)Dali::Toolkit::Slider::Property::VALUE;
80227   jresult = (int)result;
80228   return jresult;
80229 }
80230
80231
80232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
80233   int jresult ;
80234   int result;
80235
80236   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
80237   jresult = (int)result;
80238   return jresult;
80239 }
80240
80241
80242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
80243   int jresult ;
80244   int result;
80245
80246   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
80247   jresult = (int)result;
80248   return jresult;
80249 }
80250
80251
80252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
80253   int jresult ;
80254   int result;
80255
80256   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
80257   jresult = (int)result;
80258   return jresult;
80259 }
80260
80261
80262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
80263   int jresult ;
80264   int result;
80265
80266   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
80267   jresult = (int)result;
80268   return jresult;
80269 }
80270
80271
80272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
80273   int jresult ;
80274   int result;
80275
80276   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
80277   jresult = (int)result;
80278   return jresult;
80279 }
80280
80281
80282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
80283   int jresult ;
80284   int result;
80285
80286   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
80287   jresult = (int)result;
80288   return jresult;
80289 }
80290
80291
80292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
80293   int jresult ;
80294   int result;
80295
80296   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
80297   jresult = (int)result;
80298   return jresult;
80299 }
80300
80301
80302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
80303   int jresult ;
80304   int result;
80305
80306   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
80307   jresult = (int)result;
80308   return jresult;
80309 }
80310
80311
80312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
80313   int jresult ;
80314   int result;
80315
80316   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
80317   jresult = (int)result;
80318   return jresult;
80319 }
80320
80321
80322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
80323   int jresult ;
80324   int result;
80325
80326   result = (int)Dali::Toolkit::Slider::Property::MARKS;
80327   jresult = (int)result;
80328   return jresult;
80329 }
80330
80331
80332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
80333   int jresult ;
80334   int result;
80335
80336   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
80337   jresult = (int)result;
80338   return jresult;
80339 }
80340
80341
80342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
80343   int jresult ;
80344   int result;
80345
80346   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
80347   jresult = (int)result;
80348   return jresult;
80349 }
80350
80351
80352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
80353   void * jresult ;
80354   Dali::Toolkit::Slider::Property *result = 0 ;
80355
80356   {
80357     try {
80358       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
80359     } catch (std::out_of_range& e) {
80360       {
80361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80362       };
80363     } catch (std::exception& e) {
80364       {
80365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80366       };
80367     } catch (...) {
80368       {
80369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80370       };
80371     }
80372   }
80373   jresult = (void *)result;
80374   return jresult;
80375 }
80376
80377
80378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
80379   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
80380
80381   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
80382   {
80383     try {
80384       delete arg1;
80385     } catch (std::out_of_range& e) {
80386       {
80387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80388       };
80389     } catch (std::exception& e) {
80390       {
80391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80392       };
80393     } catch (...) {
80394       {
80395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80396       };
80397     }
80398   }
80399 }
80400
80401
80402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
80403   void * jresult ;
80404   Dali::Toolkit::Slider result;
80405
80406   {
80407     try {
80408       result = Dali::Toolkit::Slider::New();
80409     } catch (std::out_of_range& e) {
80410       {
80411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80412       };
80413     } catch (std::exception& e) {
80414       {
80415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80416       };
80417     } catch (...) {
80418       {
80419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80420       };
80421     }
80422   }
80423   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80424   return jresult;
80425 }
80426
80427
80428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
80429   void * jresult ;
80430   Dali::Toolkit::Slider *result = 0 ;
80431
80432   {
80433     try {
80434       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
80435     } catch (std::out_of_range& e) {
80436       {
80437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80438       };
80439     } catch (std::exception& e) {
80440       {
80441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80442       };
80443     } catch (...) {
80444       {
80445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80446       };
80447     }
80448   }
80449   jresult = (void *)result;
80450   return jresult;
80451 }
80452
80453
80454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
80455   void * jresult ;
80456   Dali::Toolkit::Slider *arg1 = 0 ;
80457   Dali::Toolkit::Slider *result = 0 ;
80458
80459   arg1 = (Dali::Toolkit::Slider *)jarg1;
80460   if (!arg1) {
80461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80462     return 0;
80463   }
80464   {
80465     try {
80466       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
80467     } catch (std::out_of_range& e) {
80468       {
80469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80470       };
80471     } catch (std::exception& e) {
80472       {
80473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80474       };
80475     } catch (...) {
80476       {
80477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80478       };
80479     }
80480   }
80481   jresult = (void *)result;
80482   return jresult;
80483 }
80484
80485
80486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
80487   void * jresult ;
80488   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80489   Dali::Toolkit::Slider *arg2 = 0 ;
80490   Dali::Toolkit::Slider *result = 0 ;
80491
80492   arg1 = (Dali::Toolkit::Slider *)jarg1;
80493   arg2 = (Dali::Toolkit::Slider *)jarg2;
80494   if (!arg2) {
80495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80496     return 0;
80497   }
80498   {
80499     try {
80500       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
80501     } catch (std::out_of_range& e) {
80502       {
80503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80504       };
80505     } catch (std::exception& e) {
80506       {
80507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80508       };
80509     } catch (...) {
80510       {
80511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80512       };
80513     }
80514   }
80515   jresult = (void *)result;
80516   return jresult;
80517 }
80518
80519
80520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
80521   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80522
80523   arg1 = (Dali::Toolkit::Slider *)jarg1;
80524   {
80525     try {
80526       delete arg1;
80527     } catch (std::out_of_range& e) {
80528       {
80529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80530       };
80531     } catch (std::exception& e) {
80532       {
80533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80534       };
80535     } catch (...) {
80536       {
80537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80538       };
80539     }
80540   }
80541 }
80542
80543
80544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
80545   void * jresult ;
80546   Dali::BaseHandle arg1 ;
80547   Dali::BaseHandle *argp1 ;
80548   Dali::Toolkit::Slider result;
80549
80550   argp1 = (Dali::BaseHandle *)jarg1;
80551   if (!argp1) {
80552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80553     return 0;
80554   }
80555   arg1 = *argp1;
80556   {
80557     try {
80558       result = Dali::Toolkit::Slider::DownCast(arg1);
80559     } catch (std::out_of_range& e) {
80560       {
80561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80562       };
80563     } catch (std::exception& e) {
80564       {
80565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80566       };
80567     } catch (...) {
80568       {
80569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80570       };
80571     }
80572   }
80573   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80574   return jresult;
80575 }
80576
80577
80578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
80579   void * jresult ;
80580   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80581   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
80582
80583   arg1 = (Dali::Toolkit::Slider *)jarg1;
80584   {
80585     try {
80586       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
80587     } catch (std::out_of_range& e) {
80588       {
80589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80590       };
80591     } catch (std::exception& e) {
80592       {
80593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80594       };
80595     } catch (...) {
80596       {
80597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80598       };
80599     }
80600   }
80601   jresult = (void *)result;
80602   return jresult;
80603 }
80604
80605
80606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
80607   void * jresult ;
80608   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80609   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
80610
80611   arg1 = (Dali::Toolkit::Slider *)jarg1;
80612   {
80613     try {
80614       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
80615     } catch (std::out_of_range& e) {
80616       {
80617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80618       };
80619     } catch (std::exception& e) {
80620       {
80621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80622       };
80623     } catch (...) {
80624       {
80625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80626       };
80627     }
80628   }
80629   jresult = (void *)result;
80630   return jresult;
80631 }
80632
80633
80634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
80635   void * jresult ;
80636   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80637   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
80638
80639   arg1 = (Dali::Toolkit::Slider *)jarg1;
80640   {
80641     try {
80642       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
80643     } catch (std::out_of_range& e) {
80644       {
80645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80646       };
80647     } catch (std::exception& e) {
80648       {
80649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80650       };
80651     } catch (...) {
80652       {
80653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80654       };
80655     }
80656   }
80657   jresult = (void *)result;
80658   return jresult;
80659 }
80660
80661
80662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
80663   int jresult ;
80664   int result;
80665
80666   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
80667   jresult = (int)result;
80668   return jresult;
80669 }
80670
80671
80672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
80673   int jresult ;
80674   int result;
80675
80676   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
80677   jresult = (int)result;
80678   return jresult;
80679 }
80680
80681
80682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
80683   int jresult ;
80684   int result;
80685
80686   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
80687   jresult = (int)result;
80688   return jresult;
80689 }
80690
80691
80692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
80693   int jresult ;
80694   int result;
80695
80696   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
80697   jresult = (int)result;
80698   return jresult;
80699 }
80700
80701
80702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
80703   void * jresult ;
80704   Dali::Toolkit::VideoView::Property *result = 0 ;
80705
80706   {
80707     try {
80708       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
80709     } catch (std::out_of_range& e) {
80710       {
80711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80712       };
80713     } catch (std::exception& e) {
80714       {
80715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80716       };
80717     } catch (...) {
80718       {
80719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80720       };
80721     }
80722   }
80723   jresult = (void *)result;
80724   return jresult;
80725 }
80726
80727
80728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
80729   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
80730
80731   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
80732   {
80733     try {
80734       delete arg1;
80735     } catch (std::out_of_range& e) {
80736       {
80737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80738       };
80739     } catch (std::exception& e) {
80740       {
80741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80742       };
80743     } catch (...) {
80744       {
80745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80746       };
80747     }
80748   }
80749 }
80750
80751
80752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
80753   void * jresult ;
80754   Dali::Toolkit::VideoView result;
80755
80756   {
80757     try {
80758       result = Dali::Toolkit::VideoView::New();
80759     } catch (std::out_of_range& e) {
80760       {
80761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80762       };
80763     } catch (std::exception& e) {
80764       {
80765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80766       };
80767     } catch (...) {
80768       {
80769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80770       };
80771     }
80772   }
80773   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
80774   return jresult;
80775 }
80776
80777
80778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
80779   void * jresult ;
80780   std::string *arg1 = 0 ;
80781   Dali::Toolkit::VideoView result;
80782
80783   if (!jarg1) {
80784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80785     return 0;
80786   }
80787   std::string arg1_str(jarg1);
80788   arg1 = &arg1_str;
80789   {
80790     try {
80791       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
80792     } catch (std::out_of_range& e) {
80793       {
80794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80795       };
80796     } catch (std::exception& e) {
80797       {
80798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80799       };
80800     } catch (...) {
80801       {
80802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80803       };
80804     }
80805   }
80806   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
80807
80808   //argout typemap for const std::string&
80809
80810   return jresult;
80811 }
80812
80813
80814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
80815   void * jresult ;
80816   Dali::Toolkit::VideoView *result = 0 ;
80817
80818   {
80819     try {
80820       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
80821     } catch (std::out_of_range& e) {
80822       {
80823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80824       };
80825     } catch (std::exception& e) {
80826       {
80827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80828       };
80829     } catch (...) {
80830       {
80831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80832       };
80833     }
80834   }
80835   jresult = (void *)result;
80836   return jresult;
80837 }
80838
80839
80840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
80841   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
80842
80843   arg1 = (Dali::Toolkit::VideoView *)jarg1;
80844   {
80845     try {
80846       delete arg1;
80847     } catch (std::out_of_range& e) {
80848       {
80849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80850       };
80851     } catch (std::exception& e) {
80852       {
80853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80854       };
80855     } catch (...) {
80856       {
80857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80858       };
80859     }
80860   }
80861 }
80862
80863
80864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
80865   void * jresult ;
80866   Dali::Toolkit::VideoView *arg1 = 0 ;
80867   Dali::Toolkit::VideoView *result = 0 ;
80868
80869   arg1 = (Dali::Toolkit::VideoView *)jarg1;
80870   if (!arg1) {
80871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
80872     return 0;
80873   }
80874   {
80875     try {
80876       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
80877     } catch (std::out_of_range& e) {
80878       {
80879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80880       };
80881     } catch (std::exception& e) {
80882       {
80883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80884       };
80885     } catch (...) {
80886       {
80887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80888       };
80889     }
80890   }
80891   jresult = (void *)result;
80892   return jresult;
80893 }
80894
80895
80896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
80897   void * jresult ;
80898   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
80899   Dali::Toolkit::VideoView *arg2 = 0 ;
80900   Dali::Toolkit::VideoView *result = 0 ;
80901
80902   arg1 = (Dali::Toolkit::VideoView *)jarg1;
80903   arg2 = (Dali::Toolkit::VideoView *)jarg2;
80904   if (!arg2) {
80905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
80906     return 0;
80907   }
80908   {
80909     try {
80910       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
80911     } catch (std::out_of_range& e) {
80912       {
80913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80914       };
80915     } catch (std::exception& e) {
80916       {
80917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80918       };
80919     } catch (...) {
80920       {
80921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80922       };
80923     }
80924   }
80925   jresult = (void *)result;
80926   return jresult;
80927 }
80928
80929
80930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
80931   void * jresult ;
80932   Dali::BaseHandle arg1 ;
80933   Dali::BaseHandle *argp1 ;
80934   Dali::Toolkit::VideoView result;
80935
80936   argp1 = (Dali::BaseHandle *)jarg1;
80937   if (!argp1) {
80938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80939     return 0;
80940   }
80941   arg1 = *argp1;
80942   {
80943     try {
80944       result = Dali::Toolkit::VideoView::DownCast(arg1);
80945     } catch (std::out_of_range& e) {
80946       {
80947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80948       };
80949     } catch (std::exception& e) {
80950       {
80951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80952       };
80953     } catch (...) {
80954       {
80955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80956       };
80957     }
80958   }
80959   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
80960   return jresult;
80961 }
80962
80963
80964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
80965   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
80966
80967   arg1 = (Dali::Toolkit::VideoView *)jarg1;
80968   {
80969     try {
80970       (arg1)->Play();
80971     } catch (std::out_of_range& e) {
80972       {
80973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80974       };
80975     } catch (std::exception& e) {
80976       {
80977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80978       };
80979     } catch (...) {
80980       {
80981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80982       };
80983     }
80984   }
80985 }
80986
80987
80988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
80989   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
80990
80991   arg1 = (Dali::Toolkit::VideoView *)jarg1;
80992   {
80993     try {
80994       (arg1)->Pause();
80995     } catch (std::out_of_range& e) {
80996       {
80997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80998       };
80999     } catch (std::exception& e) {
81000       {
81001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81002       };
81003     } catch (...) {
81004       {
81005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81006       };
81007     }
81008   }
81009 }
81010
81011
81012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
81013   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81014
81015   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81016   {
81017     try {
81018       (arg1)->Stop();
81019     } catch (std::out_of_range& e) {
81020       {
81021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81022       };
81023     } catch (std::exception& e) {
81024       {
81025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81026       };
81027     } catch (...) {
81028       {
81029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81030       };
81031     }
81032   }
81033 }
81034
81035
81036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
81037   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81038   int arg2 ;
81039
81040   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81041   arg2 = (int)jarg2;
81042   {
81043     try {
81044       (arg1)->Forward(arg2);
81045     } catch (std::out_of_range& e) {
81046       {
81047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81048       };
81049     } catch (std::exception& e) {
81050       {
81051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81052       };
81053     } catch (...) {
81054       {
81055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81056       };
81057     }
81058   }
81059 }
81060
81061
81062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
81063   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81064   int arg2 ;
81065
81066   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81067   arg2 = (int)jarg2;
81068   {
81069     try {
81070       (arg1)->Backward(arg2);
81071     } catch (std::out_of_range& e) {
81072       {
81073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81074       };
81075     } catch (std::exception& e) {
81076       {
81077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81078       };
81079     } catch (...) {
81080       {
81081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81082       };
81083     }
81084   }
81085 }
81086
81087
81088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
81089   void * jresult ;
81090   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81091   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
81092
81093   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81094   {
81095     try {
81096       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
81097     } catch (std::out_of_range& e) {
81098       {
81099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81100       };
81101     } catch (std::exception& e) {
81102       {
81103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81104       };
81105     } catch (...) {
81106       {
81107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81108       };
81109     }
81110   }
81111   jresult = (void *)result;
81112   return jresult;
81113 }
81114
81115
81116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
81117   int jresult ;
81118   int result;
81119
81120   result = (int)Dali::Toolkit::Popup::Property::TITLE;
81121   jresult = (int)result;
81122   return jresult;
81123 }
81124
81125
81126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
81127   int jresult ;
81128   int result;
81129
81130   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
81131   jresult = (int)result;
81132   return jresult;
81133 }
81134
81135
81136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
81137   int jresult ;
81138   int result;
81139
81140   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
81141   jresult = (int)result;
81142   return jresult;
81143 }
81144
81145
81146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
81147   int jresult ;
81148   int result;
81149
81150   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
81151   jresult = (int)result;
81152   return jresult;
81153 }
81154
81155
81156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
81157   int jresult ;
81158   int result;
81159
81160   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
81161   jresult = (int)result;
81162   return jresult;
81163 }
81164
81165
81166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
81167   int jresult ;
81168   int result;
81169
81170   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
81171   jresult = (int)result;
81172   return jresult;
81173 }
81174
81175
81176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
81177   int jresult ;
81178   int result;
81179
81180   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
81181   jresult = (int)result;
81182   return jresult;
81183 }
81184
81185
81186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
81187   int jresult ;
81188   int result;
81189
81190   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
81191   jresult = (int)result;
81192   return jresult;
81193 }
81194
81195
81196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
81197   int jresult ;
81198   int result;
81199
81200   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
81201   jresult = (int)result;
81202   return jresult;
81203 }
81204
81205
81206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
81207   int jresult ;
81208   int result;
81209
81210   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
81211   jresult = (int)result;
81212   return jresult;
81213 }
81214
81215
81216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
81217   int jresult ;
81218   int result;
81219
81220   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
81221   jresult = (int)result;
81222   return jresult;
81223 }
81224
81225
81226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
81227   int jresult ;
81228   int result;
81229
81230   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
81231   jresult = (int)result;
81232   return jresult;
81233 }
81234
81235
81236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
81237   int jresult ;
81238   int result;
81239
81240   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
81241   jresult = (int)result;
81242   return jresult;
81243 }
81244
81245
81246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
81247   int jresult ;
81248   int result;
81249
81250   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
81251   jresult = (int)result;
81252   return jresult;
81253 }
81254
81255
81256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
81257   int jresult ;
81258   int result;
81259
81260   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
81261   jresult = (int)result;
81262   return jresult;
81263 }
81264
81265
81266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
81267   int jresult ;
81268   int result;
81269
81270   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
81271   jresult = (int)result;
81272   return jresult;
81273 }
81274
81275
81276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
81277   int jresult ;
81278   int result;
81279
81280   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
81281   jresult = (int)result;
81282   return jresult;
81283 }
81284
81285
81286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
81287   int jresult ;
81288   int result;
81289
81290   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
81291   jresult = (int)result;
81292   return jresult;
81293 }
81294
81295
81296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
81297   int jresult ;
81298   int result;
81299
81300   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
81301   jresult = (int)result;
81302   return jresult;
81303 }
81304
81305
81306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
81307   int jresult ;
81308   int result;
81309
81310   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
81311   jresult = (int)result;
81312   return jresult;
81313 }
81314
81315
81316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
81317   int jresult ;
81318   int result;
81319
81320   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
81321   jresult = (int)result;
81322   return jresult;
81323 }
81324
81325
81326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
81327   void * jresult ;
81328   Dali::Toolkit::Popup::Property *result = 0 ;
81329
81330   {
81331     try {
81332       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
81333     } catch (std::out_of_range& e) {
81334       {
81335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81336       };
81337     } catch (std::exception& e) {
81338       {
81339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81340       };
81341     } catch (...) {
81342       {
81343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81344       };
81345     }
81346   }
81347   jresult = (void *)result;
81348   return jresult;
81349 }
81350
81351
81352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
81353   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
81354
81355   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
81356   {
81357     try {
81358       delete arg1;
81359     } catch (std::out_of_range& e) {
81360       {
81361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81362       };
81363     } catch (std::exception& e) {
81364       {
81365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81366       };
81367     } catch (...) {
81368       {
81369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81370       };
81371     }
81372   }
81373 }
81374
81375
81376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
81377   void * jresult ;
81378   Dali::Toolkit::Popup *result = 0 ;
81379
81380   {
81381     try {
81382       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
81383     } catch (std::out_of_range& e) {
81384       {
81385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81386       };
81387     } catch (std::exception& e) {
81388       {
81389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81390       };
81391     } catch (...) {
81392       {
81393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81394       };
81395     }
81396   }
81397   jresult = (void *)result;
81398   return jresult;
81399 }
81400
81401
81402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
81403   void * jresult ;
81404   Dali::Toolkit::Popup result;
81405
81406   {
81407     try {
81408       result = Dali::Toolkit::Popup::New();
81409     } catch (std::out_of_range& e) {
81410       {
81411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81412       };
81413     } catch (std::exception& e) {
81414       {
81415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81416       };
81417     } catch (...) {
81418       {
81419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81420       };
81421     }
81422   }
81423   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81424   return jresult;
81425 }
81426
81427
81428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
81429   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81430
81431   arg1 = (Dali::Toolkit::Popup *)jarg1;
81432   {
81433     try {
81434       delete arg1;
81435     } catch (std::out_of_range& e) {
81436       {
81437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81438       };
81439     } catch (std::exception& e) {
81440       {
81441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81442       };
81443     } catch (...) {
81444       {
81445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81446       };
81447     }
81448   }
81449 }
81450
81451
81452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
81453   void * jresult ;
81454   Dali::Toolkit::Popup *arg1 = 0 ;
81455   Dali::Toolkit::Popup *result = 0 ;
81456
81457   arg1 = (Dali::Toolkit::Popup *)jarg1;
81458   if (!arg1) {
81459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81460     return 0;
81461   }
81462   {
81463     try {
81464       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
81465     } catch (std::out_of_range& e) {
81466       {
81467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81468       };
81469     } catch (std::exception& e) {
81470       {
81471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81472       };
81473     } catch (...) {
81474       {
81475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81476       };
81477     }
81478   }
81479   jresult = (void *)result;
81480   return jresult;
81481 }
81482
81483
81484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
81485   void * jresult ;
81486   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81487   Dali::Toolkit::Popup *arg2 = 0 ;
81488   Dali::Toolkit::Popup *result = 0 ;
81489
81490   arg1 = (Dali::Toolkit::Popup *)jarg1;
81491   arg2 = (Dali::Toolkit::Popup *)jarg2;
81492   if (!arg2) {
81493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81494     return 0;
81495   }
81496   {
81497     try {
81498       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
81499     } catch (std::out_of_range& e) {
81500       {
81501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81502       };
81503     } catch (std::exception& e) {
81504       {
81505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81506       };
81507     } catch (...) {
81508       {
81509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81510       };
81511     }
81512   }
81513   jresult = (void *)result;
81514   return jresult;
81515 }
81516
81517
81518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
81519   void * jresult ;
81520   Dali::BaseHandle arg1 ;
81521   Dali::BaseHandle *argp1 ;
81522   Dali::Toolkit::Popup result;
81523
81524   argp1 = (Dali::BaseHandle *)jarg1;
81525   if (!argp1) {
81526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81527     return 0;
81528   }
81529   arg1 = *argp1;
81530   {
81531     try {
81532       result = Dali::Toolkit::Popup::DownCast(arg1);
81533     } catch (std::out_of_range& e) {
81534       {
81535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81536       };
81537     } catch (std::exception& e) {
81538       {
81539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81540       };
81541     } catch (...) {
81542       {
81543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81544       };
81545     }
81546   }
81547   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81548   return jresult;
81549 }
81550
81551
81552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
81553   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81554   Dali::Actor arg2 ;
81555   Dali::Actor *argp2 ;
81556
81557   arg1 = (Dali::Toolkit::Popup *)jarg1;
81558   argp2 = (Dali::Actor *)jarg2;
81559   if (!argp2) {
81560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81561     return ;
81562   }
81563   arg2 = *argp2;
81564   {
81565     try {
81566       (arg1)->SetTitle(arg2);
81567     } catch (std::out_of_range& e) {
81568       {
81569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81570       };
81571     } catch (std::exception& e) {
81572       {
81573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81574       };
81575     } catch (...) {
81576       {
81577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81578       };
81579     }
81580   }
81581 }
81582
81583
81584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
81585   void * jresult ;
81586   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81587   Dali::Actor result;
81588
81589   arg1 = (Dali::Toolkit::Popup *)jarg1;
81590   {
81591     try {
81592       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
81593     } catch (std::out_of_range& e) {
81594       {
81595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81596       };
81597     } catch (std::exception& e) {
81598       {
81599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81600       };
81601     } catch (...) {
81602       {
81603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81604       };
81605     }
81606   }
81607   jresult = new Dali::Actor((const Dali::Actor &)result);
81608   return jresult;
81609 }
81610
81611
81612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
81613   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81614   Dali::Actor arg2 ;
81615   Dali::Actor *argp2 ;
81616
81617   arg1 = (Dali::Toolkit::Popup *)jarg1;
81618   argp2 = (Dali::Actor *)jarg2;
81619   if (!argp2) {
81620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81621     return ;
81622   }
81623   arg2 = *argp2;
81624   {
81625     try {
81626       (arg1)->SetContent(arg2);
81627     } catch (std::out_of_range& e) {
81628       {
81629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81630       };
81631     } catch (std::exception& e) {
81632       {
81633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81634       };
81635     } catch (...) {
81636       {
81637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81638       };
81639     }
81640   }
81641 }
81642
81643
81644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
81645   void * jresult ;
81646   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81647   Dali::Actor result;
81648
81649   arg1 = (Dali::Toolkit::Popup *)jarg1;
81650   {
81651     try {
81652       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
81653     } catch (std::out_of_range& e) {
81654       {
81655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81656       };
81657     } catch (std::exception& e) {
81658       {
81659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81660       };
81661     } catch (...) {
81662       {
81663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81664       };
81665     }
81666   }
81667   jresult = new Dali::Actor((const Dali::Actor &)result);
81668   return jresult;
81669 }
81670
81671
81672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
81673   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81674   Dali::Actor arg2 ;
81675   Dali::Actor *argp2 ;
81676
81677   arg1 = (Dali::Toolkit::Popup *)jarg1;
81678   argp2 = (Dali::Actor *)jarg2;
81679   if (!argp2) {
81680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81681     return ;
81682   }
81683   arg2 = *argp2;
81684   {
81685     try {
81686       (arg1)->SetFooter(arg2);
81687     } catch (std::out_of_range& e) {
81688       {
81689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81690       };
81691     } catch (std::exception& e) {
81692       {
81693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81694       };
81695     } catch (...) {
81696       {
81697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81698       };
81699     }
81700   }
81701 }
81702
81703
81704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
81705   void * jresult ;
81706   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81707   Dali::Actor result;
81708
81709   arg1 = (Dali::Toolkit::Popup *)jarg1;
81710   {
81711     try {
81712       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
81713     } catch (std::out_of_range& e) {
81714       {
81715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81716       };
81717     } catch (std::exception& e) {
81718       {
81719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81720       };
81721     } catch (...) {
81722       {
81723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81724       };
81725     }
81726   }
81727   jresult = new Dali::Actor((const Dali::Actor &)result);
81728   return jresult;
81729 }
81730
81731
81732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
81733   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81734   Dali::Toolkit::Popup::DisplayState arg2 ;
81735
81736   arg1 = (Dali::Toolkit::Popup *)jarg1;
81737   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
81738   {
81739     try {
81740       (arg1)->SetDisplayState(arg2);
81741     } catch (std::out_of_range& e) {
81742       {
81743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81744       };
81745     } catch (std::exception& e) {
81746       {
81747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81748       };
81749     } catch (...) {
81750       {
81751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81752       };
81753     }
81754   }
81755 }
81756
81757
81758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
81759   int jresult ;
81760   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81761   Dali::Toolkit::Popup::DisplayState result;
81762
81763   arg1 = (Dali::Toolkit::Popup *)jarg1;
81764   {
81765     try {
81766       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
81767     } catch (std::out_of_range& e) {
81768       {
81769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81770       };
81771     } catch (std::exception& e) {
81772       {
81773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81774       };
81775     } catch (...) {
81776       {
81777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81778       };
81779     }
81780   }
81781   jresult = (int)result;
81782   return jresult;
81783 }
81784
81785
81786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
81787   void * jresult ;
81788   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81789   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
81790
81791   arg1 = (Dali::Toolkit::Popup *)jarg1;
81792   {
81793     try {
81794       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
81795     } catch (std::out_of_range& e) {
81796       {
81797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81798       };
81799     } catch (std::exception& e) {
81800       {
81801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81802       };
81803     } catch (...) {
81804       {
81805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81806       };
81807     }
81808   }
81809   jresult = (void *)result;
81810   return jresult;
81811 }
81812
81813
81814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
81815   void * jresult ;
81816   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81817   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
81818
81819   arg1 = (Dali::Toolkit::Popup *)jarg1;
81820   {
81821     try {
81822       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
81823     } catch (std::out_of_range& e) {
81824       {
81825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81826       };
81827     } catch (std::exception& e) {
81828       {
81829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81830       };
81831     } catch (...) {
81832       {
81833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81834       };
81835     }
81836   }
81837   jresult = (void *)result;
81838   return jresult;
81839 }
81840
81841
81842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
81843   void * jresult ;
81844   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81845   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
81846
81847   arg1 = (Dali::Toolkit::Popup *)jarg1;
81848   {
81849     try {
81850       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
81851     } catch (std::out_of_range& e) {
81852       {
81853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81854       };
81855     } catch (std::exception& e) {
81856       {
81857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81858       };
81859     } catch (...) {
81860       {
81861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81862       };
81863     }
81864   }
81865   jresult = (void *)result;
81866   return jresult;
81867 }
81868
81869
81870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
81871   void * jresult ;
81872   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81873   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
81874
81875   arg1 = (Dali::Toolkit::Popup *)jarg1;
81876   {
81877     try {
81878       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
81879     } catch (std::out_of_range& e) {
81880       {
81881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81882       };
81883     } catch (std::exception& e) {
81884       {
81885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81886       };
81887     } catch (...) {
81888       {
81889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81890       };
81891     }
81892   }
81893   jresult = (void *)result;
81894   return jresult;
81895 }
81896
81897
81898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
81899   void * jresult ;
81900   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81901   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
81902
81903   arg1 = (Dali::Toolkit::Popup *)jarg1;
81904   {
81905     try {
81906       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
81907     } catch (std::out_of_range& e) {
81908       {
81909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81910       };
81911     } catch (std::exception& e) {
81912       {
81913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81914       };
81915     } catch (...) {
81916       {
81917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81918       };
81919     }
81920   }
81921   jresult = (void *)result;
81922   return jresult;
81923 }
81924
81925
81926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
81927   int jresult ;
81928   int result;
81929
81930   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
81931   jresult = (int)result;
81932   return jresult;
81933 }
81934
81935
81936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
81937   int jresult ;
81938   int result;
81939
81940   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
81941   jresult = (int)result;
81942   return jresult;
81943 }
81944
81945
81946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
81947   int jresult ;
81948   int result;
81949
81950   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
81951   jresult = (int)result;
81952   return jresult;
81953 }
81954
81955
81956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
81957   int jresult ;
81958   int result;
81959
81960   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
81961   jresult = (int)result;
81962   return jresult;
81963 }
81964
81965
81966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
81967   int jresult ;
81968   int result;
81969
81970   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
81971   jresult = (int)result;
81972   return jresult;
81973 }
81974
81975
81976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
81977   int jresult ;
81978   int result;
81979
81980   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
81981   jresult = (int)result;
81982   return jresult;
81983 }
81984
81985
81986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
81987   int jresult ;
81988   int result;
81989
81990   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
81991   jresult = (int)result;
81992   return jresult;
81993 }
81994
81995
81996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
81997   int jresult ;
81998   int result;
81999
82000   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
82001   jresult = (int)result;
82002   return jresult;
82003 }
82004
82005
82006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
82007   int jresult ;
82008   int result;
82009
82010   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
82011   jresult = (int)result;
82012   return jresult;
82013 }
82014
82015
82016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
82017   void * jresult ;
82018   Dali::Toolkit::ProgressBar::Property *result = 0 ;
82019
82020   {
82021     try {
82022       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
82023     } catch (std::out_of_range& e) {
82024       {
82025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82026       };
82027     } catch (std::exception& e) {
82028       {
82029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82030       };
82031     } catch (...) {
82032       {
82033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82034       };
82035     }
82036   }
82037   jresult = (void *)result;
82038   return jresult;
82039 }
82040
82041
82042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
82043   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
82044
82045   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
82046   {
82047     try {
82048       delete arg1;
82049     } catch (std::out_of_range& e) {
82050       {
82051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82052       };
82053     } catch (std::exception& e) {
82054       {
82055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82056       };
82057     } catch (...) {
82058       {
82059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82060       };
82061     }
82062   }
82063 }
82064
82065
82066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
82067   void * jresult ;
82068   Dali::Toolkit::ProgressBar result;
82069
82070   {
82071     try {
82072       result = Dali::Toolkit::ProgressBar::New();
82073     } catch (std::out_of_range& e) {
82074       {
82075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82076       };
82077     } catch (std::exception& e) {
82078       {
82079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82080       };
82081     } catch (...) {
82082       {
82083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82084       };
82085     }
82086   }
82087   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82088   return jresult;
82089 }
82090
82091
82092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
82093   void * jresult ;
82094   Dali::Toolkit::ProgressBar *result = 0 ;
82095
82096   {
82097     try {
82098       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
82099     } catch (std::out_of_range& e) {
82100       {
82101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82102       };
82103     } catch (std::exception& e) {
82104       {
82105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82106       };
82107     } catch (...) {
82108       {
82109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82110       };
82111     }
82112   }
82113   jresult = (void *)result;
82114   return jresult;
82115 }
82116
82117
82118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
82119   void * jresult ;
82120   Dali::Toolkit::ProgressBar *arg1 = 0 ;
82121   Dali::Toolkit::ProgressBar *result = 0 ;
82122
82123   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82124   if (!arg1) {
82125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82126     return 0;
82127   }
82128   {
82129     try {
82130       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
82131     } catch (std::out_of_range& e) {
82132       {
82133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82134       };
82135     } catch (std::exception& e) {
82136       {
82137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82138       };
82139     } catch (...) {
82140       {
82141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82142       };
82143     }
82144   }
82145   jresult = (void *)result;
82146   return jresult;
82147 }
82148
82149
82150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
82151   void * jresult ;
82152   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82153   Dali::Toolkit::ProgressBar *arg2 = 0 ;
82154   Dali::Toolkit::ProgressBar *result = 0 ;
82155
82156   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82157   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
82158   if (!arg2) {
82159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82160     return 0;
82161   }
82162   {
82163     try {
82164       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
82165     } catch (std::out_of_range& e) {
82166       {
82167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82168       };
82169     } catch (std::exception& e) {
82170       {
82171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82172       };
82173     } catch (...) {
82174       {
82175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82176       };
82177     }
82178   }
82179   jresult = (void *)result;
82180   return jresult;
82181 }
82182
82183
82184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
82185   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82186
82187   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82188   {
82189     try {
82190       delete arg1;
82191     } catch (std::out_of_range& e) {
82192       {
82193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82194       };
82195     } catch (std::exception& e) {
82196       {
82197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82198       };
82199     } catch (...) {
82200       {
82201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82202       };
82203     }
82204   }
82205 }
82206
82207
82208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
82209   void * jresult ;
82210   Dali::BaseHandle arg1 ;
82211   Dali::BaseHandle *argp1 ;
82212   Dali::Toolkit::ProgressBar result;
82213
82214   argp1 = (Dali::BaseHandle *)jarg1;
82215   if (!argp1) {
82216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82217     return 0;
82218   }
82219   arg1 = *argp1;
82220   {
82221     try {
82222       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
82223     } catch (std::out_of_range& e) {
82224       {
82225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82226       };
82227     } catch (std::exception& e) {
82228       {
82229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82230       };
82231     } catch (...) {
82232       {
82233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82234       };
82235     }
82236   }
82237   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82238   return jresult;
82239 }
82240
82241
82242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
82243   void * jresult ;
82244   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82245   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
82246
82247   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82248   {
82249     try {
82250       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82251     } catch (std::out_of_range& e) {
82252       {
82253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82254       };
82255     } catch (std::exception& e) {
82256       {
82257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82258       };
82259     } catch (...) {
82260       {
82261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82262       };
82263     }
82264   }
82265   jresult = (void *)result;
82266   return jresult;
82267 }
82268
82269
82270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
82271   void * jresult ;
82272   Dali::Toolkit::GaussianBlurView *result = 0 ;
82273
82274   {
82275     try {
82276       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
82277     } catch (std::out_of_range& e) {
82278       {
82279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82280       };
82281     } catch (std::exception& e) {
82282       {
82283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82284       };
82285     } catch (...) {
82286       {
82287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82288       };
82289     }
82290   }
82291   jresult = (void *)result;
82292   return jresult;
82293 }
82294
82295
82296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
82297   void * jresult ;
82298   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
82299   Dali::Toolkit::GaussianBlurView *result = 0 ;
82300
82301   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82302   if (!arg1) {
82303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82304     return 0;
82305   }
82306   {
82307     try {
82308       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
82309     } catch (std::out_of_range& e) {
82310       {
82311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82312       };
82313     } catch (std::exception& e) {
82314       {
82315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82316       };
82317     } catch (...) {
82318       {
82319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82320       };
82321     }
82322   }
82323   jresult = (void *)result;
82324   return jresult;
82325 }
82326
82327
82328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
82329   void * jresult ;
82330   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82331   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
82332   Dali::Toolkit::GaussianBlurView *result = 0 ;
82333
82334   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82335   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
82336   if (!arg2) {
82337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82338     return 0;
82339   }
82340   {
82341     try {
82342       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
82343     } catch (std::out_of_range& e) {
82344       {
82345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82346       };
82347     } catch (std::exception& e) {
82348       {
82349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82350       };
82351     } catch (...) {
82352       {
82353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82354       };
82355     }
82356   }
82357   jresult = (void *)result;
82358   return jresult;
82359 }
82360
82361
82362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
82363   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82364
82365   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82366   {
82367     try {
82368       delete arg1;
82369     } catch (std::out_of_range& e) {
82370       {
82371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82372       };
82373     } catch (std::exception& e) {
82374       {
82375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82376       };
82377     } catch (...) {
82378       {
82379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82380       };
82381     }
82382   }
82383 }
82384
82385
82386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
82387   void * jresult ;
82388   Dali::BaseHandle arg1 ;
82389   Dali::BaseHandle *argp1 ;
82390   Dali::Toolkit::GaussianBlurView result;
82391
82392   argp1 = (Dali::BaseHandle *)jarg1;
82393   if (!argp1) {
82394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82395     return 0;
82396   }
82397   arg1 = *argp1;
82398   {
82399     try {
82400       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
82401     } catch (std::out_of_range& e) {
82402       {
82403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82404       };
82405     } catch (std::exception& e) {
82406       {
82407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82408       };
82409     } catch (...) {
82410       {
82411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82412       };
82413     }
82414   }
82415   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82416   return jresult;
82417 }
82418
82419
82420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
82421   void * jresult ;
82422   Dali::Toolkit::GaussianBlurView result;
82423
82424   {
82425     try {
82426       result = Dali::Toolkit::GaussianBlurView::New();
82427     } catch (std::out_of_range& e) {
82428       {
82429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82430       };
82431     } catch (std::exception& e) {
82432       {
82433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82434       };
82435     } catch (...) {
82436       {
82437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82438       };
82439     }
82440   }
82441   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82442   return jresult;
82443 }
82444
82445
82446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
82447   void * jresult ;
82448   unsigned int arg1 ;
82449   float arg2 ;
82450   Dali::Pixel::Format arg3 ;
82451   float arg4 ;
82452   float arg5 ;
82453   bool arg6 ;
82454   Dali::Toolkit::GaussianBlurView result;
82455
82456   arg1 = (unsigned int)jarg1;
82457   arg2 = (float)jarg2;
82458   arg3 = (Dali::Pixel::Format)jarg3;
82459   arg4 = (float)jarg4;
82460   arg5 = (float)jarg5;
82461   arg6 = jarg6 ? true : false;
82462   {
82463     try {
82464       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
82465     } catch (std::out_of_range& e) {
82466       {
82467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82468       };
82469     } catch (std::exception& e) {
82470       {
82471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82472       };
82473     } catch (...) {
82474       {
82475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82476       };
82477     }
82478   }
82479   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82480   return jresult;
82481 }
82482
82483
82484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
82485   void * jresult ;
82486   unsigned int arg1 ;
82487   float arg2 ;
82488   Dali::Pixel::Format arg3 ;
82489   float arg4 ;
82490   float arg5 ;
82491   Dali::Toolkit::GaussianBlurView result;
82492
82493   arg1 = (unsigned int)jarg1;
82494   arg2 = (float)jarg2;
82495   arg3 = (Dali::Pixel::Format)jarg3;
82496   arg4 = (float)jarg4;
82497   arg5 = (float)jarg5;
82498   {
82499     try {
82500       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
82501     } catch (std::out_of_range& e) {
82502       {
82503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82504       };
82505     } catch (std::exception& e) {
82506       {
82507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82508       };
82509     } catch (...) {
82510       {
82511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82512       };
82513     }
82514   }
82515   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82516   return jresult;
82517 }
82518
82519
82520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
82521   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82522   Dali::Actor arg2 ;
82523   Dali::Actor *argp2 ;
82524
82525   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82526   argp2 = (Dali::Actor *)jarg2;
82527   if (!argp2) {
82528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82529     return ;
82530   }
82531   arg2 = *argp2;
82532   {
82533     try {
82534       (arg1)->Add(arg2);
82535     } catch (std::out_of_range& e) {
82536       {
82537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82538       };
82539     } catch (std::exception& e) {
82540       {
82541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82542       };
82543     } catch (...) {
82544       {
82545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82546       };
82547     }
82548   }
82549 }
82550
82551
82552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
82553   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82554   Dali::Actor arg2 ;
82555   Dali::Actor *argp2 ;
82556
82557   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82558   argp2 = (Dali::Actor *)jarg2;
82559   if (!argp2) {
82560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82561     return ;
82562   }
82563   arg2 = *argp2;
82564   {
82565     try {
82566       (arg1)->Remove(arg2);
82567     } catch (std::out_of_range& e) {
82568       {
82569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82570       };
82571     } catch (std::exception& e) {
82572       {
82573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82574       };
82575     } catch (...) {
82576       {
82577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82578       };
82579     }
82580   }
82581 }
82582
82583
82584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
82585   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82586
82587   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82588   {
82589     try {
82590       (arg1)->Activate();
82591     } catch (std::out_of_range& e) {
82592       {
82593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82594       };
82595     } catch (std::exception& e) {
82596       {
82597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82598       };
82599     } catch (...) {
82600       {
82601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82602       };
82603     }
82604   }
82605 }
82606
82607
82608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
82609   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82610
82611   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82612   {
82613     try {
82614       (arg1)->ActivateOnce();
82615     } catch (std::out_of_range& e) {
82616       {
82617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82618       };
82619     } catch (std::exception& e) {
82620       {
82621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82622       };
82623     } catch (...) {
82624       {
82625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82626       };
82627     }
82628   }
82629 }
82630
82631
82632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
82633   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82634
82635   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82636   {
82637     try {
82638       (arg1)->Deactivate();
82639     } catch (std::out_of_range& e) {
82640       {
82641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82642       };
82643     } catch (std::exception& e) {
82644       {
82645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82646       };
82647     } catch (...) {
82648       {
82649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82650       };
82651     }
82652   }
82653 }
82654
82655
82656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
82657   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82658   Dali::Image arg2 ;
82659   Dali::FrameBufferImage arg3 ;
82660   Dali::Image *argp2 ;
82661   Dali::FrameBufferImage *argp3 ;
82662
82663   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82664   argp2 = (Dali::Image *)jarg2;
82665   if (!argp2) {
82666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
82667     return ;
82668   }
82669   arg2 = *argp2;
82670   argp3 = (Dali::FrameBufferImage *)jarg3;
82671   if (!argp3) {
82672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
82673     return ;
82674   }
82675   arg3 = *argp3;
82676   {
82677     try {
82678       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
82679     } catch (std::out_of_range& e) {
82680       {
82681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82682       };
82683     } catch (std::exception& e) {
82684       {
82685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82686       };
82687     } catch (...) {
82688       {
82689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82690       };
82691     }
82692   }
82693 }
82694
82695
82696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
82697   int jresult ;
82698   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82699   Dali::Property::Index result;
82700
82701   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82702   {
82703     try {
82704       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
82705     } catch (std::out_of_range& e) {
82706       {
82707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82708       };
82709     } catch (std::exception& e) {
82710       {
82711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82712       };
82713     } catch (...) {
82714       {
82715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82716       };
82717     }
82718   }
82719   jresult = result;
82720   return jresult;
82721 }
82722
82723
82724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
82725   void * jresult ;
82726   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82727   Dali::FrameBufferImage result;
82728
82729   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82730   {
82731     try {
82732       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
82733     } catch (std::out_of_range& e) {
82734       {
82735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82736       };
82737     } catch (std::exception& e) {
82738       {
82739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82740       };
82741     } catch (...) {
82742       {
82743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82744       };
82745     }
82746   }
82747   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
82748   return jresult;
82749 }
82750
82751
82752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
82753   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82754   Dali::Vector4 *arg2 = 0 ;
82755
82756   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82757   arg2 = (Dali::Vector4 *)jarg2;
82758   if (!arg2) {
82759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
82760     return ;
82761   }
82762   {
82763     try {
82764       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
82765     } catch (std::out_of_range& e) {
82766       {
82767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82768       };
82769     } catch (std::exception& e) {
82770       {
82771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82772       };
82773     } catch (...) {
82774       {
82775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82776       };
82777     }
82778   }
82779 }
82780
82781
82782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
82783   void * jresult ;
82784   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82785   Dali::Vector4 result;
82786
82787   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82788   {
82789     try {
82790       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
82791     } catch (std::out_of_range& e) {
82792       {
82793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82794       };
82795     } catch (std::exception& e) {
82796       {
82797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82798       };
82799     } catch (...) {
82800       {
82801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82802       };
82803     }
82804   }
82805   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
82806   return jresult;
82807 }
82808
82809
82810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
82811   void * jresult ;
82812   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82813   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
82814
82815   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82816   {
82817     try {
82818       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
82819     } catch (std::out_of_range& e) {
82820       {
82821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82822       };
82823     } catch (std::exception& e) {
82824       {
82825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82826       };
82827     } catch (...) {
82828       {
82829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82830       };
82831     }
82832   }
82833   jresult = (void *)result;
82834   return jresult;
82835 }
82836
82837
82838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
82839   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
82840
82841   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
82842   {
82843     try {
82844       delete arg1;
82845     } catch (std::out_of_range& e) {
82846       {
82847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82848       };
82849     } catch (std::exception& e) {
82850       {
82851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82852       };
82853     } catch (...) {
82854       {
82855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82856       };
82857     }
82858   }
82859 }
82860
82861
82862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
82863   unsigned int jresult ;
82864   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
82865   unsigned int result;
82866
82867   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
82868   {
82869     try {
82870       result = (unsigned int)(arg1)->GetNumberOfPages();
82871     } catch (std::out_of_range& e) {
82872       {
82873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82874       };
82875     } catch (std::exception& e) {
82876       {
82877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82878       };
82879     } catch (...) {
82880       {
82881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82882       };
82883     }
82884   }
82885   jresult = result;
82886   return jresult;
82887 }
82888
82889
82890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
82891   void * jresult ;
82892   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
82893   unsigned int arg2 ;
82894   Dali::Texture result;
82895
82896   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
82897   arg2 = (unsigned int)jarg2;
82898   {
82899     try {
82900       result = (arg1)->NewPage(arg2);
82901     } catch (std::out_of_range& e) {
82902       {
82903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82904       };
82905     } catch (std::exception& e) {
82906       {
82907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82908       };
82909     } catch (...) {
82910       {
82911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82912       };
82913     }
82914   }
82915   jresult = new Dali::Texture((const Dali::Texture &)result);
82916   return jresult;
82917 }
82918
82919
82920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
82921   int jresult ;
82922   int result;
82923
82924   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
82925   jresult = (int)result;
82926   return jresult;
82927 }
82928
82929
82930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
82931   int jresult ;
82932   int result;
82933
82934   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
82935   jresult = (int)result;
82936   return jresult;
82937 }
82938
82939
82940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
82941   int jresult ;
82942   int result;
82943
82944   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
82945   jresult = (int)result;
82946   return jresult;
82947 }
82948
82949
82950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
82951   void * jresult ;
82952   Dali::Toolkit::PageTurnView::Property *result = 0 ;
82953
82954   {
82955     try {
82956       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
82957     } catch (std::out_of_range& e) {
82958       {
82959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82960       };
82961     } catch (std::exception& e) {
82962       {
82963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82964       };
82965     } catch (...) {
82966       {
82967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82968       };
82969     }
82970   }
82971   jresult = (void *)result;
82972   return jresult;
82973 }
82974
82975
82976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
82977   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
82978
82979   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
82980   {
82981     try {
82982       delete arg1;
82983     } catch (std::out_of_range& e) {
82984       {
82985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82986       };
82987     } catch (std::exception& e) {
82988       {
82989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82990       };
82991     } catch (...) {
82992       {
82993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82994       };
82995     }
82996   }
82997 }
82998
82999
83000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
83001   void * jresult ;
83002   Dali::Toolkit::PageTurnView *result = 0 ;
83003
83004   {
83005     try {
83006       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
83007     } catch (std::out_of_range& e) {
83008       {
83009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83010       };
83011     } catch (std::exception& e) {
83012       {
83013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83014       };
83015     } catch (...) {
83016       {
83017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83018       };
83019     }
83020   }
83021   jresult = (void *)result;
83022   return jresult;
83023 }
83024
83025
83026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
83027   void * jresult ;
83028   Dali::Toolkit::PageTurnView *arg1 = 0 ;
83029   Dali::Toolkit::PageTurnView *result = 0 ;
83030
83031   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83032   if (!arg1) {
83033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83034     return 0;
83035   }
83036   {
83037     try {
83038       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
83039     } catch (std::out_of_range& e) {
83040       {
83041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83042       };
83043     } catch (std::exception& e) {
83044       {
83045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83046       };
83047     } catch (...) {
83048       {
83049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83050       };
83051     }
83052   }
83053   jresult = (void *)result;
83054   return jresult;
83055 }
83056
83057
83058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
83059   void * jresult ;
83060   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83061   Dali::Toolkit::PageTurnView *arg2 = 0 ;
83062   Dali::Toolkit::PageTurnView *result = 0 ;
83063
83064   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83065   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
83066   if (!arg2) {
83067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83068     return 0;
83069   }
83070   {
83071     try {
83072       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
83073     } catch (std::out_of_range& e) {
83074       {
83075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83076       };
83077     } catch (std::exception& e) {
83078       {
83079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83080       };
83081     } catch (...) {
83082       {
83083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83084       };
83085     }
83086   }
83087   jresult = (void *)result;
83088   return jresult;
83089 }
83090
83091
83092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
83093   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83094
83095   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83096   {
83097     try {
83098       delete arg1;
83099     } catch (std::out_of_range& e) {
83100       {
83101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83102       };
83103     } catch (std::exception& e) {
83104       {
83105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83106       };
83107     } catch (...) {
83108       {
83109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83110       };
83111     }
83112   }
83113 }
83114
83115
83116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
83117   void * jresult ;
83118   Dali::BaseHandle arg1 ;
83119   Dali::BaseHandle *argp1 ;
83120   Dali::Toolkit::PageTurnView result;
83121
83122   argp1 = (Dali::BaseHandle *)jarg1;
83123   if (!argp1) {
83124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83125     return 0;
83126   }
83127   arg1 = *argp1;
83128   {
83129     try {
83130       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
83131     } catch (std::out_of_range& e) {
83132       {
83133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83134       };
83135     } catch (std::exception& e) {
83136       {
83137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83138       };
83139     } catch (...) {
83140       {
83141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83142       };
83143     }
83144   }
83145   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
83146   return jresult;
83147 }
83148
83149
83150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
83151   void * jresult ;
83152   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83153   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83154
83155   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83156   {
83157     try {
83158       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
83159     } catch (std::out_of_range& e) {
83160       {
83161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83162       };
83163     } catch (std::exception& e) {
83164       {
83165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83166       };
83167     } catch (...) {
83168       {
83169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83170       };
83171     }
83172   }
83173   jresult = (void *)result;
83174   return jresult;
83175 }
83176
83177
83178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
83179   void * jresult ;
83180   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83181   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83182
83183   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83184   {
83185     try {
83186       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
83187     } catch (std::out_of_range& e) {
83188       {
83189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83190       };
83191     } catch (std::exception& e) {
83192       {
83193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83194       };
83195     } catch (...) {
83196       {
83197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83198       };
83199     }
83200   }
83201   jresult = (void *)result;
83202   return jresult;
83203 }
83204
83205
83206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
83207   void * jresult ;
83208   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83209   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83210
83211   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83212   {
83213     try {
83214       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
83215     } catch (std::out_of_range& e) {
83216       {
83217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83218       };
83219     } catch (std::exception& e) {
83220       {
83221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83222       };
83223     } catch (...) {
83224       {
83225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83226       };
83227     }
83228   }
83229   jresult = (void *)result;
83230   return jresult;
83231 }
83232
83233
83234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
83235   void * jresult ;
83236   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83237   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83238
83239   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83240   {
83241     try {
83242       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
83243     } catch (std::out_of_range& e) {
83244       {
83245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83246       };
83247     } catch (std::exception& e) {
83248       {
83249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83250       };
83251     } catch (...) {
83252       {
83253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83254       };
83255     }
83256   }
83257   jresult = (void *)result;
83258   return jresult;
83259 }
83260
83261
83262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
83263   void * jresult ;
83264   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83265
83266   {
83267     try {
83268       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
83269     } catch (std::out_of_range& e) {
83270       {
83271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83272       };
83273     } catch (std::exception& e) {
83274       {
83275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83276       };
83277     } catch (...) {
83278       {
83279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83280       };
83281     }
83282   }
83283   jresult = (void *)result;
83284   return jresult;
83285 }
83286
83287
83288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
83289   void * jresult ;
83290   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
83291   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83292
83293   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83294   if (!arg1) {
83295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83296     return 0;
83297   }
83298   {
83299     try {
83300       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
83301     } catch (std::out_of_range& e) {
83302       {
83303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83304       };
83305     } catch (std::exception& e) {
83306       {
83307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83308       };
83309     } catch (...) {
83310       {
83311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83312       };
83313     }
83314   }
83315   jresult = (void *)result;
83316   return jresult;
83317 }
83318
83319
83320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
83321   void * jresult ;
83322   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83323   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
83324   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83325
83326   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83327   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
83328   if (!arg2) {
83329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83330     return 0;
83331   }
83332   {
83333     try {
83334       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
83335     } catch (std::out_of_range& e) {
83336       {
83337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83338       };
83339     } catch (std::exception& e) {
83340       {
83341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83342       };
83343     } catch (...) {
83344       {
83345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83346       };
83347     }
83348   }
83349   jresult = (void *)result;
83350   return jresult;
83351 }
83352
83353
83354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
83355   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83356
83357   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83358   {
83359     try {
83360       delete arg1;
83361     } catch (std::out_of_range& e) {
83362       {
83363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83364       };
83365     } catch (std::exception& e) {
83366       {
83367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83368       };
83369     } catch (...) {
83370       {
83371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83372       };
83373     }
83374   }
83375 }
83376
83377
83378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
83379   void * jresult ;
83380   Dali::Toolkit::PageFactory *arg1 = 0 ;
83381   Dali::Vector2 *arg2 = 0 ;
83382   Dali::Toolkit::PageTurnLandscapeView result;
83383
83384   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83385   if (!arg1) {
83386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83387     return 0;
83388   }
83389   arg2 = (Dali::Vector2 *)jarg2;
83390   if (!arg2) {
83391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83392     return 0;
83393   }
83394   {
83395     try {
83396       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
83397     } catch (std::out_of_range& e) {
83398       {
83399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83400       };
83401     } catch (std::exception& e) {
83402       {
83403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83404       };
83405     } catch (...) {
83406       {
83407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83408       };
83409     }
83410   }
83411   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83412   return jresult;
83413 }
83414
83415
83416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
83417   void * jresult ;
83418   Dali::BaseHandle arg1 ;
83419   Dali::BaseHandle *argp1 ;
83420   Dali::Toolkit::PageTurnLandscapeView result;
83421
83422   argp1 = (Dali::BaseHandle *)jarg1;
83423   if (!argp1) {
83424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83425     return 0;
83426   }
83427   arg1 = *argp1;
83428   {
83429     try {
83430       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
83431     } catch (std::out_of_range& e) {
83432       {
83433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83434       };
83435     } catch (std::exception& e) {
83436       {
83437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83438       };
83439     } catch (...) {
83440       {
83441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83442       };
83443     }
83444   }
83445   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83446   return jresult;
83447 }
83448
83449
83450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
83451   void * jresult ;
83452   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83453
83454   {
83455     try {
83456       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
83457     } catch (std::out_of_range& e) {
83458       {
83459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83460       };
83461     } catch (std::exception& e) {
83462       {
83463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83464       };
83465     } catch (...) {
83466       {
83467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83468       };
83469     }
83470   }
83471   jresult = (void *)result;
83472   return jresult;
83473 }
83474
83475
83476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
83477   void * jresult ;
83478   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
83479   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83480
83481   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83482   if (!arg1) {
83483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83484     return 0;
83485   }
83486   {
83487     try {
83488       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
83489     } catch (std::out_of_range& e) {
83490       {
83491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83492       };
83493     } catch (std::exception& e) {
83494       {
83495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83496       };
83497     } catch (...) {
83498       {
83499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83500       };
83501     }
83502   }
83503   jresult = (void *)result;
83504   return jresult;
83505 }
83506
83507
83508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
83509   void * jresult ;
83510   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83511   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
83512   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83513
83514   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83515   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
83516   if (!arg2) {
83517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83518     return 0;
83519   }
83520   {
83521     try {
83522       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
83523     } catch (std::out_of_range& e) {
83524       {
83525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83526       };
83527     } catch (std::exception& e) {
83528       {
83529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83530       };
83531     } catch (...) {
83532       {
83533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83534       };
83535     }
83536   }
83537   jresult = (void *)result;
83538   return jresult;
83539 }
83540
83541
83542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
83543   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83544
83545   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83546   {
83547     try {
83548       delete arg1;
83549     } catch (std::out_of_range& e) {
83550       {
83551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83552       };
83553     } catch (std::exception& e) {
83554       {
83555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83556       };
83557     } catch (...) {
83558       {
83559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83560       };
83561     }
83562   }
83563 }
83564
83565
83566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
83567   void * jresult ;
83568   Dali::Toolkit::PageFactory *arg1 = 0 ;
83569   Dali::Vector2 *arg2 = 0 ;
83570   Dali::Toolkit::PageTurnPortraitView result;
83571
83572   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83573   if (!arg1) {
83574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83575     return 0;
83576   }
83577   arg2 = (Dali::Vector2 *)jarg2;
83578   if (!arg2) {
83579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83580     return 0;
83581   }
83582   {
83583     try {
83584       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
83585     } catch (std::out_of_range& e) {
83586       {
83587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83588       };
83589     } catch (std::exception& e) {
83590       {
83591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83592       };
83593     } catch (...) {
83594       {
83595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83596       };
83597     }
83598   }
83599   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
83600   return jresult;
83601 }
83602
83603
83604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
83605   void * jresult ;
83606   Dali::BaseHandle arg1 ;
83607   Dali::BaseHandle *argp1 ;
83608   Dali::Toolkit::PageTurnPortraitView result;
83609
83610   argp1 = (Dali::BaseHandle *)jarg1;
83611   if (!argp1) {
83612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83613     return 0;
83614   }
83615   arg1 = *argp1;
83616   {
83617     try {
83618       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
83619     } catch (std::out_of_range& e) {
83620       {
83621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83622       };
83623     } catch (std::exception& e) {
83624       {
83625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83626       };
83627     } catch (...) {
83628       {
83629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83630       };
83631     }
83632   }
83633   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
83634   return jresult;
83635 }
83636
83637
83638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
83639   int jresult ;
83640   int result;
83641
83642   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
83643   jresult = (int)result;
83644   return jresult;
83645 }
83646
83647
83648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
83649   int jresult ;
83650   int result;
83651
83652   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
83653   jresult = (int)result;
83654   return jresult;
83655 }
83656
83657
83658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
83659   int jresult ;
83660   int result;
83661
83662   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
83663   jresult = (int)result;
83664   return jresult;
83665 }
83666
83667
83668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
83669   void * jresult ;
83670   Dali::Toolkit::ToggleButton::Property *result = 0 ;
83671
83672   {
83673     try {
83674       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
83675     } catch (std::out_of_range& e) {
83676       {
83677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83678       };
83679     } catch (std::exception& e) {
83680       {
83681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83682       };
83683     } catch (...) {
83684       {
83685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83686       };
83687     }
83688   }
83689   jresult = (void *)result;
83690   return jresult;
83691 }
83692
83693
83694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
83695   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
83696
83697   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
83698   {
83699     try {
83700       delete arg1;
83701     } catch (std::out_of_range& e) {
83702       {
83703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83704       };
83705     } catch (std::exception& e) {
83706       {
83707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83708       };
83709     } catch (...) {
83710       {
83711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83712       };
83713     }
83714   }
83715 }
83716
83717
83718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
83719   void * jresult ;
83720   Dali::Toolkit::ToggleButton *result = 0 ;
83721
83722   {
83723     try {
83724       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
83725     } catch (std::out_of_range& e) {
83726       {
83727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83728       };
83729     } catch (std::exception& e) {
83730       {
83731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83732       };
83733     } catch (...) {
83734       {
83735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83736       };
83737     }
83738   }
83739   jresult = (void *)result;
83740   return jresult;
83741 }
83742
83743
83744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
83745   void * jresult ;
83746   Dali::Toolkit::ToggleButton *arg1 = 0 ;
83747   Dali::Toolkit::ToggleButton *result = 0 ;
83748
83749   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
83750   if (!arg1) {
83751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
83752     return 0;
83753   }
83754   {
83755     try {
83756       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
83757     } catch (std::out_of_range& e) {
83758       {
83759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83760       };
83761     } catch (std::exception& e) {
83762       {
83763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83764       };
83765     } catch (...) {
83766       {
83767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83768       };
83769     }
83770   }
83771   jresult = (void *)result;
83772   return jresult;
83773 }
83774
83775
83776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
83777   void * jresult ;
83778   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
83779   Dali::Toolkit::ToggleButton *arg2 = 0 ;
83780   Dali::Toolkit::ToggleButton *result = 0 ;
83781
83782   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
83783   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
83784   if (!arg2) {
83785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
83786     return 0;
83787   }
83788   {
83789     try {
83790       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
83791     } catch (std::out_of_range& e) {
83792       {
83793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83794       };
83795     } catch (std::exception& e) {
83796       {
83797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83798       };
83799     } catch (...) {
83800       {
83801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83802       };
83803     }
83804   }
83805   jresult = (void *)result;
83806   return jresult;
83807 }
83808
83809
83810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
83811   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
83812
83813   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
83814   {
83815     try {
83816       delete arg1;
83817     } catch (std::out_of_range& e) {
83818       {
83819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83820       };
83821     } catch (std::exception& e) {
83822       {
83823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83824       };
83825     } catch (...) {
83826       {
83827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83828       };
83829     }
83830   }
83831 }
83832
83833
83834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
83835   void * jresult ;
83836   Dali::Toolkit::ToggleButton result;
83837
83838   {
83839     try {
83840       result = Dali::Toolkit::ToggleButton::New();
83841     } catch (std::out_of_range& e) {
83842       {
83843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83844       };
83845     } catch (std::exception& e) {
83846       {
83847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83848       };
83849     } catch (...) {
83850       {
83851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83852       };
83853     }
83854   }
83855   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
83856   return jresult;
83857 }
83858
83859
83860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
83861   void * jresult ;
83862   Dali::BaseHandle arg1 ;
83863   Dali::BaseHandle *argp1 ;
83864   Dali::Toolkit::ToggleButton result;
83865
83866   argp1 = (Dali::BaseHandle *)jarg1;
83867   if (!argp1) {
83868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83869     return 0;
83870   }
83871   arg1 = *argp1;
83872   {
83873     try {
83874       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
83875     } catch (std::out_of_range& e) {
83876       {
83877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83878       };
83879     } catch (std::exception& e) {
83880       {
83881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83882       };
83883     } catch (...) {
83884       {
83885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83886       };
83887     }
83888   }
83889   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
83890   return jresult;
83891 }
83892
83893
83894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
83895   void * jresult ;
83896   Dali::Toolkit::Visual::Base *result = 0 ;
83897
83898   {
83899     try {
83900       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
83901     } catch (std::out_of_range& e) {
83902       {
83903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83904       };
83905     } catch (std::exception& e) {
83906       {
83907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83908       };
83909     } catch (...) {
83910       {
83911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83912       };
83913     }
83914   }
83915   jresult = (void *)result;
83916   return jresult;
83917 }
83918
83919
83920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
83921   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
83922
83923   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
83924   {
83925     try {
83926       delete arg1;
83927     } catch (std::out_of_range& e) {
83928       {
83929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83930       };
83931     } catch (std::exception& e) {
83932       {
83933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83934       };
83935     } catch (...) {
83936       {
83937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83938       };
83939     }
83940   }
83941 }
83942
83943
83944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
83945   void * jresult ;
83946   Dali::Toolkit::Visual::Base *arg1 = 0 ;
83947   Dali::Toolkit::Visual::Base *result = 0 ;
83948
83949   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
83950   if (!arg1) {
83951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
83952     return 0;
83953   }
83954   {
83955     try {
83956       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
83957     } catch (std::out_of_range& e) {
83958       {
83959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83960       };
83961     } catch (std::exception& e) {
83962       {
83963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83964       };
83965     } catch (...) {
83966       {
83967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83968       };
83969     }
83970   }
83971   jresult = (void *)result;
83972   return jresult;
83973 }
83974
83975
83976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
83977   void * jresult ;
83978   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
83979   Dali::Toolkit::Visual::Base *arg2 = 0 ;
83980   Dali::Toolkit::Visual::Base *result = 0 ;
83981
83982   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
83983   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
83984   if (!arg2) {
83985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
83986     return 0;
83987   }
83988   {
83989     try {
83990       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
83991     } catch (std::out_of_range& e) {
83992       {
83993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83994       };
83995     } catch (std::exception& e) {
83996       {
83997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83998       };
83999     } catch (...) {
84000       {
84001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84002       };
84003     }
84004   }
84005   jresult = (void *)result;
84006   return jresult;
84007 }
84008
84009
84010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
84011   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84012   std::string *arg2 = 0 ;
84013
84014   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84015   if (!jarg2) {
84016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84017     return ;
84018   }
84019   std::string arg2_str(jarg2);
84020   arg2 = &arg2_str;
84021   {
84022     try {
84023       (arg1)->SetName((std::string const &)*arg2);
84024     } catch (std::out_of_range& e) {
84025       {
84026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84027       };
84028     } catch (std::exception& e) {
84029       {
84030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84031       };
84032     } catch (...) {
84033       {
84034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84035       };
84036     }
84037   }
84038
84039   //argout typemap for const std::string&
84040
84041 }
84042
84043
84044 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
84045   char * jresult ;
84046   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84047   std::string *result = 0 ;
84048
84049   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84050   {
84051     try {
84052       result = (std::string *) &(arg1)->GetName();
84053     } catch (std::out_of_range& e) {
84054       {
84055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84056       };
84057     } catch (std::exception& e) {
84058       {
84059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84060       };
84061     } catch (...) {
84062       {
84063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84064       };
84065     }
84066   }
84067   jresult = SWIG_csharp_string_callback(result->c_str());
84068   return jresult;
84069 }
84070
84071
84072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
84073   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84074   Dali::Property::Map *arg2 = 0 ;
84075   Dali::Size arg3 ;
84076   Dali::Size *argp3 ;
84077
84078   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84079   arg2 = (Dali::Property::Map *)jarg2;
84080   if (!arg2) {
84081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84082     return ;
84083   }
84084   argp3 = (Dali::Size *)jarg3;
84085   if (!argp3) {
84086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
84087     return ;
84088   }
84089   arg3 = *argp3;
84090   {
84091     try {
84092       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
84093     } catch (std::out_of_range& e) {
84094       {
84095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84096       };
84097     } catch (std::exception& e) {
84098       {
84099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84100       };
84101     } catch (...) {
84102       {
84103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84104       };
84105     }
84106   }
84107 }
84108
84109
84110 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
84111   float jresult ;
84112   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84113   float arg2 ;
84114   float result;
84115
84116   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84117   arg2 = (float)jarg2;
84118   {
84119     try {
84120       result = (float)(arg1)->GetHeightForWidth(arg2);
84121     } catch (std::out_of_range& e) {
84122       {
84123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84124       };
84125     } catch (std::exception& e) {
84126       {
84127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84128       };
84129     } catch (...) {
84130       {
84131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84132       };
84133     }
84134   }
84135   jresult = result;
84136   return jresult;
84137 }
84138
84139
84140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
84141   float jresult ;
84142   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84143   float arg2 ;
84144   float result;
84145
84146   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84147   arg2 = (float)jarg2;
84148   {
84149     try {
84150       result = (float)(arg1)->GetWidthForHeight(arg2);
84151     } catch (std::out_of_range& e) {
84152       {
84153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84154       };
84155     } catch (std::exception& e) {
84156       {
84157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84158       };
84159     } catch (...) {
84160       {
84161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84162       };
84163     }
84164   }
84165   jresult = result;
84166   return jresult;
84167 }
84168
84169
84170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
84171   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84172   Dali::Vector2 *arg2 = 0 ;
84173
84174   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84175   arg2 = (Dali::Vector2 *)jarg2;
84176   if (!arg2) {
84177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
84178     return ;
84179   }
84180   {
84181     try {
84182       (arg1)->GetNaturalSize(*arg2);
84183     } catch (std::out_of_range& e) {
84184       {
84185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84186       };
84187     } catch (std::exception& e) {
84188       {
84189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84190       };
84191     } catch (...) {
84192       {
84193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84194       };
84195     }
84196   }
84197 }
84198
84199
84200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
84201   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84202   float arg2 ;
84203
84204   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84205   arg2 = (float)jarg2;
84206   {
84207     try {
84208       (arg1)->SetDepthIndex(arg2);
84209     } catch (std::out_of_range& e) {
84210       {
84211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84212       };
84213     } catch (std::exception& e) {
84214       {
84215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84216       };
84217     } catch (...) {
84218       {
84219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84220       };
84221     }
84222   }
84223 }
84224
84225
84226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
84227   float jresult ;
84228   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84229   float result;
84230
84231   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84232   {
84233     try {
84234       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
84235     } catch (std::out_of_range& e) {
84236       {
84237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84238       };
84239     } catch (std::exception& e) {
84240       {
84241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84242       };
84243     } catch (...) {
84244       {
84245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84246       };
84247     }
84248   }
84249   jresult = result;
84250   return jresult;
84251 }
84252
84253
84254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
84255   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84256   Dali::Property::Map *arg2 = 0 ;
84257
84258   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84259   arg2 = (Dali::Property::Map *)jarg2;
84260   if (!arg2) {
84261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
84262     return ;
84263   }
84264   {
84265     try {
84266       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
84267     } catch (std::out_of_range& e) {
84268       {
84269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84270       };
84271     } catch (std::exception& e) {
84272       {
84273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84274       };
84275     } catch (...) {
84276       {
84277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84278       };
84279     }
84280   }
84281 }
84282
84283
84284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
84285   void * jresult ;
84286   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
84287   Dali::Toolkit::Visual::Base *result = 0 ;
84288
84289   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
84290   {
84291     try {
84292       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
84293     } catch (std::out_of_range& e) {
84294       {
84295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84296       };
84297     } catch (std::exception& e) {
84298       {
84299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84300       };
84301     } catch (...) {
84302       {
84303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84304       };
84305     }
84306   }
84307   jresult = (void *)result;
84308   return jresult;
84309 }
84310
84311
84312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
84313   void * jresult ;
84314   Dali::Toolkit::VisualFactory result;
84315
84316   {
84317     try {
84318       result = Dali::Toolkit::VisualFactory::Get();
84319     } catch (std::out_of_range& e) {
84320       {
84321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84322       };
84323     } catch (std::exception& e) {
84324       {
84325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84326       };
84327     } catch (...) {
84328       {
84329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84330       };
84331     }
84332   }
84333   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
84334   return jresult;
84335 }
84336
84337
84338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
84339   void * jresult ;
84340   Dali::Toolkit::VisualFactory *result = 0 ;
84341
84342   {
84343     try {
84344       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
84345     } catch (std::out_of_range& e) {
84346       {
84347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84348       };
84349     } catch (std::exception& e) {
84350       {
84351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84352       };
84353     } catch (...) {
84354       {
84355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84356       };
84357     }
84358   }
84359   jresult = (void *)result;
84360   return jresult;
84361 }
84362
84363
84364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
84365   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84366
84367   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84368   {
84369     try {
84370       delete arg1;
84371     } catch (std::out_of_range& e) {
84372       {
84373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84374       };
84375     } catch (std::exception& e) {
84376       {
84377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84378       };
84379     } catch (...) {
84380       {
84381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84382       };
84383     }
84384   }
84385 }
84386
84387
84388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
84389   void * jresult ;
84390   Dali::Toolkit::VisualFactory *arg1 = 0 ;
84391   Dali::Toolkit::VisualFactory *result = 0 ;
84392
84393   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84394   if (!arg1) {
84395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84396     return 0;
84397   }
84398   {
84399     try {
84400       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
84401     } catch (std::out_of_range& e) {
84402       {
84403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84404       };
84405     } catch (std::exception& e) {
84406       {
84407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84408       };
84409     } catch (...) {
84410       {
84411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84412       };
84413     }
84414   }
84415   jresult = (void *)result;
84416   return jresult;
84417 }
84418
84419
84420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
84421   void * jresult ;
84422   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84423   Dali::Toolkit::VisualFactory *arg2 = 0 ;
84424   Dali::Toolkit::VisualFactory *result = 0 ;
84425
84426   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84427   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
84428   if (!arg2) {
84429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84430     return 0;
84431   }
84432   {
84433     try {
84434       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
84435     } catch (std::out_of_range& e) {
84436       {
84437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84438       };
84439     } catch (std::exception& e) {
84440       {
84441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84442       };
84443     } catch (...) {
84444       {
84445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84446       };
84447     }
84448   }
84449   jresult = (void *)result;
84450   return jresult;
84451 }
84452
84453
84454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
84455   void * jresult ;
84456   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84457   Dali::Property::Map *arg2 = 0 ;
84458   Dali::Toolkit::Visual::Base result;
84459
84460   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84461   arg2 = (Dali::Property::Map *)jarg2;
84462   if (!arg2) {
84463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84464     return 0;
84465   }
84466   {
84467     try {
84468       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
84469     } catch (std::out_of_range& e) {
84470       {
84471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84472       };
84473     } catch (std::exception& e) {
84474       {
84475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84476       };
84477     } catch (...) {
84478       {
84479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84480       };
84481     }
84482   }
84483   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84484   return jresult;
84485 }
84486
84487
84488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
84489   void * jresult ;
84490   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84491   Dali::Image *arg2 = 0 ;
84492   Dali::Toolkit::Visual::Base result;
84493
84494   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84495   arg2 = (Dali::Image *)jarg2;
84496   if (!arg2) {
84497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
84498     return 0;
84499   }
84500   {
84501     try {
84502       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
84503     } catch (std::out_of_range& e) {
84504       {
84505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84506       };
84507     } catch (std::exception& e) {
84508       {
84509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84510       };
84511     } catch (...) {
84512       {
84513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84514       };
84515     }
84516   }
84517   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84518   return jresult;
84519 }
84520
84521
84522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
84523   void * jresult ;
84524   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84525   std::string *arg2 = 0 ;
84526   Dali::ImageDimensions arg3 ;
84527   Dali::ImageDimensions *argp3 ;
84528   Dali::Toolkit::Visual::Base result;
84529
84530   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84531   if (!jarg2) {
84532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84533     return 0;
84534   }
84535   std::string arg2_str(jarg2);
84536   arg2 = &arg2_str;
84537   argp3 = (Dali::ImageDimensions *)jarg3;
84538   if (!argp3) {
84539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
84540     return 0;
84541   }
84542   arg3 = *argp3;
84543   {
84544     try {
84545       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
84546     } catch (std::out_of_range& e) {
84547       {
84548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84549       };
84550     } catch (std::exception& e) {
84551       {
84552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84553       };
84554     } catch (...) {
84555       {
84556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84557       };
84558     }
84559   }
84560   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84561
84562   //argout typemap for const std::string&
84563
84564   return jresult;
84565 }
84566
84567
84568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
84569   void * jresult ;
84570   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84571
84572   {
84573     try {
84574       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
84575     } catch (std::out_of_range& e) {
84576       {
84577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84578       };
84579     } catch (std::exception& e) {
84580       {
84581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84582       };
84583     } catch (...) {
84584       {
84585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84586       };
84587     }
84588   }
84589   jresult = (void *)result;
84590   return jresult;
84591 }
84592
84593
84594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
84595   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84596
84597   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84598   {
84599     try {
84600       delete arg1;
84601     } catch (std::out_of_range& e) {
84602       {
84603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84604       };
84605     } catch (std::exception& e) {
84606       {
84607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84608       };
84609     } catch (...) {
84610       {
84611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84612       };
84613     }
84614   }
84615 }
84616
84617
84618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
84619   void * jresult ;
84620   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
84621   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84622
84623   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84624   if (!arg1) {
84625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
84626     return 0;
84627   }
84628   {
84629     try {
84630       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
84631     } catch (std::out_of_range& e) {
84632       {
84633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84634       };
84635     } catch (std::exception& e) {
84636       {
84637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84638       };
84639     } catch (...) {
84640       {
84641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84642       };
84643     }
84644   }
84645   jresult = (void *)result;
84646   return jresult;
84647 }
84648
84649
84650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
84651   void * jresult ;
84652   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84653   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
84654   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84655
84656   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84657   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
84658   if (!arg2) {
84659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
84660     return 0;
84661   }
84662   {
84663     try {
84664       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
84665     } catch (std::out_of_range& e) {
84666       {
84667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84668       };
84669     } catch (std::exception& e) {
84670       {
84671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84672       };
84673     } catch (...) {
84674       {
84675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84676       };
84677     }
84678   }
84679   jresult = (void *)result;
84680   return jresult;
84681 }
84682
84683
84684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
84685   void * jresult ;
84686   Dali::Toolkit::AsyncImageLoader result;
84687
84688   {
84689     try {
84690       result = Dali::Toolkit::AsyncImageLoader::New();
84691     } catch (std::out_of_range& e) {
84692       {
84693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84694       };
84695     } catch (std::exception& e) {
84696       {
84697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84698       };
84699     } catch (...) {
84700       {
84701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84702       };
84703     }
84704   }
84705   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
84706   return jresult;
84707 }
84708
84709
84710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
84711   void * jresult ;
84712   Dali::BaseHandle arg1 ;
84713   Dali::BaseHandle *argp1 ;
84714   Dali::Toolkit::AsyncImageLoader result;
84715
84716   argp1 = (Dali::BaseHandle *)jarg1;
84717   if (!argp1) {
84718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84719     return 0;
84720   }
84721   arg1 = *argp1;
84722   {
84723     try {
84724       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
84725     } catch (std::out_of_range& e) {
84726       {
84727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84728       };
84729     } catch (std::exception& e) {
84730       {
84731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84732       };
84733     } catch (...) {
84734       {
84735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84736       };
84737     }
84738   }
84739   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
84740   return jresult;
84741 }
84742
84743
84744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
84745   unsigned int jresult ;
84746   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84747   std::string *arg2 = 0 ;
84748   uint32_t result;
84749
84750   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84751   if (!jarg2) {
84752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84753     return 0;
84754   }
84755   std::string arg2_str(jarg2);
84756   arg2 = &arg2_str;
84757   {
84758     try {
84759       result = (arg1)->Load((std::string const &)*arg2);
84760     } catch (std::out_of_range& e) {
84761       {
84762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84763       };
84764     } catch (std::exception& e) {
84765       {
84766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84767       };
84768     } catch (...) {
84769       {
84770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84771       };
84772     }
84773   }
84774   jresult = result;
84775
84776   //argout typemap for const std::string&
84777
84778   return jresult;
84779 }
84780
84781
84782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
84783   unsigned int jresult ;
84784   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84785   std::string *arg2 = 0 ;
84786   Dali::ImageDimensions arg3 ;
84787   Dali::ImageDimensions *argp3 ;
84788   uint32_t result;
84789
84790   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84791   if (!jarg2) {
84792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84793     return 0;
84794   }
84795   std::string arg2_str(jarg2);
84796   arg2 = &arg2_str;
84797   argp3 = (Dali::ImageDimensions *)jarg3;
84798   if (!argp3) {
84799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
84800     return 0;
84801   }
84802   arg3 = *argp3;
84803   {
84804     try {
84805       result = (arg1)->Load((std::string const &)*arg2,arg3);
84806     } catch (std::out_of_range& e) {
84807       {
84808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84809       };
84810     } catch (std::exception& e) {
84811       {
84812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84813       };
84814     } catch (...) {
84815       {
84816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84817       };
84818     }
84819   }
84820   jresult = result;
84821
84822   //argout typemap for const std::string&
84823
84824   return jresult;
84825 }
84826
84827
84828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
84829   unsigned int jresult ;
84830   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84831   std::string *arg2 = 0 ;
84832   Dali::ImageDimensions arg3 ;
84833   Dali::FittingMode::Type arg4 ;
84834   Dali::SamplingMode::Type arg5 ;
84835   bool arg6 ;
84836   Dali::ImageDimensions *argp3 ;
84837   uint32_t result;
84838
84839   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84840   if (!jarg2) {
84841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84842     return 0;
84843   }
84844   std::string arg2_str(jarg2);
84845   arg2 = &arg2_str;
84846   argp3 = (Dali::ImageDimensions *)jarg3;
84847   if (!argp3) {
84848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
84849     return 0;
84850   }
84851   arg3 = *argp3;
84852   arg4 = (Dali::FittingMode::Type)jarg4;
84853   arg5 = (Dali::SamplingMode::Type)jarg5;
84854   arg6 = jarg6 ? true : false;
84855   {
84856     try {
84857       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
84858     } catch (std::out_of_range& e) {
84859       {
84860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84861       };
84862     } catch (std::exception& e) {
84863       {
84864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84865       };
84866     } catch (...) {
84867       {
84868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84869       };
84870     }
84871   }
84872   jresult = result;
84873
84874   //argout typemap for const std::string&
84875
84876   return jresult;
84877 }
84878
84879
84880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
84881   unsigned int jresult ;
84882   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84883   uint32_t arg2 ;
84884   bool result;
84885
84886   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84887   arg2 = (uint32_t)jarg2;
84888   {
84889     try {
84890       result = (bool)(arg1)->Cancel(arg2);
84891     } catch (std::out_of_range& e) {
84892       {
84893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84894       };
84895     } catch (std::exception& e) {
84896       {
84897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84898       };
84899     } catch (...) {
84900       {
84901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84902       };
84903     }
84904   }
84905   jresult = result;
84906   return jresult;
84907 }
84908
84909
84910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
84911   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84912
84913   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84914   {
84915     try {
84916       (arg1)->CancelAll();
84917     } catch (std::out_of_range& e) {
84918       {
84919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84920       };
84921     } catch (std::exception& e) {
84922       {
84923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84924       };
84925     } catch (...) {
84926       {
84927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84928       };
84929     }
84930   }
84931 }
84932
84933
84934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
84935   void * jresult ;
84936   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84937   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
84938
84939   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84940   {
84941     try {
84942       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
84943     } catch (std::out_of_range& e) {
84944       {
84945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84946       };
84947     } catch (std::exception& e) {
84948       {
84949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84950       };
84951     } catch (...) {
84952       {
84953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84954       };
84955     }
84956   }
84957   jresult = (void *)result;
84958   return jresult;
84959 }
84960
84961
84962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
84963   void * jresult ;
84964   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
84965   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84966
84967   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
84968   {
84969     try {
84970       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
84971     } catch (std::out_of_range& e) {
84972       {
84973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84974       };
84975     } catch (std::exception& e) {
84976       {
84977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84978       };
84979     } catch (...) {
84980       {
84981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84982       };
84983     }
84984   }
84985   jresult = (void *)result;
84986   return jresult;
84987 }
84988
84989
84990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
84991   void * jresult ;
84992   std::string *arg1 = 0 ;
84993   Dali::PixelData result;
84994
84995   if (!jarg1) {
84996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84997     return 0;
84998   }
84999   std::string arg1_str(jarg1);
85000   arg1 = &arg1_str;
85001   {
85002     try {
85003       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
85004     } catch (std::out_of_range& e) {
85005       {
85006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85007       };
85008     } catch (std::exception& e) {
85009       {
85010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85011       };
85012     } catch (...) {
85013       {
85014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85015       };
85016     }
85017   }
85018   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85019
85020   //argout typemap for const std::string&
85021
85022   return jresult;
85023 }
85024
85025
85026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
85027   void * jresult ;
85028   std::string *arg1 = 0 ;
85029   Dali::ImageDimensions arg2 ;
85030   Dali::ImageDimensions *argp2 ;
85031   Dali::PixelData result;
85032
85033   if (!jarg1) {
85034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85035     return 0;
85036   }
85037   std::string arg1_str(jarg1);
85038   arg1 = &arg1_str;
85039   argp2 = (Dali::ImageDimensions *)jarg2;
85040   if (!argp2) {
85041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85042     return 0;
85043   }
85044   arg2 = *argp2;
85045   {
85046     try {
85047       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
85048     } catch (std::out_of_range& e) {
85049       {
85050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85051       };
85052     } catch (std::exception& e) {
85053       {
85054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85055       };
85056     } catch (...) {
85057       {
85058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85059       };
85060     }
85061   }
85062   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85063
85064   //argout typemap for const std::string&
85065
85066   return jresult;
85067 }
85068
85069
85070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
85071   void * jresult ;
85072   std::string *arg1 = 0 ;
85073   Dali::ImageDimensions arg2 ;
85074   Dali::FittingMode::Type arg3 ;
85075   Dali::SamplingMode::Type arg4 ;
85076   bool arg5 ;
85077   Dali::ImageDimensions *argp2 ;
85078   Dali::PixelData result;
85079
85080   if (!jarg1) {
85081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85082     return 0;
85083   }
85084   std::string arg1_str(jarg1);
85085   arg1 = &arg1_str;
85086   argp2 = (Dali::ImageDimensions *)jarg2;
85087   if (!argp2) {
85088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85089     return 0;
85090   }
85091   arg2 = *argp2;
85092   arg3 = (Dali::FittingMode::Type)jarg3;
85093   arg4 = (Dali::SamplingMode::Type)jarg4;
85094   arg5 = jarg5 ? true : false;
85095   {
85096     try {
85097       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
85098     } catch (std::out_of_range& e) {
85099       {
85100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85101       };
85102     } catch (std::exception& e) {
85103       {
85104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85105       };
85106     } catch (...) {
85107       {
85108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85109       };
85110     }
85111   }
85112   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85113
85114   //argout typemap for const std::string&
85115
85116   return jresult;
85117 }
85118
85119
85120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
85121   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85122
85123   arg1 = (std::vector< unsigned int > *)jarg1;
85124   {
85125     try {
85126       (arg1)->clear();
85127     } catch (std::out_of_range& e) {
85128       {
85129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85130       };
85131     } catch (std::exception& e) {
85132       {
85133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85134       };
85135     } catch (...) {
85136       {
85137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85138       };
85139     }
85140   }
85141 }
85142
85143
85144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
85145   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85146   unsigned int *arg2 = 0 ;
85147   unsigned int temp2 ;
85148
85149   arg1 = (std::vector< unsigned int > *)jarg1;
85150   temp2 = (unsigned int)jarg2;
85151   arg2 = &temp2;
85152   {
85153     try {
85154       (arg1)->push_back((unsigned int const &)*arg2);
85155     } catch (std::out_of_range& e) {
85156       {
85157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85158       };
85159     } catch (std::exception& e) {
85160       {
85161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85162       };
85163     } catch (...) {
85164       {
85165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85166       };
85167     }
85168   }
85169 }
85170
85171
85172 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
85173   unsigned long jresult ;
85174   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85175   std::vector< unsigned int >::size_type result;
85176
85177   arg1 = (std::vector< unsigned int > *)jarg1;
85178   {
85179     try {
85180       result = ((std::vector< unsigned int > const *)arg1)->size();
85181     } catch (std::out_of_range& e) {
85182       {
85183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85184       };
85185     } catch (std::exception& e) {
85186       {
85187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85188       };
85189     } catch (...) {
85190       {
85191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85192       };
85193     }
85194   }
85195   jresult = (unsigned long)result;
85196   return jresult;
85197 }
85198
85199
85200 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
85201   unsigned long jresult ;
85202   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85203   std::vector< unsigned int >::size_type result;
85204
85205   arg1 = (std::vector< unsigned int > *)jarg1;
85206   {
85207     try {
85208       result = ((std::vector< unsigned int > const *)arg1)->capacity();
85209     } catch (std::out_of_range& e) {
85210       {
85211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85212       };
85213     } catch (std::exception& e) {
85214       {
85215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85216       };
85217     } catch (...) {
85218       {
85219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85220       };
85221     }
85222   }
85223   jresult = (unsigned long)result;
85224   return jresult;
85225 }
85226
85227
85228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
85229   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85230   std::vector< unsigned int >::size_type arg2 ;
85231
85232   arg1 = (std::vector< unsigned int > *)jarg1;
85233   arg2 = (std::vector< unsigned int >::size_type)jarg2;
85234   {
85235     try {
85236       (arg1)->reserve(arg2);
85237     } catch (std::out_of_range& e) {
85238       {
85239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85240       };
85241     } catch (std::exception& e) {
85242       {
85243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85244       };
85245     } catch (...) {
85246       {
85247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85248       };
85249     }
85250   }
85251 }
85252
85253
85254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
85255   void * jresult ;
85256   std::vector< unsigned int > *result = 0 ;
85257
85258   {
85259     try {
85260       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
85261     } catch (std::out_of_range& e) {
85262       {
85263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85264       };
85265     } catch (std::exception& e) {
85266       {
85267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85268       };
85269     } catch (...) {
85270       {
85271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85272       };
85273     }
85274   }
85275   jresult = (void *)result;
85276   return jresult;
85277 }
85278
85279
85280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
85281   void * jresult ;
85282   std::vector< unsigned int > *arg1 = 0 ;
85283   std::vector< unsigned int > *result = 0 ;
85284
85285   arg1 = (std::vector< unsigned int > *)jarg1;
85286   if (!arg1) {
85287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85288     return 0;
85289   }
85290   {
85291     try {
85292       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
85293     } catch (std::out_of_range& e) {
85294       {
85295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85296       };
85297     } catch (std::exception& e) {
85298       {
85299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85300       };
85301     } catch (...) {
85302       {
85303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85304       };
85305     }
85306   }
85307   jresult = (void *)result;
85308   return jresult;
85309 }
85310
85311
85312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
85313   void * jresult ;
85314   int arg1 ;
85315   std::vector< unsigned int > *result = 0 ;
85316
85317   arg1 = (int)jarg1;
85318   {
85319     try {
85320       try {
85321         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
85322       }
85323       catch(std::out_of_range &_e) {
85324         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85325         return 0;
85326       }
85327
85328     } catch (std::out_of_range& e) {
85329       {
85330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85331       };
85332     } catch (std::exception& e) {
85333       {
85334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85335       };
85336     } catch (...) {
85337       {
85338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85339       };
85340     }
85341   }
85342   jresult = (void *)result;
85343   return jresult;
85344 }
85345
85346
85347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
85348   unsigned int jresult ;
85349   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85350   int arg2 ;
85351   unsigned int result;
85352
85353   arg1 = (std::vector< unsigned int > *)jarg1;
85354   arg2 = (int)jarg2;
85355   {
85356     try {
85357       try {
85358         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
85359       }
85360       catch(std::out_of_range &_e) {
85361         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85362         return 0;
85363       }
85364
85365     } catch (std::out_of_range& e) {
85366       {
85367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85368       };
85369     } catch (std::exception& e) {
85370       {
85371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85372       };
85373     } catch (...) {
85374       {
85375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85376       };
85377     }
85378   }
85379   jresult = result;
85380   return jresult;
85381 }
85382
85383
85384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
85385   unsigned int jresult ;
85386   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85387   int arg2 ;
85388   unsigned int *result = 0 ;
85389
85390   arg1 = (std::vector< unsigned int > *)jarg1;
85391   arg2 = (int)jarg2;
85392   {
85393     try {
85394       try {
85395         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
85396       }
85397       catch(std::out_of_range &_e) {
85398         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85399         return 0;
85400       }
85401
85402     } catch (std::out_of_range& e) {
85403       {
85404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85405       };
85406     } catch (std::exception& e) {
85407       {
85408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85409       };
85410     } catch (...) {
85411       {
85412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85413       };
85414     }
85415   }
85416   jresult = *result;
85417   return jresult;
85418 }
85419
85420
85421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
85422   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85423   int arg2 ;
85424   unsigned int *arg3 = 0 ;
85425   unsigned int temp3 ;
85426
85427   arg1 = (std::vector< unsigned int > *)jarg1;
85428   arg2 = (int)jarg2;
85429   temp3 = (unsigned int)jarg3;
85430   arg3 = &temp3;
85431   {
85432     try {
85433       try {
85434         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
85435       }
85436       catch(std::out_of_range &_e) {
85437         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85438         return ;
85439       }
85440
85441     } catch (std::out_of_range& e) {
85442       {
85443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85444       };
85445     } catch (std::exception& e) {
85446       {
85447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85448       };
85449     } catch (...) {
85450       {
85451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85452       };
85453     }
85454   }
85455 }
85456
85457
85458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
85459   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85460   std::vector< unsigned int > *arg2 = 0 ;
85461
85462   arg1 = (std::vector< unsigned int > *)jarg1;
85463   arg2 = (std::vector< unsigned int > *)jarg2;
85464   if (!arg2) {
85465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85466     return ;
85467   }
85468   {
85469     try {
85470       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
85471     } catch (std::out_of_range& e) {
85472       {
85473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85474       };
85475     } catch (std::exception& e) {
85476       {
85477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85478       };
85479     } catch (...) {
85480       {
85481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85482       };
85483     }
85484   }
85485 }
85486
85487
85488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
85489   void * jresult ;
85490   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85491   int arg2 ;
85492   int arg3 ;
85493   std::vector< unsigned int > *result = 0 ;
85494
85495   arg1 = (std::vector< unsigned int > *)jarg1;
85496   arg2 = (int)jarg2;
85497   arg3 = (int)jarg3;
85498   {
85499     try {
85500       try {
85501         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
85502       }
85503       catch(std::out_of_range &_e) {
85504         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85505         return 0;
85506       }
85507       catch(std::invalid_argument &_e) {
85508         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
85509         return 0;
85510       }
85511
85512     } catch (std::out_of_range& e) {
85513       {
85514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85515       };
85516     } catch (std::exception& e) {
85517       {
85518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85519       };
85520     } catch (...) {
85521       {
85522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85523       };
85524     }
85525   }
85526   jresult = (void *)result;
85527   return jresult;
85528 }
85529
85530
85531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
85532   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85533   int arg2 ;
85534   unsigned int *arg3 = 0 ;
85535   unsigned int temp3 ;
85536
85537   arg1 = (std::vector< unsigned int > *)jarg1;
85538   arg2 = (int)jarg2;
85539   temp3 = (unsigned int)jarg3;
85540   arg3 = &temp3;
85541   {
85542     try {
85543       try {
85544         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
85545       }
85546       catch(std::out_of_range &_e) {
85547         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85548         return ;
85549       }
85550
85551     } catch (std::out_of_range& e) {
85552       {
85553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85554       };
85555     } catch (std::exception& e) {
85556       {
85557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85558       };
85559     } catch (...) {
85560       {
85561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85562       };
85563     }
85564   }
85565 }
85566
85567
85568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
85569   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85570   int arg2 ;
85571   std::vector< unsigned int > *arg3 = 0 ;
85572
85573   arg1 = (std::vector< unsigned int > *)jarg1;
85574   arg2 = (int)jarg2;
85575   arg3 = (std::vector< unsigned int > *)jarg3;
85576   if (!arg3) {
85577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85578     return ;
85579   }
85580   {
85581     try {
85582       try {
85583         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
85584       }
85585       catch(std::out_of_range &_e) {
85586         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85587         return ;
85588       }
85589
85590     } catch (std::out_of_range& e) {
85591       {
85592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85593       };
85594     } catch (std::exception& e) {
85595       {
85596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85597       };
85598     } catch (...) {
85599       {
85600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85601       };
85602     }
85603   }
85604 }
85605
85606
85607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
85608   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85609   int arg2 ;
85610
85611   arg1 = (std::vector< unsigned int > *)jarg1;
85612   arg2 = (int)jarg2;
85613   {
85614     try {
85615       try {
85616         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
85617       }
85618       catch(std::out_of_range &_e) {
85619         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85620         return ;
85621       }
85622
85623     } catch (std::out_of_range& e) {
85624       {
85625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85626       };
85627     } catch (std::exception& e) {
85628       {
85629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85630       };
85631     } catch (...) {
85632       {
85633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85634       };
85635     }
85636   }
85637 }
85638
85639
85640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
85641   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85642   int arg2 ;
85643   int arg3 ;
85644
85645   arg1 = (std::vector< unsigned int > *)jarg1;
85646   arg2 = (int)jarg2;
85647   arg3 = (int)jarg3;
85648   {
85649     try {
85650       try {
85651         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
85652       }
85653       catch(std::out_of_range &_e) {
85654         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85655         return ;
85656       }
85657       catch(std::invalid_argument &_e) {
85658         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
85659         return ;
85660       }
85661
85662     } catch (std::out_of_range& e) {
85663       {
85664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85665       };
85666     } catch (std::exception& e) {
85667       {
85668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85669       };
85670     } catch (...) {
85671       {
85672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85673       };
85674     }
85675   }
85676 }
85677
85678
85679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
85680   void * jresult ;
85681   unsigned int *arg1 = 0 ;
85682   int arg2 ;
85683   unsigned int temp1 ;
85684   std::vector< unsigned int > *result = 0 ;
85685
85686   temp1 = (unsigned int)jarg1;
85687   arg1 = &temp1;
85688   arg2 = (int)jarg2;
85689   {
85690     try {
85691       try {
85692         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
85693       }
85694       catch(std::out_of_range &_e) {
85695         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85696         return 0;
85697       }
85698
85699     } catch (std::out_of_range& e) {
85700       {
85701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85702       };
85703     } catch (std::exception& e) {
85704       {
85705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85706       };
85707     } catch (...) {
85708       {
85709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85710       };
85711     }
85712   }
85713   jresult = (void *)result;
85714   return jresult;
85715 }
85716
85717
85718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
85719   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85720
85721   arg1 = (std::vector< unsigned int > *)jarg1;
85722   {
85723     try {
85724       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
85725     } catch (std::out_of_range& e) {
85726       {
85727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85728       };
85729     } catch (std::exception& e) {
85730       {
85731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85732       };
85733     } catch (...) {
85734       {
85735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85736       };
85737     }
85738   }
85739 }
85740
85741
85742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
85743   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85744   int arg2 ;
85745   int arg3 ;
85746
85747   arg1 = (std::vector< unsigned int > *)jarg1;
85748   arg2 = (int)jarg2;
85749   arg3 = (int)jarg3;
85750   {
85751     try {
85752       try {
85753         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
85754       }
85755       catch(std::out_of_range &_e) {
85756         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85757         return ;
85758       }
85759       catch(std::invalid_argument &_e) {
85760         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
85761         return ;
85762       }
85763
85764     } catch (std::out_of_range& e) {
85765       {
85766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85767       };
85768     } catch (std::exception& e) {
85769       {
85770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85771       };
85772     } catch (...) {
85773       {
85774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85775       };
85776     }
85777   }
85778 }
85779
85780
85781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
85782   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85783   int arg2 ;
85784   std::vector< unsigned int > *arg3 = 0 ;
85785
85786   arg1 = (std::vector< unsigned int > *)jarg1;
85787   arg2 = (int)jarg2;
85788   arg3 = (std::vector< unsigned int > *)jarg3;
85789   if (!arg3) {
85790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85791     return ;
85792   }
85793   {
85794     try {
85795       try {
85796         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
85797       }
85798       catch(std::out_of_range &_e) {
85799         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85800         return ;
85801       }
85802
85803     } catch (std::out_of_range& e) {
85804       {
85805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85806       };
85807     } catch (std::exception& e) {
85808       {
85809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85810       };
85811     } catch (...) {
85812       {
85813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85814       };
85815     }
85816   }
85817 }
85818
85819
85820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
85821   unsigned int jresult ;
85822   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85823   unsigned int *arg2 = 0 ;
85824   unsigned int temp2 ;
85825   bool result;
85826
85827   arg1 = (std::vector< unsigned int > *)jarg1;
85828   temp2 = (unsigned int)jarg2;
85829   arg2 = &temp2;
85830   {
85831     try {
85832       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
85833     } catch (std::out_of_range& e) {
85834       {
85835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85836       };
85837     } catch (std::exception& e) {
85838       {
85839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85840       };
85841     } catch (...) {
85842       {
85843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85844       };
85845     }
85846   }
85847   jresult = result;
85848   return jresult;
85849 }
85850
85851
85852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
85853   int jresult ;
85854   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85855   unsigned int *arg2 = 0 ;
85856   unsigned int temp2 ;
85857   int result;
85858
85859   arg1 = (std::vector< unsigned int > *)jarg1;
85860   temp2 = (unsigned int)jarg2;
85861   arg2 = &temp2;
85862   {
85863     try {
85864       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
85865     } catch (std::out_of_range& e) {
85866       {
85867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85868       };
85869     } catch (std::exception& e) {
85870       {
85871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85872       };
85873     } catch (...) {
85874       {
85875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85876       };
85877     }
85878   }
85879   jresult = result;
85880   return jresult;
85881 }
85882
85883
85884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
85885   int jresult ;
85886   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85887   unsigned int *arg2 = 0 ;
85888   unsigned int temp2 ;
85889   int result;
85890
85891   arg1 = (std::vector< unsigned int > *)jarg1;
85892   temp2 = (unsigned int)jarg2;
85893   arg2 = &temp2;
85894   {
85895     try {
85896       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
85897     } catch (std::out_of_range& e) {
85898       {
85899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85900       };
85901     } catch (std::exception& e) {
85902       {
85903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85904       };
85905     } catch (...) {
85906       {
85907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85908       };
85909     }
85910   }
85911   jresult = result;
85912   return jresult;
85913 }
85914
85915
85916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
85917   unsigned int jresult ;
85918   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85919   unsigned int *arg2 = 0 ;
85920   unsigned int temp2 ;
85921   bool result;
85922
85923   arg1 = (std::vector< unsigned int > *)jarg1;
85924   temp2 = (unsigned int)jarg2;
85925   arg2 = &temp2;
85926   {
85927     try {
85928       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
85929     } catch (std::out_of_range& e) {
85930       {
85931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85932       };
85933     } catch (std::exception& e) {
85934       {
85935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85936       };
85937     } catch (...) {
85938       {
85939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85940       };
85941     }
85942   }
85943   jresult = result;
85944   return jresult;
85945 }
85946
85947
85948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
85949   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85950
85951   arg1 = (std::vector< unsigned int > *)jarg1;
85952   {
85953     try {
85954       delete arg1;
85955     } catch (std::out_of_range& e) {
85956       {
85957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85958       };
85959     } catch (std::exception& e) {
85960       {
85961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85962       };
85963     } catch (...) {
85964       {
85965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85966       };
85967     }
85968   }
85969 }
85970
85971
85972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
85973   void * jresult ;
85974   std::pair< unsigned int,Dali::Actor > *result = 0 ;
85975
85976   {
85977     try {
85978       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
85979     } catch (std::out_of_range& e) {
85980       {
85981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85982       };
85983     } catch (std::exception& e) {
85984       {
85985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85986       };
85987     } catch (...) {
85988       {
85989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85990       };
85991     }
85992   }
85993   jresult = (void *)result;
85994   return jresult;
85995 }
85996
85997
85998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
85999   void * jresult ;
86000   unsigned int arg1 ;
86001   Dali::Actor arg2 ;
86002   Dali::Actor *argp2 ;
86003   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86004
86005   arg1 = (unsigned int)jarg1;
86006   argp2 = (Dali::Actor *)jarg2;
86007   if (!argp2) {
86008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86009     return 0;
86010   }
86011   arg2 = *argp2;
86012   {
86013     try {
86014       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
86015     } catch (std::out_of_range& e) {
86016       {
86017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86018       };
86019     } catch (std::exception& e) {
86020       {
86021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86022       };
86023     } catch (...) {
86024       {
86025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86026       };
86027     }
86028   }
86029   jresult = (void *)result;
86030   return jresult;
86031 }
86032
86033
86034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
86035   void * jresult ;
86036   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86037   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86038
86039   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86040   if (!arg1) {
86041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86042     return 0;
86043   }
86044   {
86045     try {
86046       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
86047     } catch (std::out_of_range& e) {
86048       {
86049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86050       };
86051     } catch (std::exception& e) {
86052       {
86053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86054       };
86055     } catch (...) {
86056       {
86057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86058       };
86059     }
86060   }
86061   jresult = (void *)result;
86062   return jresult;
86063 }
86064
86065
86066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
86067   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86068   unsigned int arg2 ;
86069
86070   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86071   arg2 = (unsigned int)jarg2;
86072   if (arg1) (arg1)->first = arg2;
86073 }
86074
86075
86076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
86077   unsigned int jresult ;
86078   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86079   unsigned int result;
86080
86081   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86082   result = (unsigned int) ((arg1)->first);
86083   jresult = result;
86084   return jresult;
86085 }
86086
86087
86088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
86089   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86090   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
86091
86092   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86093   arg2 = (Dali::Actor *)jarg2;
86094   if (arg1) (arg1)->second = *arg2;
86095 }
86096
86097
86098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
86099   void * jresult ;
86100   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86101   Dali::Actor *result = 0 ;
86102
86103   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86104   result = (Dali::Actor *)& ((arg1)->second);
86105   jresult = (void *)result;
86106   return jresult;
86107 }
86108
86109
86110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
86111   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86112
86113   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86114   {
86115     try {
86116       delete arg1;
86117     } catch (std::out_of_range& e) {
86118       {
86119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86120       };
86121     } catch (std::exception& e) {
86122       {
86123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86124       };
86125     } catch (...) {
86126       {
86127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86128       };
86129     }
86130   }
86131 }
86132
86133
86134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
86135   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86136
86137   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86138   {
86139     try {
86140       (arg1)->clear();
86141     } catch (std::out_of_range& e) {
86142       {
86143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86144       };
86145     } catch (std::exception& e) {
86146       {
86147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86148       };
86149     } catch (...) {
86150       {
86151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86152       };
86153     }
86154   }
86155 }
86156
86157
86158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
86159   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86160   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
86161
86162   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86163   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
86164   if (!arg2) {
86165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86166     return ;
86167   }
86168   {
86169     try {
86170       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
86171     } catch (std::out_of_range& e) {
86172       {
86173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86174       };
86175     } catch (std::exception& e) {
86176       {
86177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86178       };
86179     } catch (...) {
86180       {
86181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86182       };
86183     }
86184   }
86185 }
86186
86187
86188 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
86189   unsigned long jresult ;
86190   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86191   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86192
86193   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86194   {
86195     try {
86196       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
86197     } catch (std::out_of_range& e) {
86198       {
86199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86200       };
86201     } catch (std::exception& e) {
86202       {
86203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86204       };
86205     } catch (...) {
86206       {
86207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86208       };
86209     }
86210   }
86211   jresult = (unsigned long)result;
86212   return jresult;
86213 }
86214
86215
86216 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
86217   unsigned long jresult ;
86218   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86219   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86220
86221   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86222   {
86223     try {
86224       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
86225     } catch (std::out_of_range& e) {
86226       {
86227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86228       };
86229     } catch (std::exception& e) {
86230       {
86231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86232       };
86233     } catch (...) {
86234       {
86235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86236       };
86237     }
86238   }
86239   jresult = (unsigned long)result;
86240   return jresult;
86241 }
86242
86243
86244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
86245   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86246   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
86247
86248   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86249   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
86250   {
86251     try {
86252       (arg1)->reserve(arg2);
86253     } catch (std::out_of_range& e) {
86254       {
86255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86256       };
86257     } catch (std::exception& e) {
86258       {
86259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86260       };
86261     } catch (...) {
86262       {
86263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86264       };
86265     }
86266   }
86267 }
86268
86269
86270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
86271   void * jresult ;
86272   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86273
86274   {
86275     try {
86276       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
86277     } catch (std::out_of_range& e) {
86278       {
86279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86280       };
86281     } catch (std::exception& e) {
86282       {
86283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86284       };
86285     } catch (...) {
86286       {
86287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86288       };
86289     }
86290   }
86291   jresult = (void *)result;
86292   return jresult;
86293 }
86294
86295
86296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
86297   void * jresult ;
86298   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
86299   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86300
86301   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86302   if (!arg1) {
86303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86304     return 0;
86305   }
86306   {
86307     try {
86308       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);
86309     } catch (std::out_of_range& e) {
86310       {
86311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86312       };
86313     } catch (std::exception& e) {
86314       {
86315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86316       };
86317     } catch (...) {
86318       {
86319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86320       };
86321     }
86322   }
86323   jresult = (void *)result;
86324   return jresult;
86325 }
86326
86327
86328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
86329   void * jresult ;
86330   int arg1 ;
86331   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86332
86333   arg1 = (int)jarg1;
86334   {
86335     try {
86336       try {
86337         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);
86338       }
86339       catch(std::out_of_range &_e) {
86340         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86341         return 0;
86342       }
86343
86344     } catch (std::out_of_range& e) {
86345       {
86346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86347       };
86348     } catch (std::exception& e) {
86349       {
86350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86351       };
86352     } catch (...) {
86353       {
86354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86355       };
86356     }
86357   }
86358   jresult = (void *)result;
86359   return jresult;
86360 }
86361
86362
86363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
86364   void * jresult ;
86365   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86366   int arg2 ;
86367   std::pair< unsigned int,Dali::Actor > result;
86368
86369   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86370   arg2 = (int)jarg2;
86371   {
86372     try {
86373       try {
86374         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
86375       }
86376       catch(std::out_of_range &_e) {
86377         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86378         return 0;
86379       }
86380
86381     } catch (std::out_of_range& e) {
86382       {
86383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86384       };
86385     } catch (std::exception& e) {
86386       {
86387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86388       };
86389     } catch (...) {
86390       {
86391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86392       };
86393     }
86394   }
86395   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
86396   return jresult;
86397 }
86398
86399
86400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
86401   void * jresult ;
86402   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86403   int arg2 ;
86404   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86405
86406   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86407   arg2 = (int)jarg2;
86408   {
86409     try {
86410       try {
86411         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
86412       }
86413       catch(std::out_of_range &_e) {
86414         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86415         return 0;
86416       }
86417
86418     } catch (std::out_of_range& e) {
86419       {
86420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86421       };
86422     } catch (std::exception& e) {
86423       {
86424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86425       };
86426     } catch (...) {
86427       {
86428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86429       };
86430     }
86431   }
86432   jresult = (void *)result;
86433   return jresult;
86434 }
86435
86436
86437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
86438   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86439   int arg2 ;
86440   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
86441
86442   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86443   arg2 = (int)jarg2;
86444   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
86445   if (!arg3) {
86446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86447     return ;
86448   }
86449   {
86450     try {
86451       try {
86452         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);
86453       }
86454       catch(std::out_of_range &_e) {
86455         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86456         return ;
86457       }
86458
86459     } catch (std::out_of_range& e) {
86460       {
86461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86462       };
86463     } catch (std::exception& e) {
86464       {
86465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86466       };
86467     } catch (...) {
86468       {
86469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86470       };
86471     }
86472   }
86473 }
86474
86475
86476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
86477   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86478   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
86479
86480   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86481   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
86482   if (!arg2) {
86483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86484     return ;
86485   }
86486   {
86487     try {
86488       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);
86489     } catch (std::out_of_range& e) {
86490       {
86491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86492       };
86493     } catch (std::exception& e) {
86494       {
86495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86496       };
86497     } catch (...) {
86498       {
86499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86500       };
86501     }
86502   }
86503 }
86504
86505
86506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
86507   void * jresult ;
86508   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86509   int arg2 ;
86510   int arg3 ;
86511   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86512
86513   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86514   arg2 = (int)jarg2;
86515   arg3 = (int)jarg3;
86516   {
86517     try {
86518       try {
86519         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);
86520       }
86521       catch(std::out_of_range &_e) {
86522         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86523         return 0;
86524       }
86525       catch(std::invalid_argument &_e) {
86526         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86527         return 0;
86528       }
86529
86530     } catch (std::out_of_range& e) {
86531       {
86532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86533       };
86534     } catch (std::exception& e) {
86535       {
86536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86537       };
86538     } catch (...) {
86539       {
86540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86541       };
86542     }
86543   }
86544   jresult = (void *)result;
86545   return jresult;
86546 }
86547
86548
86549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
86550   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86551   int arg2 ;
86552   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
86553
86554   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86555   arg2 = (int)jarg2;
86556   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
86557   if (!arg3) {
86558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86559     return ;
86560   }
86561   {
86562     try {
86563       try {
86564         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);
86565       }
86566       catch(std::out_of_range &_e) {
86567         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86568         return ;
86569       }
86570
86571     } catch (std::out_of_range& e) {
86572       {
86573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86574       };
86575     } catch (std::exception& e) {
86576       {
86577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86578       };
86579     } catch (...) {
86580       {
86581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86582       };
86583     }
86584   }
86585 }
86586
86587
86588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
86589   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86590   int arg2 ;
86591   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
86592
86593   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86594   arg2 = (int)jarg2;
86595   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
86596   if (!arg3) {
86597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86598     return ;
86599   }
86600   {
86601     try {
86602       try {
86603         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);
86604       }
86605       catch(std::out_of_range &_e) {
86606         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86607         return ;
86608       }
86609
86610     } catch (std::out_of_range& e) {
86611       {
86612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86613       };
86614     } catch (std::exception& e) {
86615       {
86616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86617       };
86618     } catch (...) {
86619       {
86620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86621       };
86622     }
86623   }
86624 }
86625
86626
86627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
86628   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86629   int arg2 ;
86630
86631   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86632   arg2 = (int)jarg2;
86633   {
86634     try {
86635       try {
86636         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
86637       }
86638       catch(std::out_of_range &_e) {
86639         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86640         return ;
86641       }
86642
86643     } catch (std::out_of_range& e) {
86644       {
86645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86646       };
86647     } catch (std::exception& e) {
86648       {
86649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86650       };
86651     } catch (...) {
86652       {
86653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86654       };
86655     }
86656   }
86657 }
86658
86659
86660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
86661   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86662   int arg2 ;
86663   int arg3 ;
86664
86665   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86666   arg2 = (int)jarg2;
86667   arg3 = (int)jarg3;
86668   {
86669     try {
86670       try {
86671         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
86672       }
86673       catch(std::out_of_range &_e) {
86674         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86675         return ;
86676       }
86677       catch(std::invalid_argument &_e) {
86678         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86679         return ;
86680       }
86681
86682     } catch (std::out_of_range& e) {
86683       {
86684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86685       };
86686     } catch (std::exception& e) {
86687       {
86688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86689       };
86690     } catch (...) {
86691       {
86692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86693       };
86694     }
86695   }
86696 }
86697
86698
86699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
86700   void * jresult ;
86701   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86702   int arg2 ;
86703   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86704
86705   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86706   if (!arg1) {
86707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86708     return 0;
86709   }
86710   arg2 = (int)jarg2;
86711   {
86712     try {
86713       try {
86714         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);
86715       }
86716       catch(std::out_of_range &_e) {
86717         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86718         return 0;
86719       }
86720
86721     } catch (std::out_of_range& e) {
86722       {
86723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86724       };
86725     } catch (std::exception& e) {
86726       {
86727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86728       };
86729     } catch (...) {
86730       {
86731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86732       };
86733     }
86734   }
86735   jresult = (void *)result;
86736   return jresult;
86737 }
86738
86739
86740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
86741   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86742
86743   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86744   {
86745     try {
86746       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
86747     } catch (std::out_of_range& e) {
86748       {
86749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86750       };
86751     } catch (std::exception& e) {
86752       {
86753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86754       };
86755     } catch (...) {
86756       {
86757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86758       };
86759     }
86760   }
86761 }
86762
86763
86764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
86765   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86766   int arg2 ;
86767   int arg3 ;
86768
86769   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86770   arg2 = (int)jarg2;
86771   arg3 = (int)jarg3;
86772   {
86773     try {
86774       try {
86775         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
86776       }
86777       catch(std::out_of_range &_e) {
86778         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86779         return ;
86780       }
86781       catch(std::invalid_argument &_e) {
86782         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86783         return ;
86784       }
86785
86786     } catch (std::out_of_range& e) {
86787       {
86788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86789       };
86790     } catch (std::exception& e) {
86791       {
86792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86793       };
86794     } catch (...) {
86795       {
86796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86797       };
86798     }
86799   }
86800 }
86801
86802
86803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
86804   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86805   int arg2 ;
86806   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
86807
86808   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86809   arg2 = (int)jarg2;
86810   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
86811   if (!arg3) {
86812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86813     return ;
86814   }
86815   {
86816     try {
86817       try {
86818         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);
86819       }
86820       catch(std::out_of_range &_e) {
86821         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86822         return ;
86823       }
86824
86825     } catch (std::out_of_range& e) {
86826       {
86827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86828       };
86829     } catch (std::exception& e) {
86830       {
86831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86832       };
86833     } catch (...) {
86834       {
86835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86836       };
86837     }
86838   }
86839 }
86840
86841
86842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
86843   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86844
86845   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86846   {
86847     try {
86848       delete arg1;
86849     } catch (std::out_of_range& e) {
86850       {
86851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86852       };
86853     } catch (std::exception& e) {
86854       {
86855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86856       };
86857     } catch (...) {
86858       {
86859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86860       };
86861     }
86862   }
86863 }
86864
86865
86866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
86867   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
86868
86869   arg1 = (std::vector< Dali::Actor > *)jarg1;
86870   {
86871     try {
86872       (arg1)->clear();
86873     } catch (std::out_of_range& e) {
86874       {
86875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86876       };
86877     } catch (std::exception& e) {
86878       {
86879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86880       };
86881     } catch (...) {
86882       {
86883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86884       };
86885     }
86886   }
86887 }
86888
86889
86890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
86891   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
86892   Dali::Actor *arg2 = 0 ;
86893
86894   arg1 = (std::vector< Dali::Actor > *)jarg1;
86895   arg2 = (Dali::Actor *)jarg2;
86896   if (!arg2) {
86897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
86898     return ;
86899   }
86900   {
86901     try {
86902       (arg1)->push_back((Dali::Actor const &)*arg2);
86903     } catch (std::out_of_range& e) {
86904       {
86905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86906       };
86907     } catch (std::exception& e) {
86908       {
86909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86910       };
86911     } catch (...) {
86912       {
86913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86914       };
86915     }
86916   }
86917 }
86918
86919
86920 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
86921   unsigned long jresult ;
86922   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
86923   std::vector< Dali::Actor >::size_type result;
86924
86925   arg1 = (std::vector< Dali::Actor > *)jarg1;
86926   {
86927     try {
86928       result = ((std::vector< Dali::Actor > const *)arg1)->size();
86929     } catch (std::out_of_range& e) {
86930       {
86931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86932       };
86933     } catch (std::exception& e) {
86934       {
86935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86936       };
86937     } catch (...) {
86938       {
86939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86940       };
86941     }
86942   }
86943   jresult = (unsigned long)result;
86944   return jresult;
86945 }
86946
86947
86948 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
86949   unsigned long jresult ;
86950   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
86951   std::vector< Dali::Actor >::size_type result;
86952
86953   arg1 = (std::vector< Dali::Actor > *)jarg1;
86954   {
86955     try {
86956       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
86957     } catch (std::out_of_range& e) {
86958       {
86959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86960       };
86961     } catch (std::exception& e) {
86962       {
86963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86964       };
86965     } catch (...) {
86966       {
86967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86968       };
86969     }
86970   }
86971   jresult = (unsigned long)result;
86972   return jresult;
86973 }
86974
86975
86976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
86977   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
86978   std::vector< Dali::Actor >::size_type arg2 ;
86979
86980   arg1 = (std::vector< Dali::Actor > *)jarg1;
86981   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
86982   {
86983     try {
86984       (arg1)->reserve(arg2);
86985     } catch (std::out_of_range& e) {
86986       {
86987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86988       };
86989     } catch (std::exception& e) {
86990       {
86991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86992       };
86993     } catch (...) {
86994       {
86995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86996       };
86997     }
86998   }
86999 }
87000
87001
87002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
87003   void * jresult ;
87004   std::vector< Dali::Actor > *result = 0 ;
87005
87006   {
87007     try {
87008       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
87009     } catch (std::out_of_range& e) {
87010       {
87011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87012       };
87013     } catch (std::exception& e) {
87014       {
87015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87016       };
87017     } catch (...) {
87018       {
87019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87020       };
87021     }
87022   }
87023   jresult = (void *)result;
87024   return jresult;
87025 }
87026
87027
87028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
87029   void * jresult ;
87030   std::vector< Dali::Actor > *arg1 = 0 ;
87031   std::vector< Dali::Actor > *result = 0 ;
87032
87033   arg1 = (std::vector< Dali::Actor > *)jarg1;
87034   if (!arg1) {
87035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87036     return 0;
87037   }
87038   {
87039     try {
87040       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
87041     } catch (std::out_of_range& e) {
87042       {
87043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87044       };
87045     } catch (std::exception& e) {
87046       {
87047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87048       };
87049     } catch (...) {
87050       {
87051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87052       };
87053     }
87054   }
87055   jresult = (void *)result;
87056   return jresult;
87057 }
87058
87059
87060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
87061   void * jresult ;
87062   int arg1 ;
87063   std::vector< Dali::Actor > *result = 0 ;
87064
87065   arg1 = (int)jarg1;
87066   {
87067     try {
87068       try {
87069         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
87070       }
87071       catch(std::out_of_range &_e) {
87072         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87073         return 0;
87074       }
87075
87076     } catch (std::out_of_range& e) {
87077       {
87078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87079       };
87080     } catch (std::exception& e) {
87081       {
87082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87083       };
87084     } catch (...) {
87085       {
87086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87087       };
87088     }
87089   }
87090   jresult = (void *)result;
87091   return jresult;
87092 }
87093
87094
87095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
87096   void * jresult ;
87097   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87098   int arg2 ;
87099   Dali::Actor result;
87100
87101   arg1 = (std::vector< Dali::Actor > *)jarg1;
87102   arg2 = (int)jarg2;
87103   {
87104     try {
87105       try {
87106         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
87107       }
87108       catch(std::out_of_range &_e) {
87109         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87110         return 0;
87111       }
87112
87113     } catch (std::out_of_range& e) {
87114       {
87115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87116       };
87117     } catch (std::exception& e) {
87118       {
87119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87120       };
87121     } catch (...) {
87122       {
87123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87124       };
87125     }
87126   }
87127   jresult = new Dali::Actor((const Dali::Actor &)result);
87128   return jresult;
87129 }
87130
87131
87132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
87133   void * jresult ;
87134   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87135   int arg2 ;
87136   Dali::Actor *result = 0 ;
87137
87138   arg1 = (std::vector< Dali::Actor > *)jarg1;
87139   arg2 = (int)jarg2;
87140   {
87141     try {
87142       try {
87143         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
87144       }
87145       catch(std::out_of_range &_e) {
87146         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87147         return 0;
87148       }
87149
87150     } catch (std::out_of_range& e) {
87151       {
87152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87153       };
87154     } catch (std::exception& e) {
87155       {
87156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87157       };
87158     } catch (...) {
87159       {
87160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87161       };
87162     }
87163   }
87164   jresult = (void *)result;
87165   return jresult;
87166 }
87167
87168
87169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87170   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87171   int arg2 ;
87172   Dali::Actor *arg3 = 0 ;
87173
87174   arg1 = (std::vector< Dali::Actor > *)jarg1;
87175   arg2 = (int)jarg2;
87176   arg3 = (Dali::Actor *)jarg3;
87177   if (!arg3) {
87178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87179     return ;
87180   }
87181   {
87182     try {
87183       try {
87184         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
87185       }
87186       catch(std::out_of_range &_e) {
87187         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87188         return ;
87189       }
87190
87191     } catch (std::out_of_range& e) {
87192       {
87193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87194       };
87195     } catch (std::exception& e) {
87196       {
87197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87198       };
87199     } catch (...) {
87200       {
87201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87202       };
87203     }
87204   }
87205 }
87206
87207
87208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
87209   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87210   std::vector< Dali::Actor > *arg2 = 0 ;
87211
87212   arg1 = (std::vector< Dali::Actor > *)jarg1;
87213   arg2 = (std::vector< Dali::Actor > *)jarg2;
87214   if (!arg2) {
87215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87216     return ;
87217   }
87218   {
87219     try {
87220       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
87221     } catch (std::out_of_range& e) {
87222       {
87223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87224       };
87225     } catch (std::exception& e) {
87226       {
87227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87228       };
87229     } catch (...) {
87230       {
87231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87232       };
87233     }
87234   }
87235 }
87236
87237
87238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87239   void * jresult ;
87240   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87241   int arg2 ;
87242   int arg3 ;
87243   std::vector< Dali::Actor > *result = 0 ;
87244
87245   arg1 = (std::vector< Dali::Actor > *)jarg1;
87246   arg2 = (int)jarg2;
87247   arg3 = (int)jarg3;
87248   {
87249     try {
87250       try {
87251         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
87252       }
87253       catch(std::out_of_range &_e) {
87254         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87255         return 0;
87256       }
87257       catch(std::invalid_argument &_e) {
87258         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87259         return 0;
87260       }
87261
87262     } catch (std::out_of_range& e) {
87263       {
87264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87265       };
87266     } catch (std::exception& e) {
87267       {
87268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87269       };
87270     } catch (...) {
87271       {
87272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87273       };
87274     }
87275   }
87276   jresult = (void *)result;
87277   return jresult;
87278 }
87279
87280
87281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87282   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87283   int arg2 ;
87284   Dali::Actor *arg3 = 0 ;
87285
87286   arg1 = (std::vector< Dali::Actor > *)jarg1;
87287   arg2 = (int)jarg2;
87288   arg3 = (Dali::Actor *)jarg3;
87289   if (!arg3) {
87290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87291     return ;
87292   }
87293   {
87294     try {
87295       try {
87296         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
87297       }
87298       catch(std::out_of_range &_e) {
87299         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87300         return ;
87301       }
87302
87303     } catch (std::out_of_range& e) {
87304       {
87305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87306       };
87307     } catch (std::exception& e) {
87308       {
87309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87310       };
87311     } catch (...) {
87312       {
87313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87314       };
87315     }
87316   }
87317 }
87318
87319
87320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87321   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87322   int arg2 ;
87323   std::vector< Dali::Actor > *arg3 = 0 ;
87324
87325   arg1 = (std::vector< Dali::Actor > *)jarg1;
87326   arg2 = (int)jarg2;
87327   arg3 = (std::vector< Dali::Actor > *)jarg3;
87328   if (!arg3) {
87329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87330     return ;
87331   }
87332   {
87333     try {
87334       try {
87335         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
87336       }
87337       catch(std::out_of_range &_e) {
87338         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87339         return ;
87340       }
87341
87342     } catch (std::out_of_range& e) {
87343       {
87344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87345       };
87346     } catch (std::exception& e) {
87347       {
87348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87349       };
87350     } catch (...) {
87351       {
87352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87353       };
87354     }
87355   }
87356 }
87357
87358
87359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
87360   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87361   int arg2 ;
87362
87363   arg1 = (std::vector< Dali::Actor > *)jarg1;
87364   arg2 = (int)jarg2;
87365   {
87366     try {
87367       try {
87368         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
87369       }
87370       catch(std::out_of_range &_e) {
87371         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87372         return ;
87373       }
87374
87375     } catch (std::out_of_range& e) {
87376       {
87377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87378       };
87379     } catch (std::exception& e) {
87380       {
87381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87382       };
87383     } catch (...) {
87384       {
87385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87386       };
87387     }
87388   }
87389 }
87390
87391
87392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87393   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87394   int arg2 ;
87395   int arg3 ;
87396
87397   arg1 = (std::vector< Dali::Actor > *)jarg1;
87398   arg2 = (int)jarg2;
87399   arg3 = (int)jarg3;
87400   {
87401     try {
87402       try {
87403         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
87404       }
87405       catch(std::out_of_range &_e) {
87406         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87407         return ;
87408       }
87409       catch(std::invalid_argument &_e) {
87410         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87411         return ;
87412       }
87413
87414     } catch (std::out_of_range& e) {
87415       {
87416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87417       };
87418     } catch (std::exception& e) {
87419       {
87420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87421       };
87422     } catch (...) {
87423       {
87424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87425       };
87426     }
87427   }
87428 }
87429
87430
87431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
87432   void * jresult ;
87433   Dali::Actor *arg1 = 0 ;
87434   int arg2 ;
87435   std::vector< Dali::Actor > *result = 0 ;
87436
87437   arg1 = (Dali::Actor *)jarg1;
87438   if (!arg1) {
87439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87440     return 0;
87441   }
87442   arg2 = (int)jarg2;
87443   {
87444     try {
87445       try {
87446         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
87447       }
87448       catch(std::out_of_range &_e) {
87449         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87450         return 0;
87451       }
87452
87453     } catch (std::out_of_range& e) {
87454       {
87455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87456       };
87457     } catch (std::exception& e) {
87458       {
87459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87460       };
87461     } catch (...) {
87462       {
87463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87464       };
87465     }
87466   }
87467   jresult = (void *)result;
87468   return jresult;
87469 }
87470
87471
87472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
87473   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87474
87475   arg1 = (std::vector< Dali::Actor > *)jarg1;
87476   {
87477     try {
87478       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
87479     } catch (std::out_of_range& e) {
87480       {
87481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87482       };
87483     } catch (std::exception& e) {
87484       {
87485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87486       };
87487     } catch (...) {
87488       {
87489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87490       };
87491     }
87492   }
87493 }
87494
87495
87496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87497   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87498   int arg2 ;
87499   int arg3 ;
87500
87501   arg1 = (std::vector< Dali::Actor > *)jarg1;
87502   arg2 = (int)jarg2;
87503   arg3 = (int)jarg3;
87504   {
87505     try {
87506       try {
87507         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87508       }
87509       catch(std::out_of_range &_e) {
87510         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87511         return ;
87512       }
87513       catch(std::invalid_argument &_e) {
87514         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87515         return ;
87516       }
87517
87518     } catch (std::out_of_range& e) {
87519       {
87520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87521       };
87522     } catch (std::exception& e) {
87523       {
87524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87525       };
87526     } catch (...) {
87527       {
87528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87529       };
87530     }
87531   }
87532 }
87533
87534
87535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87536   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87537   int arg2 ;
87538   std::vector< Dali::Actor > *arg3 = 0 ;
87539
87540   arg1 = (std::vector< Dali::Actor > *)jarg1;
87541   arg2 = (int)jarg2;
87542   arg3 = (std::vector< Dali::Actor > *)jarg3;
87543   if (!arg3) {
87544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87545     return ;
87546   }
87547   {
87548     try {
87549       try {
87550         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
87551       }
87552       catch(std::out_of_range &_e) {
87553         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87554         return ;
87555       }
87556
87557     } catch (std::out_of_range& e) {
87558       {
87559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87560       };
87561     } catch (std::exception& e) {
87562       {
87563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87564       };
87565     } catch (...) {
87566       {
87567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87568       };
87569     }
87570   }
87571 }
87572
87573
87574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
87575   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87576
87577   arg1 = (std::vector< Dali::Actor > *)jarg1;
87578   {
87579     try {
87580       delete arg1;
87581     } catch (std::out_of_range& e) {
87582       {
87583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87584       };
87585     } catch (std::exception& e) {
87586       {
87587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87588       };
87589     } catch (...) {
87590       {
87591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87592       };
87593     }
87594   }
87595 }
87596
87597
87598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
87599   unsigned int jresult ;
87600   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
87601   bool result;
87602
87603   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
87604   {
87605     try {
87606       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
87607     } catch (std::out_of_range& e) {
87608       {
87609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87610       };
87611     } catch (std::exception& e) {
87612       {
87613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87614       };
87615     } catch (...) {
87616       {
87617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87618       };
87619     }
87620   }
87621   jresult = result;
87622   return jresult;
87623 }
87624
87625
87626 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
87627   unsigned long jresult ;
87628   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
87629   std::size_t result;
87630
87631   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
87632   {
87633     try {
87634       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
87635     } catch (std::out_of_range& e) {
87636       {
87637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87638       };
87639     } catch (std::exception& e) {
87640       {
87641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87642       };
87643     } catch (...) {
87644       {
87645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87646       };
87647     }
87648   }
87649   jresult = (unsigned long)result;
87650   return jresult;
87651 }
87652
87653
87654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
87655   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
87656   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
87657
87658   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
87659   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
87660   {
87661     try {
87662       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
87663     } catch (std::out_of_range& e) {
87664       {
87665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87666       };
87667     } catch (std::exception& e) {
87668       {
87669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87670       };
87671     } catch (...) {
87672       {
87673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87674       };
87675     }
87676   }
87677 }
87678
87679
87680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
87681   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
87682   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
87683
87684   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
87685   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
87686   {
87687     try {
87688       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
87689     } catch (std::out_of_range& e) {
87690       {
87691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87692       };
87693     } catch (std::exception& e) {
87694       {
87695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87696       };
87697     } catch (...) {
87698       {
87699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87700       };
87701     }
87702   }
87703 }
87704
87705
87706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
87707   unsigned int jresult ;
87708   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
87709   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
87710   bool result;
87711
87712   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
87713   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
87714   if (!arg2) {
87715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
87716     return 0;
87717   }
87718   {
87719     try {
87720       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
87721     } catch (std::out_of_range& e) {
87722       {
87723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87724       };
87725     } catch (std::exception& e) {
87726       {
87727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87728       };
87729     } catch (...) {
87730       {
87731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87732       };
87733     }
87734   }
87735   jresult = result;
87736   return jresult;
87737 }
87738
87739
87740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
87741   void * jresult ;
87742   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
87743
87744   {
87745     try {
87746       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
87747     } catch (std::out_of_range& e) {
87748       {
87749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87750       };
87751     } catch (std::exception& e) {
87752       {
87753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87754       };
87755     } catch (...) {
87756       {
87757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87758       };
87759     }
87760   }
87761   jresult = (void *)result;
87762   return jresult;
87763 }
87764
87765
87766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
87767   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
87768
87769   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
87770   {
87771     try {
87772       delete arg1;
87773     } catch (std::out_of_range& e) {
87774       {
87775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87776       };
87777     } catch (std::exception& e) {
87778       {
87779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87780       };
87781     } catch (...) {
87782       {
87783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87784       };
87785     }
87786   }
87787 }
87788
87789
87790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
87791   unsigned int jresult ;
87792   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
87793   bool result;
87794
87795   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
87796   {
87797     try {
87798       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);
87799     } catch (std::out_of_range& e) {
87800       {
87801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87802       };
87803     } catch (std::exception& e) {
87804       {
87805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87806       };
87807     } catch (...) {
87808       {
87809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87810       };
87811     }
87812   }
87813   jresult = result;
87814   return jresult;
87815 }
87816
87817
87818 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
87819   unsigned long jresult ;
87820   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
87821   std::size_t result;
87822
87823   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
87824   {
87825     try {
87826       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);
87827     } catch (std::out_of_range& e) {
87828       {
87829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87830       };
87831     } catch (std::exception& e) {
87832       {
87833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87834       };
87835     } catch (...) {
87836       {
87837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87838       };
87839     }
87840   }
87841   jresult = (unsigned long)result;
87842   return jresult;
87843 }
87844
87845
87846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
87847   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
87848   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
87849
87850   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
87851   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
87852   {
87853     try {
87854       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
87855     } catch (std::out_of_range& e) {
87856       {
87857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87858       };
87859     } catch (std::exception& e) {
87860       {
87861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87862       };
87863     } catch (...) {
87864       {
87865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87866       };
87867     }
87868   }
87869 }
87870
87871
87872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
87873   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
87874   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
87875
87876   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
87877   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
87878   {
87879     try {
87880       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
87881     } catch (std::out_of_range& e) {
87882       {
87883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87884       };
87885     } catch (std::exception& e) {
87886       {
87887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87888       };
87889     } catch (...) {
87890       {
87891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87892       };
87893     }
87894   }
87895 }
87896
87897
87898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
87899   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
87900   Dali::Actor arg2 ;
87901   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
87902   Dali::Actor *argp2 ;
87903
87904   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
87905   argp2 = (Dali::Actor *)jarg2;
87906   if (!argp2) {
87907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87908     return ;
87909   }
87910   arg2 = *argp2;
87911   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
87912   {
87913     try {
87914       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
87915     } catch (std::out_of_range& e) {
87916       {
87917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87918       };
87919     } catch (std::exception& e) {
87920       {
87921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87922       };
87923     } catch (...) {
87924       {
87925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87926       };
87927     }
87928   }
87929 }
87930
87931
87932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
87933   void * jresult ;
87934   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
87935
87936   {
87937     try {
87938       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
87939     } catch (std::out_of_range& e) {
87940       {
87941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87942       };
87943     } catch (std::exception& e) {
87944       {
87945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87946       };
87947     } catch (...) {
87948       {
87949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87950       };
87951     }
87952   }
87953   jresult = (void *)result;
87954   return jresult;
87955 }
87956
87957
87958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
87959   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
87960
87961   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
87962   {
87963     try {
87964       delete arg1;
87965     } catch (std::out_of_range& e) {
87966       {
87967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87968       };
87969     } catch (std::exception& e) {
87970       {
87971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87972       };
87973     } catch (...) {
87974       {
87975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87976       };
87977     }
87978   }
87979 }
87980
87981
87982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
87983   unsigned int jresult ;
87984   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
87985   bool result;
87986
87987   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
87988   {
87989     try {
87990       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
87991     } catch (std::out_of_range& e) {
87992       {
87993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87994       };
87995     } catch (std::exception& e) {
87996       {
87997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87998       };
87999     } catch (...) {
88000       {
88001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88002       };
88003     }
88004   }
88005   jresult = result;
88006   return jresult;
88007 }
88008
88009
88010 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
88011   unsigned long jresult ;
88012   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88013   std::size_t result;
88014
88015   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88016   {
88017     try {
88018       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88019     } catch (std::out_of_range& e) {
88020       {
88021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88022       };
88023     } catch (std::exception& e) {
88024       {
88025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88026       };
88027     } catch (...) {
88028       {
88029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88030       };
88031     }
88032   }
88033   jresult = (unsigned long)result;
88034   return jresult;
88035 }
88036
88037
88038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
88039   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88040   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88041
88042   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88043   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88044   {
88045     try {
88046       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
88047     } catch (std::out_of_range& e) {
88048       {
88049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88050       };
88051     } catch (std::exception& e) {
88052       {
88053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88054       };
88055     } catch (...) {
88056       {
88057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88058       };
88059     }
88060   }
88061 }
88062
88063
88064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88065   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88066   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88067
88068   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88069   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88070   {
88071     try {
88072       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
88073     } catch (std::out_of_range& e) {
88074       {
88075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88076       };
88077     } catch (std::exception& e) {
88078       {
88079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88080       };
88081     } catch (...) {
88082       {
88083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88084       };
88085     }
88086   }
88087 }
88088
88089
88090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
88091   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88092   Dali::Actor arg2 ;
88093   Dali::Actor arg3 ;
88094   Dali::Actor *argp2 ;
88095   Dali::Actor *argp3 ;
88096
88097   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88098   argp2 = (Dali::Actor *)jarg2;
88099   if (!argp2) {
88100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88101     return ;
88102   }
88103   arg2 = *argp2;
88104   argp3 = (Dali::Actor *)jarg3;
88105   if (!argp3) {
88106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88107     return ;
88108   }
88109   arg3 = *argp3;
88110   {
88111     try {
88112       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
88113     } catch (std::out_of_range& e) {
88114       {
88115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88116       };
88117     } catch (std::exception& e) {
88118       {
88119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88120       };
88121     } catch (...) {
88122       {
88123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88124       };
88125     }
88126   }
88127 }
88128
88129
88130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
88131   void * jresult ;
88132   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
88133
88134   {
88135     try {
88136       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
88137     } catch (std::out_of_range& e) {
88138       {
88139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88140       };
88141     } catch (std::exception& e) {
88142       {
88143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88144       };
88145     } catch (...) {
88146       {
88147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88148       };
88149     }
88150   }
88151   jresult = (void *)result;
88152   return jresult;
88153 }
88154
88155
88156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
88157   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88158
88159   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88160   {
88161     try {
88162       delete arg1;
88163     } catch (std::out_of_range& e) {
88164       {
88165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88166       };
88167     } catch (std::exception& e) {
88168       {
88169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88170       };
88171     } catch (...) {
88172       {
88173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88174       };
88175     }
88176   }
88177 }
88178
88179
88180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
88181   unsigned int jresult ;
88182   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88183   bool result;
88184
88185   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88186   {
88187     try {
88188       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88189     } catch (std::out_of_range& e) {
88190       {
88191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88192       };
88193     } catch (std::exception& e) {
88194       {
88195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88196       };
88197     } catch (...) {
88198       {
88199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88200       };
88201     }
88202   }
88203   jresult = result;
88204   return jresult;
88205 }
88206
88207
88208 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
88209   unsigned long jresult ;
88210   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88211   std::size_t result;
88212
88213   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88214   {
88215     try {
88216       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88217     } catch (std::out_of_range& e) {
88218       {
88219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88220       };
88221     } catch (std::exception& e) {
88222       {
88223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88224       };
88225     } catch (...) {
88226       {
88227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88228       };
88229     }
88230   }
88231   jresult = (unsigned long)result;
88232   return jresult;
88233 }
88234
88235
88236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
88237   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88238   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88239
88240   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88241   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88242   {
88243     try {
88244       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
88245     } catch (std::out_of_range& e) {
88246       {
88247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88248       };
88249     } catch (std::exception& e) {
88250       {
88251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88252       };
88253     } catch (...) {
88254       {
88255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88256       };
88257     }
88258   }
88259 }
88260
88261
88262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88263   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88264   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88265
88266   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88267   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88268   {
88269     try {
88270       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
88271     } catch (std::out_of_range& e) {
88272       {
88273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88274       };
88275     } catch (std::exception& e) {
88276       {
88277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88278       };
88279     } catch (...) {
88280       {
88281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88282       };
88283     }
88284   }
88285 }
88286
88287
88288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
88289   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88290   Dali::Actor arg2 ;
88291   bool arg3 ;
88292   Dali::Actor *argp2 ;
88293
88294   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88295   argp2 = (Dali::Actor *)jarg2;
88296   if (!argp2) {
88297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88298     return ;
88299   }
88300   arg2 = *argp2;
88301   arg3 = jarg3 ? true : false;
88302   {
88303     try {
88304       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
88305     } catch (std::out_of_range& e) {
88306       {
88307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88308       };
88309     } catch (std::exception& e) {
88310       {
88311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88312       };
88313     } catch (...) {
88314       {
88315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88316       };
88317     }
88318   }
88319 }
88320
88321
88322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
88323   void * jresult ;
88324   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
88325
88326   {
88327     try {
88328       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
88329     } catch (std::out_of_range& e) {
88330       {
88331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88332       };
88333     } catch (std::exception& e) {
88334       {
88335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88336       };
88337     } catch (...) {
88338       {
88339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88340       };
88341     }
88342   }
88343   jresult = (void *)result;
88344   return jresult;
88345 }
88346
88347
88348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
88349   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88350
88351   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88352   {
88353     try {
88354       delete arg1;
88355     } catch (std::out_of_range& e) {
88356       {
88357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88358       };
88359     } catch (std::exception& e) {
88360       {
88361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88362       };
88363     } catch (...) {
88364       {
88365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88366       };
88367     }
88368   }
88369 }
88370
88371
88372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
88373   unsigned int jresult ;
88374   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88375   bool result;
88376
88377   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88378   {
88379     try {
88380       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);
88381     } catch (std::out_of_range& e) {
88382       {
88383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88384       };
88385     } catch (std::exception& e) {
88386       {
88387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88388       };
88389     } catch (...) {
88390       {
88391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88392       };
88393     }
88394   }
88395   jresult = result;
88396   return jresult;
88397 }
88398
88399
88400 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
88401   unsigned long jresult ;
88402   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88403   std::size_t result;
88404
88405   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88406   {
88407     try {
88408       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);
88409     } catch (std::out_of_range& e) {
88410       {
88411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88412       };
88413     } catch (std::exception& e) {
88414       {
88415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88416       };
88417     } catch (...) {
88418       {
88419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88420       };
88421     }
88422   }
88423   jresult = (unsigned long)result;
88424   return jresult;
88425 }
88426
88427
88428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
88429   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88430   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
88431
88432   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88433   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
88434   {
88435     try {
88436       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
88437     } catch (std::out_of_range& e) {
88438       {
88439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88440       };
88441     } catch (std::exception& e) {
88442       {
88443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88444       };
88445     } catch (...) {
88446       {
88447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88448       };
88449     }
88450   }
88451 }
88452
88453
88454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88455   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88456   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
88457
88458   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88459   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
88460   {
88461     try {
88462       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
88463     } catch (std::out_of_range& e) {
88464       {
88465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88466       };
88467     } catch (std::exception& e) {
88468       {
88469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88470       };
88471     } catch (...) {
88472       {
88473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88474       };
88475     }
88476   }
88477 }
88478
88479
88480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88481   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88482   Dali::Toolkit::StyleManager arg2 ;
88483   Dali::StyleChange::Type arg3 ;
88484   Dali::Toolkit::StyleManager *argp2 ;
88485
88486   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88487   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
88488   if (!argp2) {
88489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
88490     return ;
88491   }
88492   arg2 = *argp2;
88493   arg3 = (Dali::StyleChange::Type)jarg3;
88494   {
88495     try {
88496       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
88497     } catch (std::out_of_range& e) {
88498       {
88499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88500       };
88501     } catch (std::exception& e) {
88502       {
88503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88504       };
88505     } catch (...) {
88506       {
88507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88508       };
88509     }
88510   }
88511 }
88512
88513
88514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
88515   void * jresult ;
88516   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
88517
88518   {
88519     try {
88520       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
88521     } catch (std::out_of_range& e) {
88522       {
88523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88524       };
88525     } catch (std::exception& e) {
88526       {
88527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88528       };
88529     } catch (...) {
88530       {
88531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88532       };
88533     }
88534   }
88535   jresult = (void *)result;
88536   return jresult;
88537 }
88538
88539
88540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
88541   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88542
88543   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88544   {
88545     try {
88546       delete arg1;
88547     } catch (std::out_of_range& e) {
88548       {
88549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88550       };
88551     } catch (std::exception& e) {
88552       {
88553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88554       };
88555     } catch (...) {
88556       {
88557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88558       };
88559     }
88560   }
88561 }
88562
88563
88564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
88565   unsigned int jresult ;
88566   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88567   bool result;
88568
88569   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88570   {
88571     try {
88572       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
88573     } catch (std::out_of_range& e) {
88574       {
88575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88576       };
88577     } catch (std::exception& e) {
88578       {
88579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88580       };
88581     } catch (...) {
88582       {
88583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88584       };
88585     }
88586   }
88587   jresult = result;
88588   return jresult;
88589 }
88590
88591
88592 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
88593   unsigned long jresult ;
88594   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88595   std::size_t result;
88596
88597   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88598   {
88599     try {
88600       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
88601     } catch (std::out_of_range& e) {
88602       {
88603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88604       };
88605     } catch (std::exception& e) {
88606       {
88607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88608       };
88609     } catch (...) {
88610       {
88611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88612       };
88613     }
88614   }
88615   jresult = (unsigned long)result;
88616   return jresult;
88617 }
88618
88619
88620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
88621   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88622   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
88623
88624   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88625   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
88626   {
88627     try {
88628       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
88629     } catch (std::out_of_range& e) {
88630       {
88631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88632       };
88633     } catch (std::exception& e) {
88634       {
88635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88636       };
88637     } catch (...) {
88638       {
88639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88640       };
88641     }
88642   }
88643 }
88644
88645
88646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
88647   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88648   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
88649
88650   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88651   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
88652   {
88653     try {
88654       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
88655     } catch (std::out_of_range& e) {
88656       {
88657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88658       };
88659     } catch (std::exception& e) {
88660       {
88661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88662       };
88663     } catch (...) {
88664       {
88665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88666       };
88667     }
88668   }
88669 }
88670
88671
88672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
88673   unsigned int jresult ;
88674   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88675   Dali::Toolkit::Button arg2 ;
88676   Dali::Toolkit::Button *argp2 ;
88677   bool result;
88678
88679   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88680   argp2 = (Dali::Toolkit::Button *)jarg2;
88681   if (!argp2) {
88682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
88683     return 0;
88684   }
88685   arg2 = *argp2;
88686   {
88687     try {
88688       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
88689     } catch (std::out_of_range& e) {
88690       {
88691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88692       };
88693     } catch (std::exception& e) {
88694       {
88695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88696       };
88697     } catch (...) {
88698       {
88699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88700       };
88701     }
88702   }
88703   jresult = result;
88704   return jresult;
88705 }
88706
88707
88708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
88709   void * jresult ;
88710   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
88711
88712   {
88713     try {
88714       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
88715     } catch (std::out_of_range& e) {
88716       {
88717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88718       };
88719     } catch (std::exception& e) {
88720       {
88721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88722       };
88723     } catch (...) {
88724       {
88725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88726       };
88727     }
88728   }
88729   jresult = (void *)result;
88730   return jresult;
88731 }
88732
88733
88734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
88735   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88736
88737   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88738   {
88739     try {
88740       delete arg1;
88741     } catch (std::out_of_range& e) {
88742       {
88743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88744       };
88745     } catch (std::exception& e) {
88746       {
88747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88748       };
88749     } catch (...) {
88750       {
88751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88752       };
88753     }
88754   }
88755 }
88756
88757
88758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
88759   unsigned int jresult ;
88760   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
88761   bool result;
88762
88763   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
88764   {
88765     try {
88766       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
88767     } catch (std::out_of_range& e) {
88768       {
88769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88770       };
88771     } catch (std::exception& e) {
88772       {
88773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88774       };
88775     } catch (...) {
88776       {
88777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88778       };
88779     }
88780   }
88781   jresult = result;
88782   return jresult;
88783 }
88784
88785
88786 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
88787   unsigned long jresult ;
88788   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
88789   std::size_t result;
88790
88791   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
88792   {
88793     try {
88794       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
88795     } catch (std::out_of_range& e) {
88796       {
88797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88798       };
88799     } catch (std::exception& e) {
88800       {
88801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88802       };
88803     } catch (...) {
88804       {
88805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88806       };
88807     }
88808   }
88809   jresult = (unsigned long)result;
88810   return jresult;
88811 }
88812
88813
88814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
88815   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
88816   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
88817
88818   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
88819   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
88820   {
88821     try {
88822       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
88823     } catch (std::out_of_range& e) {
88824       {
88825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88826       };
88827     } catch (std::exception& e) {
88828       {
88829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88830       };
88831     } catch (...) {
88832       {
88833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88834       };
88835     }
88836   }
88837 }
88838
88839
88840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
88841   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
88842   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
88843
88844   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
88845   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
88846   {
88847     try {
88848       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
88849     } catch (std::out_of_range& e) {
88850       {
88851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88852       };
88853     } catch (std::exception& e) {
88854       {
88855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88856       };
88857     } catch (...) {
88858       {
88859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88860       };
88861     }
88862   }
88863 }
88864
88865
88866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
88867   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
88868   Dali::Toolkit::GaussianBlurView arg2 ;
88869   Dali::Toolkit::GaussianBlurView *argp2 ;
88870
88871   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
88872   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
88873   if (!argp2) {
88874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
88875     return ;
88876   }
88877   arg2 = *argp2;
88878   {
88879     try {
88880       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
88881     } catch (std::out_of_range& e) {
88882       {
88883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88884       };
88885     } catch (std::exception& e) {
88886       {
88887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88888       };
88889     } catch (...) {
88890       {
88891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88892       };
88893     }
88894   }
88895 }
88896
88897
88898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
88899   void * jresult ;
88900   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
88901
88902   {
88903     try {
88904       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
88905     } catch (std::out_of_range& e) {
88906       {
88907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88908       };
88909     } catch (std::exception& e) {
88910       {
88911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88912       };
88913     } catch (...) {
88914       {
88915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88916       };
88917     }
88918   }
88919   jresult = (void *)result;
88920   return jresult;
88921 }
88922
88923
88924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
88925   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
88926
88927   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
88928   {
88929     try {
88930       delete arg1;
88931     } catch (std::out_of_range& e) {
88932       {
88933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88934       };
88935     } catch (std::exception& e) {
88936       {
88937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88938       };
88939     } catch (...) {
88940       {
88941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88942       };
88943     }
88944   }
88945 }
88946
88947
88948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
88949   unsigned int jresult ;
88950   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
88951   bool result;
88952
88953   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
88954   {
88955     try {
88956       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);
88957     } catch (std::out_of_range& e) {
88958       {
88959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88960       };
88961     } catch (std::exception& e) {
88962       {
88963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88964       };
88965     } catch (...) {
88966       {
88967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88968       };
88969     }
88970   }
88971   jresult = result;
88972   return jresult;
88973 }
88974
88975
88976 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
88977   unsigned long jresult ;
88978   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
88979   std::size_t result;
88980
88981   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
88982   {
88983     try {
88984       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);
88985     } catch (std::out_of_range& e) {
88986       {
88987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88988       };
88989     } catch (std::exception& e) {
88990       {
88991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88992       };
88993     } catch (...) {
88994       {
88995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88996       };
88997     }
88998   }
88999   jresult = (unsigned long)result;
89000   return jresult;
89001 }
89002
89003
89004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
89005   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89006   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89007
89008   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89009   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89010   {
89011     try {
89012       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
89013     } catch (std::out_of_range& e) {
89014       {
89015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89016       };
89017     } catch (std::exception& e) {
89018       {
89019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89020       };
89021     } catch (...) {
89022       {
89023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89024       };
89025     }
89026   }
89027 }
89028
89029
89030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
89031   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89032   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89033
89034   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89035   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89036   {
89037     try {
89038       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89039     } catch (std::out_of_range& e) {
89040       {
89041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89042       };
89043     } catch (std::exception& e) {
89044       {
89045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89046       };
89047     } catch (...) {
89048       {
89049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89050       };
89051     }
89052   }
89053 }
89054
89055
89056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
89057   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89058   Dali::Toolkit::PageTurnView arg2 ;
89059   unsigned int arg3 ;
89060   bool arg4 ;
89061   Dali::Toolkit::PageTurnView *argp2 ;
89062
89063   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89064   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89065   if (!argp2) {
89066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89067     return ;
89068   }
89069   arg2 = *argp2;
89070   arg3 = (unsigned int)jarg3;
89071   arg4 = jarg4 ? true : false;
89072   {
89073     try {
89074       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89075     } catch (std::out_of_range& e) {
89076       {
89077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89078       };
89079     } catch (std::exception& e) {
89080       {
89081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89082       };
89083     } catch (...) {
89084       {
89085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89086       };
89087     }
89088   }
89089 }
89090
89091
89092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
89093   void * jresult ;
89094   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
89095
89096   {
89097     try {
89098       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
89099     } catch (std::out_of_range& e) {
89100       {
89101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89102       };
89103     } catch (std::exception& e) {
89104       {
89105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89106       };
89107     } catch (...) {
89108       {
89109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89110       };
89111     }
89112   }
89113   jresult = (void *)result;
89114   return jresult;
89115 }
89116
89117
89118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
89119   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89120
89121   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89122   {
89123     try {
89124       delete arg1;
89125     } catch (std::out_of_range& e) {
89126       {
89127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89128       };
89129     } catch (std::exception& e) {
89130       {
89131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89132       };
89133     } catch (...) {
89134       {
89135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89136       };
89137     }
89138   }
89139 }
89140
89141
89142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
89143   unsigned int jresult ;
89144   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89145   bool result;
89146
89147   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89148   {
89149     try {
89150       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89151     } catch (std::out_of_range& e) {
89152       {
89153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89154       };
89155     } catch (std::exception& e) {
89156       {
89157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89158       };
89159     } catch (...) {
89160       {
89161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89162       };
89163     }
89164   }
89165   jresult = result;
89166   return jresult;
89167 }
89168
89169
89170 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
89171   unsigned long jresult ;
89172   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89173   std::size_t result;
89174
89175   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89176   {
89177     try {
89178       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89179     } catch (std::out_of_range& e) {
89180       {
89181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89182       };
89183     } catch (std::exception& e) {
89184       {
89185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89186       };
89187     } catch (...) {
89188       {
89189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89190       };
89191     }
89192   }
89193   jresult = (unsigned long)result;
89194   return jresult;
89195 }
89196
89197
89198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
89199   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89200   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89201
89202   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89203   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89204   {
89205     try {
89206       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
89207     } catch (std::out_of_range& e) {
89208       {
89209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89210       };
89211     } catch (std::exception& e) {
89212       {
89213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89214       };
89215     } catch (...) {
89216       {
89217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89218       };
89219     }
89220   }
89221 }
89222
89223
89224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
89225   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89226   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89227
89228   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89229   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89230   {
89231     try {
89232       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
89233     } catch (std::out_of_range& e) {
89234       {
89235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89236       };
89237     } catch (std::exception& e) {
89238       {
89239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89240       };
89241     } catch (...) {
89242       {
89243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89244       };
89245     }
89246   }
89247 }
89248
89249
89250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
89251   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89252   Dali::Toolkit::PageTurnView arg2 ;
89253   Dali::Toolkit::PageTurnView *argp2 ;
89254
89255   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89256   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89257   if (!argp2) {
89258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89259     return ;
89260   }
89261   arg2 = *argp2;
89262   {
89263     try {
89264       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
89265     } catch (std::out_of_range& e) {
89266       {
89267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89268       };
89269     } catch (std::exception& e) {
89270       {
89271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89272       };
89273     } catch (...) {
89274       {
89275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89276       };
89277     }
89278   }
89279 }
89280
89281
89282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
89283   void * jresult ;
89284   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
89285
89286   {
89287     try {
89288       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
89289     } catch (std::out_of_range& e) {
89290       {
89291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89292       };
89293     } catch (std::exception& e) {
89294       {
89295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89296       };
89297     } catch (...) {
89298       {
89299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89300       };
89301     }
89302   }
89303   jresult = (void *)result;
89304   return jresult;
89305 }
89306
89307
89308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
89309   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89310
89311   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89312   {
89313     try {
89314       delete arg1;
89315     } catch (std::out_of_range& e) {
89316       {
89317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89318       };
89319     } catch (std::exception& e) {
89320       {
89321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89322       };
89323     } catch (...) {
89324       {
89325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89326       };
89327     }
89328   }
89329 }
89330
89331
89332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
89333   unsigned int jresult ;
89334   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89335   bool result;
89336
89337   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89338   {
89339     try {
89340       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *)arg1);
89341     } catch (std::out_of_range& e) {
89342       {
89343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89344       };
89345     } catch (std::exception& e) {
89346       {
89347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89348       };
89349     } catch (...) {
89350       {
89351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89352       };
89353     }
89354   }
89355   jresult = result;
89356   return jresult;
89357 }
89358
89359
89360 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
89361   unsigned long jresult ;
89362   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89363   std::size_t result;
89364
89365   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89366   {
89367     try {
89368       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *)arg1);
89369     } catch (std::out_of_range& e) {
89370       {
89371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89372       };
89373     } catch (std::exception& e) {
89374       {
89375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89376       };
89377     } catch (...) {
89378       {
89379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89380       };
89381     }
89382   }
89383   jresult = (unsigned long)result;
89384   return jresult;
89385 }
89386
89387
89388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
89389   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89390   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
89391
89392   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89393   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
89394   {
89395     try {
89396       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
89397     } catch (std::out_of_range& e) {
89398       {
89399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89400       };
89401     } catch (std::exception& e) {
89402       {
89403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89404       };
89405     } catch (...) {
89406       {
89407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89408       };
89409     }
89410   }
89411 }
89412
89413
89414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89415   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89416   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
89417
89418   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89419   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
89420   {
89421     try {
89422       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
89423     } catch (std::out_of_range& e) {
89424       {
89425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89426       };
89427     } catch (std::exception& e) {
89428       {
89429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89430       };
89431     } catch (...) {
89432       {
89433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89434       };
89435     }
89436   }
89437 }
89438
89439
89440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
89441   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89442   Dali::Toolkit::ProgressBar arg2 ;
89443   float arg3 ;
89444   float arg4 ;
89445   Dali::Toolkit::ProgressBar *argp2 ;
89446
89447   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89448   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
89449   if (!argp2) {
89450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
89451     return ;
89452   }
89453   arg2 = *argp2;
89454   arg3 = (float)jarg3;
89455   arg4 = (float)jarg4;
89456   {
89457     try {
89458       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89459     } catch (std::out_of_range& e) {
89460       {
89461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89462       };
89463     } catch (std::exception& e) {
89464       {
89465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89466       };
89467     } catch (...) {
89468       {
89469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89470       };
89471     }
89472   }
89473 }
89474
89475
89476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
89477   void * jresult ;
89478   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
89479
89480   {
89481     try {
89482       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
89483     } catch (std::out_of_range& e) {
89484       {
89485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89486       };
89487     } catch (std::exception& e) {
89488       {
89489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89490       };
89491     } catch (...) {
89492       {
89493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89494       };
89495     }
89496   }
89497   jresult = (void *)result;
89498   return jresult;
89499 }
89500
89501
89502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
89503   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89504
89505   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89506   {
89507     try {
89508       delete arg1;
89509     } catch (std::out_of_range& e) {
89510       {
89511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89512       };
89513     } catch (std::exception& e) {
89514       {
89515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89516       };
89517     } catch (...) {
89518       {
89519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89520       };
89521     }
89522   }
89523 }
89524
89525
89526 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
89527   unsigned int jresult ;
89528   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89529   bool result;
89530
89531   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89532   {
89533     try {
89534       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);
89535     } catch (std::out_of_range& e) {
89536       {
89537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89538       };
89539     } catch (std::exception& e) {
89540       {
89541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89542       };
89543     } catch (...) {
89544       {
89545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89546       };
89547     }
89548   }
89549   jresult = result;
89550   return jresult;
89551 }
89552
89553
89554 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
89555   unsigned long jresult ;
89556   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89557   std::size_t result;
89558
89559   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89560   {
89561     try {
89562       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);
89563     } catch (std::out_of_range& e) {
89564       {
89565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89566       };
89567     } catch (std::exception& e) {
89568       {
89569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89570       };
89571     } catch (...) {
89572       {
89573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89574       };
89575     }
89576   }
89577   jresult = (unsigned long)result;
89578   return jresult;
89579 }
89580
89581
89582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
89583   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89584   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
89585
89586   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89587   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
89588   {
89589     try {
89590       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
89591     } catch (std::out_of_range& e) {
89592       {
89593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89594       };
89595     } catch (std::exception& e) {
89596       {
89597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89598       };
89599     } catch (...) {
89600       {
89601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89602       };
89603     }
89604   }
89605 }
89606
89607
89608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
89609   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89610   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
89611
89612   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89613   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
89614   {
89615     try {
89616       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
89617     } catch (std::out_of_range& e) {
89618       {
89619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89620       };
89621     } catch (std::exception& e) {
89622       {
89623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89624       };
89625     } catch (...) {
89626       {
89627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89628       };
89629     }
89630   }
89631 }
89632
89633
89634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
89635   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89636   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
89637
89638   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89639   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
89640   if (!arg2) {
89641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
89642     return ;
89643   }
89644   {
89645     try {
89646       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
89647     } catch (std::out_of_range& e) {
89648       {
89649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89650       };
89651     } catch (std::exception& e) {
89652       {
89653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89654       };
89655     } catch (...) {
89656       {
89657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89658       };
89659     }
89660   }
89661 }
89662
89663
89664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
89665   void * jresult ;
89666   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
89667
89668   {
89669     try {
89670       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
89671     } catch (std::out_of_range& e) {
89672       {
89673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89674       };
89675     } catch (std::exception& e) {
89676       {
89677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89678       };
89679     } catch (...) {
89680       {
89681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89682       };
89683     }
89684   }
89685   jresult = (void *)result;
89686   return jresult;
89687 }
89688
89689
89690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
89691   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89692
89693   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89694   {
89695     try {
89696       delete arg1;
89697     } catch (std::out_of_range& e) {
89698       {
89699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89700       };
89701     } catch (std::exception& e) {
89702       {
89703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89704       };
89705     } catch (...) {
89706       {
89707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89708       };
89709     }
89710   }
89711 }
89712
89713
89714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
89715   unsigned int jresult ;
89716   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
89717   bool result;
89718
89719   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
89720   {
89721     try {
89722       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
89723     } catch (std::out_of_range& e) {
89724       {
89725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89726       };
89727     } catch (std::exception& e) {
89728       {
89729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89730       };
89731     } catch (...) {
89732       {
89733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89734       };
89735     }
89736   }
89737   jresult = result;
89738   return jresult;
89739 }
89740
89741
89742 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
89743   unsigned long jresult ;
89744   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
89745   std::size_t result;
89746
89747   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
89748   {
89749     try {
89750       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
89751     } catch (std::out_of_range& e) {
89752       {
89753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89754       };
89755     } catch (std::exception& e) {
89756       {
89757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89758       };
89759     } catch (...) {
89760       {
89761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89762       };
89763     }
89764   }
89765   jresult = (unsigned long)result;
89766   return jresult;
89767 }
89768
89769
89770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
89771   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
89772   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
89773
89774   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
89775   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
89776   {
89777     try {
89778       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
89779     } catch (std::out_of_range& e) {
89780       {
89781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89782       };
89783     } catch (std::exception& e) {
89784       {
89785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89786       };
89787     } catch (...) {
89788       {
89789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89790       };
89791     }
89792   }
89793 }
89794
89795
89796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
89797   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
89798   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
89799
89800   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
89801   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
89802   {
89803     try {
89804       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
89805     } catch (std::out_of_range& e) {
89806       {
89807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89808       };
89809     } catch (std::exception& e) {
89810       {
89811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89812       };
89813     } catch (...) {
89814       {
89815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89816       };
89817     }
89818   }
89819 }
89820
89821
89822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
89823   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
89824   Dali::Vector2 *arg2 = 0 ;
89825
89826   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
89827   arg2 = (Dali::Vector2 *)jarg2;
89828   if (!arg2) {
89829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89830     return ;
89831   }
89832   {
89833     try {
89834       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
89835     } catch (std::out_of_range& e) {
89836       {
89837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89838       };
89839     } catch (std::exception& e) {
89840       {
89841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89842       };
89843     } catch (...) {
89844       {
89845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89846       };
89847     }
89848   }
89849 }
89850
89851
89852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
89853   void * jresult ;
89854   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
89855
89856   {
89857     try {
89858       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
89859     } catch (std::out_of_range& e) {
89860       {
89861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89862       };
89863     } catch (std::exception& e) {
89864       {
89865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89866       };
89867     } catch (...) {
89868       {
89869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89870       };
89871     }
89872   }
89873   jresult = (void *)result;
89874   return jresult;
89875 }
89876
89877
89878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
89879   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
89880
89881   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
89882   {
89883     try {
89884       delete arg1;
89885     } catch (std::out_of_range& e) {
89886       {
89887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89888       };
89889     } catch (std::exception& e) {
89890       {
89891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89892       };
89893     } catch (...) {
89894       {
89895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89896       };
89897     }
89898   }
89899 }
89900
89901
89902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
89903   unsigned int jresult ;
89904   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
89905   bool result;
89906
89907   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
89908   {
89909     try {
89910       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
89911     } catch (std::out_of_range& e) {
89912       {
89913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89914       };
89915     } catch (std::exception& e) {
89916       {
89917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89918       };
89919     } catch (...) {
89920       {
89921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89922       };
89923     }
89924   }
89925   jresult = result;
89926   return jresult;
89927 }
89928
89929
89930 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
89931   unsigned long jresult ;
89932   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
89933   std::size_t result;
89934
89935   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
89936   {
89937     try {
89938       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
89939     } catch (std::out_of_range& e) {
89940       {
89941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89942       };
89943     } catch (std::exception& e) {
89944       {
89945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89946       };
89947     } catch (...) {
89948       {
89949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89950       };
89951     }
89952   }
89953   jresult = (unsigned long)result;
89954   return jresult;
89955 }
89956
89957
89958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
89959   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
89960   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
89961
89962   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
89963   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
89964   {
89965     try {
89966       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
89967     } catch (std::out_of_range& e) {
89968       {
89969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89970       };
89971     } catch (std::exception& e) {
89972       {
89973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89974       };
89975     } catch (...) {
89976       {
89977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89978       };
89979     }
89980   }
89981 }
89982
89983
89984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
89985   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
89986   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
89987
89988   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
89989   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
89990   {
89991     try {
89992       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
89993     } catch (std::out_of_range& e) {
89994       {
89995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89996       };
89997     } catch (std::exception& e) {
89998       {
89999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90000       };
90001     } catch (...) {
90002       {
90003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90004       };
90005     }
90006   }
90007 }
90008
90009
90010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
90011   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90012   Dali::Toolkit::TextEditor arg2 ;
90013   Dali::Toolkit::TextEditor *argp2 ;
90014
90015   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90016   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
90017   if (!argp2) {
90018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
90019     return ;
90020   }
90021   arg2 = *argp2;
90022   {
90023     try {
90024       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
90025     } catch (std::out_of_range& e) {
90026       {
90027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90028       };
90029     } catch (std::exception& e) {
90030       {
90031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90032       };
90033     } catch (...) {
90034       {
90035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90036       };
90037     }
90038   }
90039 }
90040
90041
90042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
90043   void * jresult ;
90044   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
90045
90046   {
90047     try {
90048       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
90049     } catch (std::out_of_range& e) {
90050       {
90051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90052       };
90053     } catch (std::exception& e) {
90054       {
90055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90056       };
90057     } catch (...) {
90058       {
90059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90060       };
90061     }
90062   }
90063   jresult = (void *)result;
90064   return jresult;
90065 }
90066
90067
90068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
90069   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90070
90071   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90072   {
90073     try {
90074       delete arg1;
90075     } catch (std::out_of_range& e) {
90076       {
90077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90078       };
90079     } catch (std::exception& e) {
90080       {
90081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90082       };
90083     } catch (...) {
90084       {
90085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90086       };
90087     }
90088   }
90089 }
90090
90091
90092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
90093   unsigned int jresult ;
90094   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90095   bool result;
90096
90097   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90098   {
90099     try {
90100       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90101     } catch (std::out_of_range& e) {
90102       {
90103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90104       };
90105     } catch (std::exception& e) {
90106       {
90107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90108       };
90109     } catch (...) {
90110       {
90111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90112       };
90113     }
90114   }
90115   jresult = result;
90116   return jresult;
90117 }
90118
90119
90120 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
90121   unsigned long jresult ;
90122   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90123   std::size_t result;
90124
90125   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90126   {
90127     try {
90128       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90129     } catch (std::out_of_range& e) {
90130       {
90131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90132       };
90133     } catch (std::exception& e) {
90134       {
90135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90136       };
90137     } catch (...) {
90138       {
90139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90140       };
90141     }
90142   }
90143   jresult = (unsigned long)result;
90144   return jresult;
90145 }
90146
90147
90148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
90149   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90150   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90151
90152   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90153   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90154   {
90155     try {
90156       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
90157     } catch (std::out_of_range& e) {
90158       {
90159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90160       };
90161     } catch (std::exception& e) {
90162       {
90163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90164       };
90165     } catch (...) {
90166       {
90167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90168       };
90169     }
90170   }
90171 }
90172
90173
90174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
90175   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90176   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90177
90178   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90179   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90180   {
90181     try {
90182       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
90183     } catch (std::out_of_range& e) {
90184       {
90185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90186       };
90187     } catch (std::exception& e) {
90188       {
90189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90190       };
90191     } catch (...) {
90192       {
90193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90194       };
90195     }
90196   }
90197 }
90198
90199
90200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
90201   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90202   Dali::Toolkit::TextField arg2 ;
90203   Dali::Toolkit::TextField *argp2 ;
90204
90205   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90206   argp2 = (Dali::Toolkit::TextField *)jarg2;
90207   if (!argp2) {
90208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
90209     return ;
90210   }
90211   arg2 = *argp2;
90212   {
90213     try {
90214       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
90215     } catch (std::out_of_range& e) {
90216       {
90217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90218       };
90219     } catch (std::exception& e) {
90220       {
90221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90222       };
90223     } catch (...) {
90224       {
90225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90226       };
90227     }
90228   }
90229 }
90230
90231
90232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
90233   void * jresult ;
90234   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
90235
90236   {
90237     try {
90238       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
90239     } catch (std::out_of_range& e) {
90240       {
90241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90242       };
90243     } catch (std::exception& e) {
90244       {
90245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90246       };
90247     } catch (...) {
90248       {
90249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90250       };
90251     }
90252   }
90253   jresult = (void *)result;
90254   return jresult;
90255 }
90256
90257
90258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
90259   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90260
90261   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90262   {
90263     try {
90264       delete arg1;
90265     } catch (std::out_of_range& e) {
90266       {
90267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90268       };
90269     } catch (std::exception& e) {
90270       {
90271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90272       };
90273     } catch (...) {
90274       {
90275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90276       };
90277     }
90278   }
90279 }
90280
90281
90282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
90283   unsigned int jresult ;
90284   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90285   bool result;
90286
90287   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90288   {
90289     try {
90290       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);
90291     } catch (std::out_of_range& e) {
90292       {
90293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90294       };
90295     } catch (std::exception& e) {
90296       {
90297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90298       };
90299     } catch (...) {
90300       {
90301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90302       };
90303     }
90304   }
90305   jresult = result;
90306   return jresult;
90307 }
90308
90309
90310 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
90311   unsigned long jresult ;
90312   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90313   std::size_t result;
90314
90315   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90316   {
90317     try {
90318       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);
90319     } catch (std::out_of_range& e) {
90320       {
90321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90322       };
90323     } catch (std::exception& e) {
90324       {
90325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90326       };
90327     } catch (...) {
90328       {
90329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90330       };
90331     }
90332   }
90333   jresult = (unsigned long)result;
90334   return jresult;
90335 }
90336
90337
90338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
90339   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90340   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90341
90342   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90343   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90344   {
90345     try {
90346       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90347     } catch (std::out_of_range& e) {
90348       {
90349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90350       };
90351     } catch (std::exception& e) {
90352       {
90353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90354       };
90355     } catch (...) {
90356       {
90357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90358       };
90359     }
90360   }
90361 }
90362
90363
90364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
90365   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90366   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90367
90368   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90369   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90370   {
90371     try {
90372       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90373     } catch (std::out_of_range& e) {
90374       {
90375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90376       };
90377     } catch (std::exception& e) {
90378       {
90379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90380       };
90381     } catch (...) {
90382       {
90383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90384       };
90385     }
90386   }
90387 }
90388
90389
90390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90391   unsigned int jresult ;
90392   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90393   Dali::Toolkit::Control arg2 ;
90394   Dali::KeyEvent *arg3 = 0 ;
90395   Dali::Toolkit::Control *argp2 ;
90396   bool result;
90397
90398   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90399   argp2 = (Dali::Toolkit::Control *)jarg2;
90400   if (!argp2) {
90401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
90402     return 0;
90403   }
90404   arg2 = *argp2;
90405   arg3 = (Dali::KeyEvent *)jarg3;
90406   if (!arg3) {
90407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
90408     return 0;
90409   }
90410   {
90411     try {
90412       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);
90413     } catch (std::out_of_range& e) {
90414       {
90415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90416       };
90417     } catch (std::exception& e) {
90418       {
90419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90420       };
90421     } catch (...) {
90422       {
90423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90424       };
90425     }
90426   }
90427   jresult = result;
90428   return jresult;
90429 }
90430
90431
90432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
90433   void * jresult ;
90434   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
90435
90436   {
90437     try {
90438       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
90439     } catch (std::out_of_range& e) {
90440       {
90441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90442       };
90443     } catch (std::exception& e) {
90444       {
90445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90446       };
90447     } catch (...) {
90448       {
90449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90450       };
90451     }
90452   }
90453   jresult = (void *)result;
90454   return jresult;
90455 }
90456
90457
90458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
90459   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90460
90461   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90462   {
90463     try {
90464       delete arg1;
90465     } catch (std::out_of_range& e) {
90466       {
90467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90468       };
90469     } catch (std::exception& e) {
90470       {
90471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90472       };
90473     } catch (...) {
90474       {
90475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90476       };
90477     }
90478   }
90479 }
90480
90481
90482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
90483   unsigned int jresult ;
90484   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90485   bool result;
90486
90487   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90488   {
90489     try {
90490       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
90491     } catch (std::out_of_range& e) {
90492       {
90493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90494       };
90495     } catch (std::exception& e) {
90496       {
90497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90498       };
90499     } catch (...) {
90500       {
90501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90502       };
90503     }
90504   }
90505   jresult = result;
90506   return jresult;
90507 }
90508
90509
90510 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
90511   unsigned long jresult ;
90512   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90513   std::size_t result;
90514
90515   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90516   {
90517     try {
90518       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
90519     } catch (std::out_of_range& e) {
90520       {
90521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90522       };
90523     } catch (std::exception& e) {
90524       {
90525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90526       };
90527     } catch (...) {
90528       {
90529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90530       };
90531     }
90532   }
90533   jresult = (unsigned long)result;
90534   return jresult;
90535 }
90536
90537
90538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
90539   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90540   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
90541
90542   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90543   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
90544   {
90545     try {
90546       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
90547     } catch (std::out_of_range& e) {
90548       {
90549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90550       };
90551     } catch (std::exception& e) {
90552       {
90553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90554       };
90555     } catch (...) {
90556       {
90557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90558       };
90559     }
90560   }
90561 }
90562
90563
90564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
90565   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90566   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
90567
90568   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90569   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
90570   {
90571     try {
90572       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
90573     } catch (std::out_of_range& e) {
90574       {
90575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90576       };
90577     } catch (std::exception& e) {
90578       {
90579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90580       };
90581     } catch (...) {
90582       {
90583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90584       };
90585     }
90586   }
90587 }
90588
90589
90590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
90591   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90592   Dali::Toolkit::Control arg2 ;
90593   Dali::Toolkit::Control *argp2 ;
90594
90595   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90596   argp2 = (Dali::Toolkit::Control *)jarg2;
90597   if (!argp2) {
90598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
90599     return ;
90600   }
90601   arg2 = *argp2;
90602   {
90603     try {
90604       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
90605     } catch (std::out_of_range& e) {
90606       {
90607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90608       };
90609     } catch (std::exception& e) {
90610       {
90611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90612       };
90613     } catch (...) {
90614       {
90615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90616       };
90617     }
90618   }
90619 }
90620
90621
90622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
90623   void * jresult ;
90624   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
90625
90626   {
90627     try {
90628       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
90629     } catch (std::out_of_range& e) {
90630       {
90631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90632       };
90633     } catch (std::exception& e) {
90634       {
90635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90636       };
90637     } catch (...) {
90638       {
90639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90640       };
90641     }
90642   }
90643   jresult = (void *)result;
90644   return jresult;
90645 }
90646
90647
90648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
90649   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90650
90651   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90652   {
90653     try {
90654       delete arg1;
90655     } catch (std::out_of_range& e) {
90656       {
90657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90658       };
90659     } catch (std::exception& e) {
90660       {
90661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90662       };
90663     } catch (...) {
90664       {
90665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90666       };
90667     }
90668   }
90669 }
90670
90671
90672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
90673   unsigned int jresult ;
90674   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
90675   bool result;
90676
90677   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
90678   {
90679     try {
90680       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
90681     } catch (std::out_of_range& e) {
90682       {
90683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90684       };
90685     } catch (std::exception& e) {
90686       {
90687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90688       };
90689     } catch (...) {
90690       {
90691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90692       };
90693     }
90694   }
90695   jresult = result;
90696   return jresult;
90697 }
90698
90699
90700 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
90701   unsigned long jresult ;
90702   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
90703   std::size_t result;
90704
90705   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
90706   {
90707     try {
90708       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
90709     } catch (std::out_of_range& e) {
90710       {
90711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90712       };
90713     } catch (std::exception& e) {
90714       {
90715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90716       };
90717     } catch (...) {
90718       {
90719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90720       };
90721     }
90722   }
90723   jresult = (unsigned long)result;
90724   return jresult;
90725 }
90726
90727
90728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
90729   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
90730   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
90731
90732   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
90733   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
90734   {
90735     try {
90736       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
90737     } catch (std::out_of_range& e) {
90738       {
90739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90740       };
90741     } catch (std::exception& e) {
90742       {
90743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90744       };
90745     } catch (...) {
90746       {
90747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90748       };
90749     }
90750   }
90751 }
90752
90753
90754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
90755   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
90756   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
90757
90758   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
90759   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
90760   {
90761     try {
90762       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
90763     } catch (std::out_of_range& e) {
90764       {
90765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90766       };
90767     } catch (std::exception& e) {
90768       {
90769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90770       };
90771     } catch (...) {
90772       {
90773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90774       };
90775     }
90776   }
90777 }
90778
90779
90780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
90781   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
90782   Dali::Toolkit::VideoView *arg2 = 0 ;
90783
90784   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
90785   arg2 = (Dali::Toolkit::VideoView *)jarg2;
90786   if (!arg2) {
90787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
90788     return ;
90789   }
90790   {
90791     try {
90792       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
90793     } catch (std::out_of_range& e) {
90794       {
90795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90796       };
90797     } catch (std::exception& e) {
90798       {
90799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90800       };
90801     } catch (...) {
90802       {
90803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90804       };
90805     }
90806   }
90807 }
90808
90809
90810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
90811   void * jresult ;
90812   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
90813
90814   {
90815     try {
90816       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
90817     } catch (std::out_of_range& e) {
90818       {
90819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90820       };
90821     } catch (std::exception& e) {
90822       {
90823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90824       };
90825     } catch (...) {
90826       {
90827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90828       };
90829     }
90830   }
90831   jresult = (void *)result;
90832   return jresult;
90833 }
90834
90835
90836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
90837   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
90838
90839   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
90840   {
90841     try {
90842       delete arg1;
90843     } catch (std::out_of_range& e) {
90844       {
90845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90846       };
90847     } catch (std::exception& e) {
90848       {
90849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90850       };
90851     } catch (...) {
90852       {
90853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90854       };
90855     }
90856   }
90857 }
90858
90859
90860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
90861   unsigned int jresult ;
90862   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
90863   bool result;
90864
90865   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
90866   {
90867     try {
90868       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
90869     } catch (std::out_of_range& e) {
90870       {
90871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90872       };
90873     } catch (std::exception& e) {
90874       {
90875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90876       };
90877     } catch (...) {
90878       {
90879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90880       };
90881     }
90882   }
90883   jresult = result;
90884   return jresult;
90885 }
90886
90887
90888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
90889   unsigned long jresult ;
90890   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
90891   std::size_t result;
90892
90893   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
90894   {
90895     try {
90896       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
90897     } catch (std::out_of_range& e) {
90898       {
90899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90900       };
90901     } catch (std::exception& e) {
90902       {
90903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90904       };
90905     } catch (...) {
90906       {
90907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90908       };
90909     }
90910   }
90911   jresult = (unsigned long)result;
90912   return jresult;
90913 }
90914
90915
90916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
90917   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
90918   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
90919
90920   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
90921   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
90922   {
90923     try {
90924       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
90925     } catch (std::out_of_range& e) {
90926       {
90927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90928       };
90929     } catch (std::exception& e) {
90930       {
90931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90932       };
90933     } catch (...) {
90934       {
90935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90936       };
90937     }
90938   }
90939 }
90940
90941
90942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90943   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
90944   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
90945
90946   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
90947   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
90948   {
90949     try {
90950       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
90951     } catch (std::out_of_range& e) {
90952       {
90953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90954       };
90955     } catch (std::exception& e) {
90956       {
90957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90958       };
90959     } catch (...) {
90960       {
90961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90962       };
90963     }
90964   }
90965 }
90966
90967
90968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
90969   unsigned int jresult ;
90970   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
90971   Dali::Toolkit::Slider arg2 ;
90972   float arg3 ;
90973   Dali::Toolkit::Slider *argp2 ;
90974   bool result;
90975
90976   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
90977   argp2 = (Dali::Toolkit::Slider *)jarg2;
90978   if (!argp2) {
90979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
90980     return 0;
90981   }
90982   arg2 = *argp2;
90983   arg3 = (float)jarg3;
90984   {
90985     try {
90986       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
90987     } catch (std::out_of_range& e) {
90988       {
90989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90990       };
90991     } catch (std::exception& e) {
90992       {
90993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90994       };
90995     } catch (...) {
90996       {
90997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90998       };
90999     }
91000   }
91001   jresult = result;
91002   return jresult;
91003 }
91004
91005
91006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
91007   void * jresult ;
91008   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
91009
91010   {
91011     try {
91012       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
91013     } catch (std::out_of_range& e) {
91014       {
91015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91016       };
91017     } catch (std::exception& e) {
91018       {
91019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91020       };
91021     } catch (...) {
91022       {
91023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91024       };
91025     }
91026   }
91027   jresult = (void *)result;
91028   return jresult;
91029 }
91030
91031
91032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
91033   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91034
91035   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91036   {
91037     try {
91038       delete arg1;
91039     } catch (std::out_of_range& e) {
91040       {
91041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91042       };
91043     } catch (std::exception& e) {
91044       {
91045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91046       };
91047     } catch (...) {
91048       {
91049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91050       };
91051     }
91052   }
91053 }
91054
91055
91056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
91057   unsigned int jresult ;
91058   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91059   bool result;
91060
91061   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91062   {
91063     try {
91064       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91065     } catch (std::out_of_range& e) {
91066       {
91067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91068       };
91069     } catch (std::exception& e) {
91070       {
91071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91072       };
91073     } catch (...) {
91074       {
91075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91076       };
91077     }
91078   }
91079   jresult = result;
91080   return jresult;
91081 }
91082
91083
91084 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
91085   unsigned long jresult ;
91086   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91087   std::size_t result;
91088
91089   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91090   {
91091     try {
91092       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91093     } catch (std::out_of_range& e) {
91094       {
91095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91096       };
91097     } catch (std::exception& e) {
91098       {
91099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91100       };
91101     } catch (...) {
91102       {
91103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91104       };
91105     }
91106   }
91107   jresult = (unsigned long)result;
91108   return jresult;
91109 }
91110
91111
91112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
91113   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91114   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91115
91116   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91117   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91118   {
91119     try {
91120       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
91121     } catch (std::out_of_range& e) {
91122       {
91123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91124       };
91125     } catch (std::exception& e) {
91126       {
91127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91128       };
91129     } catch (...) {
91130       {
91131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91132       };
91133     }
91134   }
91135 }
91136
91137
91138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
91139   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91140   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91141
91142   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91143   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91144   {
91145     try {
91146       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
91147     } catch (std::out_of_range& e) {
91148       {
91149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91150       };
91151     } catch (std::exception& e) {
91152       {
91153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91154       };
91155     } catch (...) {
91156       {
91157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91158       };
91159     }
91160   }
91161 }
91162
91163
91164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91165   unsigned int jresult ;
91166   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91167   Dali::Toolkit::Slider arg2 ;
91168   int arg3 ;
91169   Dali::Toolkit::Slider *argp2 ;
91170   bool result;
91171
91172   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91173   argp2 = (Dali::Toolkit::Slider *)jarg2;
91174   if (!argp2) {
91175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91176     return 0;
91177   }
91178   arg2 = *argp2;
91179   arg3 = (int)jarg3;
91180   {
91181     try {
91182       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
91183     } catch (std::out_of_range& e) {
91184       {
91185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91186       };
91187     } catch (std::exception& e) {
91188       {
91189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91190       };
91191     } catch (...) {
91192       {
91193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91194       };
91195     }
91196   }
91197   jresult = result;
91198   return jresult;
91199 }
91200
91201
91202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
91203   void * jresult ;
91204   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
91205
91206   {
91207     try {
91208       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
91209     } catch (std::out_of_range& e) {
91210       {
91211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91212       };
91213     } catch (std::exception& e) {
91214       {
91215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91216       };
91217     } catch (...) {
91218       {
91219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91220       };
91221     }
91222   }
91223   jresult = (void *)result;
91224   return jresult;
91225 }
91226
91227
91228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
91229   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91230
91231   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91232   {
91233     try {
91234       delete arg1;
91235     } catch (std::out_of_range& e) {
91236       {
91237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91238       };
91239     } catch (std::exception& e) {
91240       {
91241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91242       };
91243     } catch (...) {
91244       {
91245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91246       };
91247     }
91248   }
91249 }
91250
91251
91252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
91253   void * jresult ;
91254   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91255
91256   {
91257     try {
91258       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
91259     } catch (std::out_of_range& e) {
91260       {
91261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91262       };
91263     } catch (std::exception& e) {
91264       {
91265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91266       };
91267     } catch (...) {
91268       {
91269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91270       };
91271     }
91272   }
91273   jresult = (void *)result;
91274   return jresult;
91275 }
91276
91277
91278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
91279   void * jresult ;
91280   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
91281   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91282
91283   arg1 = (Dali::Toolkit::Ruler *)jarg1;
91284   {
91285     try {
91286       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
91287     } catch (std::out_of_range& e) {
91288       {
91289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91290       };
91291     } catch (std::exception& e) {
91292       {
91293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91294       };
91295     } catch (...) {
91296       {
91297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91298       };
91299     }
91300   }
91301   jresult = (void *)result;
91302   return jresult;
91303 }
91304
91305
91306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
91307   void * jresult ;
91308   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
91309   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91310
91311   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91312   if (!arg1) {
91313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91314     return 0;
91315   }
91316   {
91317     try {
91318       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
91319     } catch (std::out_of_range& e) {
91320       {
91321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91322       };
91323     } catch (std::exception& e) {
91324       {
91325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91326       };
91327     } catch (...) {
91328       {
91329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91330       };
91331     }
91332   }
91333   jresult = (void *)result;
91334   return jresult;
91335 }
91336
91337
91338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
91339   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91340
91341   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91342   {
91343     try {
91344       delete arg1;
91345     } catch (std::out_of_range& e) {
91346       {
91347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91348       };
91349     } catch (std::exception& e) {
91350       {
91351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91352       };
91353     } catch (...) {
91354       {
91355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91356       };
91357     }
91358   }
91359 }
91360
91361
91362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
91363   void * jresult ;
91364   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91365   Dali::Toolkit::Ruler *result = 0 ;
91366
91367   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91368   {
91369     try {
91370       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
91371     } catch (std::out_of_range& e) {
91372       {
91373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91374       };
91375     } catch (std::exception& e) {
91376       {
91377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91378       };
91379     } catch (...) {
91380       {
91381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91382       };
91383     }
91384   }
91385   jresult = (void *)result;
91386   return jresult;
91387 }
91388
91389
91390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
91391   void * jresult ;
91392   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91393   Dali::Toolkit::Ruler *result = 0 ;
91394
91395   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91396   {
91397     try {
91398       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
91399     } catch (std::out_of_range& e) {
91400       {
91401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91402       };
91403     } catch (std::exception& e) {
91404       {
91405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91406       };
91407     } catch (...) {
91408       {
91409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91410       };
91411     }
91412   }
91413   jresult = (void *)result;
91414   return jresult;
91415 }
91416
91417
91418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
91419   void * jresult ;
91420   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91421   Dali::Toolkit::Ruler *result = 0 ;
91422
91423   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91424   {
91425     try {
91426       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
91427     } catch (std::out_of_range& e) {
91428       {
91429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91430       };
91431     } catch (std::exception& e) {
91432       {
91433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91434       };
91435     } catch (...) {
91436       {
91437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91438       };
91439     }
91440   }
91441   jresult = (void *)result;
91442   return jresult;
91443 }
91444
91445
91446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
91447   void * jresult ;
91448   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91449   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
91450   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91451
91452   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91453   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
91454   if (!arg2) {
91455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91456     return 0;
91457   }
91458   {
91459     try {
91460       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
91461     } catch (std::out_of_range& e) {
91462       {
91463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91464       };
91465     } catch (std::exception& e) {
91466       {
91467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91468       };
91469     } catch (...) {
91470       {
91471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91472       };
91473     }
91474   }
91475   jresult = (void *)result;
91476   return jresult;
91477 }
91478
91479
91480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
91481   void * jresult ;
91482   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91483   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
91484   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91485
91486   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91487   arg2 = (Dali::Toolkit::Ruler *)jarg2;
91488   {
91489     try {
91490       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
91491     } catch (std::out_of_range& e) {
91492       {
91493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91494       };
91495     } catch (std::exception& e) {
91496       {
91497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91498       };
91499     } catch (...) {
91500       {
91501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91502       };
91503     }
91504   }
91505   jresult = (void *)result;
91506   return jresult;
91507 }
91508
91509
91510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
91511   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91512
91513   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91514   {
91515     try {
91516       (arg1)->Reset();
91517     } catch (std::out_of_range& e) {
91518       {
91519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91520       };
91521     } catch (std::exception& e) {
91522       {
91523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91524       };
91525     } catch (...) {
91526       {
91527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91528       };
91529     }
91530   }
91531 }
91532
91533
91534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
91535   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91536   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
91537
91538   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91539   arg2 = (Dali::Toolkit::Ruler *)jarg2;
91540   {
91541     try {
91542       (arg1)->Reset(arg2);
91543     } catch (std::out_of_range& e) {
91544       {
91545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91546       };
91547     } catch (std::exception& e) {
91548       {
91549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91550       };
91551     } catch (...) {
91552       {
91553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91554       };
91555     }
91556   }
91557 }
91558
91559
91560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
91561   void * jresult ;
91562   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91563   Dali::Toolkit::Ruler *result = 0 ;
91564
91565   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91566   {
91567     try {
91568       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
91569     } catch (std::out_of_range& e) {
91570       {
91571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91572       };
91573     } catch (std::exception& e) {
91574       {
91575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91576       };
91577     } catch (...) {
91578       {
91579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91580       };
91581     }
91582   }
91583   jresult = (void *)result;
91584   return jresult;
91585 }
91586
91587
91588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
91589   float jresult ;
91590   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91591   float arg2 ;
91592   float arg3 ;
91593   float result;
91594
91595   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91596   arg2 = (float)jarg2;
91597   arg3 = (float)jarg3;
91598   {
91599     try {
91600       result = (float)(*arg1)->Snap(arg2,arg3);
91601     } catch (std::out_of_range& e) {
91602       {
91603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91604       };
91605     } catch (std::exception& e) {
91606       {
91607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91608       };
91609     } catch (...) {
91610       {
91611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91612       };
91613     }
91614   }
91615   jresult = result;
91616   return jresult;
91617 }
91618
91619
91620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
91621   float jresult ;
91622   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91623   float arg2 ;
91624   float result;
91625
91626   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91627   arg2 = (float)jarg2;
91628   {
91629     try {
91630       result = (float)(*arg1)->Snap(arg2);
91631     } catch (std::out_of_range& e) {
91632       {
91633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91634       };
91635     } catch (std::exception& e) {
91636       {
91637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91638       };
91639     } catch (...) {
91640       {
91641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91642       };
91643     }
91644   }
91645   jresult = result;
91646   return jresult;
91647 }
91648
91649
91650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
91651   float jresult ;
91652   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91653   unsigned int arg2 ;
91654   unsigned int *arg3 = 0 ;
91655   bool arg4 ;
91656   float result;
91657
91658   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91659   arg2 = (unsigned int)jarg2;
91660   arg3 = (unsigned int *)jarg3;
91661   arg4 = jarg4 ? true : false;
91662   {
91663     try {
91664       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
91665     } catch (std::out_of_range& e) {
91666       {
91667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91668       };
91669     } catch (std::exception& e) {
91670       {
91671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91672       };
91673     } catch (...) {
91674       {
91675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91676       };
91677     }
91678   }
91679   jresult = result;
91680   return jresult;
91681 }
91682
91683
91684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
91685   unsigned int jresult ;
91686   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91687   float arg2 ;
91688   bool arg3 ;
91689   unsigned int result;
91690
91691   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91692   arg2 = (float)jarg2;
91693   arg3 = jarg3 ? true : false;
91694   {
91695     try {
91696       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
91697     } catch (std::out_of_range& e) {
91698       {
91699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91700       };
91701     } catch (std::exception& e) {
91702       {
91703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91704       };
91705     } catch (...) {
91706       {
91707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91708       };
91709     }
91710   }
91711   jresult = result;
91712   return jresult;
91713 }
91714
91715
91716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
91717   unsigned int jresult ;
91718   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91719   unsigned int result;
91720
91721   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91722   {
91723     try {
91724       result = (unsigned int)(*arg1)->GetTotalPages();
91725     } catch (std::out_of_range& e) {
91726       {
91727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91728       };
91729     } catch (std::exception& e) {
91730       {
91731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91732       };
91733     } catch (...) {
91734       {
91735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91736       };
91737     }
91738   }
91739   jresult = result;
91740   return jresult;
91741 }
91742
91743
91744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
91745   int jresult ;
91746   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91747   Dali::Toolkit::Ruler::RulerType result;
91748
91749   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91750   {
91751     try {
91752       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
91753     } catch (std::out_of_range& e) {
91754       {
91755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91756       };
91757     } catch (std::exception& e) {
91758       {
91759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91760       };
91761     } catch (...) {
91762       {
91763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91764       };
91765     }
91766   }
91767   jresult = (int)result;
91768   return jresult;
91769 }
91770
91771
91772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
91773   unsigned int jresult ;
91774   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91775   bool result;
91776
91777   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91778   {
91779     try {
91780       result = (bool)(*arg1)->IsEnabled();
91781     } catch (std::out_of_range& e) {
91782       {
91783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91784       };
91785     } catch (std::exception& e) {
91786       {
91787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91788       };
91789     } catch (...) {
91790       {
91791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91792       };
91793     }
91794   }
91795   jresult = result;
91796   return jresult;
91797 }
91798
91799
91800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
91801   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91802
91803   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91804   {
91805     try {
91806       (*arg1)->Enable();
91807     } catch (std::out_of_range& e) {
91808       {
91809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91810       };
91811     } catch (std::exception& e) {
91812       {
91813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91814       };
91815     } catch (...) {
91816       {
91817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91818       };
91819     }
91820   }
91821 }
91822
91823
91824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
91825   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91826
91827   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91828   {
91829     try {
91830       (*arg1)->Disable();
91831     } catch (std::out_of_range& e) {
91832       {
91833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91834       };
91835     } catch (std::exception& e) {
91836       {
91837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91838       };
91839     } catch (...) {
91840       {
91841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91842       };
91843     }
91844   }
91845 }
91846
91847
91848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
91849   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91850   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
91851   Dali::Toolkit::RulerDomain *argp2 ;
91852
91853   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91854   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
91855   if (!argp2) {
91856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
91857     return ;
91858   }
91859   arg2 = *argp2;
91860   {
91861     try {
91862       (*arg1)->SetDomain(arg2);
91863     } catch (std::out_of_range& e) {
91864       {
91865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91866       };
91867     } catch (std::exception& e) {
91868       {
91869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91870       };
91871     } catch (...) {
91872       {
91873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91874       };
91875     }
91876   }
91877 }
91878
91879
91880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
91881   void * jresult ;
91882   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91883   Dali::Toolkit::RulerDomain *result = 0 ;
91884
91885   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91886   {
91887     try {
91888       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
91889     } catch (std::out_of_range& e) {
91890       {
91891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91892       };
91893     } catch (std::exception& e) {
91894       {
91895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91896       };
91897     } catch (...) {
91898       {
91899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91900       };
91901     }
91902   }
91903   jresult = (void *)result;
91904   return jresult;
91905 }
91906
91907
91908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
91909   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91910
91911   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91912   {
91913     try {
91914       (*arg1)->DisableDomain();
91915     } catch (std::out_of_range& e) {
91916       {
91917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91918       };
91919     } catch (std::exception& e) {
91920       {
91921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91922       };
91923     } catch (...) {
91924       {
91925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91926       };
91927     }
91928   }
91929 }
91930
91931
91932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
91933   float jresult ;
91934   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91935   float arg2 ;
91936   float arg3 ;
91937   float arg4 ;
91938   float result;
91939
91940   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91941   arg2 = (float)jarg2;
91942   arg3 = (float)jarg3;
91943   arg4 = (float)jarg4;
91944   {
91945     try {
91946       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
91947     } catch (std::out_of_range& e) {
91948       {
91949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91950       };
91951     } catch (std::exception& e) {
91952       {
91953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91954       };
91955     } catch (...) {
91956       {
91957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91958       };
91959     }
91960   }
91961   jresult = result;
91962   return jresult;
91963 }
91964
91965
91966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
91967   float jresult ;
91968   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91969   float arg2 ;
91970   float arg3 ;
91971   float result;
91972
91973   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91974   arg2 = (float)jarg2;
91975   arg3 = (float)jarg3;
91976   {
91977     try {
91978       result = (float)(*arg1)->Clamp(arg2,arg3);
91979     } catch (std::out_of_range& e) {
91980       {
91981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91982       };
91983     } catch (std::exception& e) {
91984       {
91985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91986       };
91987     } catch (...) {
91988       {
91989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91990       };
91991     }
91992   }
91993   jresult = result;
91994   return jresult;
91995 }
91996
91997
91998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
91999   float jresult ;
92000   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92001   float arg2 ;
92002   float result;
92003
92004   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92005   arg2 = (float)jarg2;
92006   {
92007     try {
92008       result = (float)(*arg1)->Clamp(arg2);
92009     } catch (std::out_of_range& e) {
92010       {
92011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92012       };
92013     } catch (std::exception& e) {
92014       {
92015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92016       };
92017     } catch (...) {
92018       {
92019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92020       };
92021     }
92022   }
92023   jresult = result;
92024   return jresult;
92025 }
92026
92027
92028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
92029   float jresult ;
92030   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92031   float arg2 ;
92032   float arg3 ;
92033   float arg4 ;
92034   Dali::Toolkit::ClampState *arg5 = 0 ;
92035   float result;
92036
92037   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92038   arg2 = (float)jarg2;
92039   arg3 = (float)jarg3;
92040   arg4 = (float)jarg4;
92041   arg5 = (Dali::Toolkit::ClampState *)jarg5;
92042   if (!arg5) {
92043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92044     return 0;
92045   }
92046   {
92047     try {
92048       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
92049     } catch (std::out_of_range& e) {
92050       {
92051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92052       };
92053     } catch (std::exception& e) {
92054       {
92055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92056       };
92057     } catch (...) {
92058       {
92059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92060       };
92061     }
92062   }
92063   jresult = result;
92064   return jresult;
92065 }
92066
92067
92068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
92069   float jresult ;
92070   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92071   float arg2 ;
92072   float arg3 ;
92073   float arg4 ;
92074   float arg5 ;
92075   float result;
92076
92077   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92078   arg2 = (float)jarg2;
92079   arg3 = (float)jarg3;
92080   arg4 = (float)jarg4;
92081   arg5 = (float)jarg5;
92082   {
92083     try {
92084       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
92085     } catch (std::out_of_range& e) {
92086       {
92087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92088       };
92089     } catch (std::exception& e) {
92090       {
92091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92092       };
92093     } catch (...) {
92094       {
92095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92096       };
92097     }
92098   }
92099   jresult = result;
92100   return jresult;
92101 }
92102
92103
92104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
92105   float jresult ;
92106   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92107   float arg2 ;
92108   float arg3 ;
92109   float arg4 ;
92110   float result;
92111
92112   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92113   arg2 = (float)jarg2;
92114   arg3 = (float)jarg3;
92115   arg4 = (float)jarg4;
92116   {
92117     try {
92118       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
92119     } catch (std::out_of_range& e) {
92120       {
92121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92122       };
92123     } catch (std::exception& e) {
92124       {
92125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92126       };
92127     } catch (...) {
92128       {
92129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92130       };
92131     }
92132   }
92133   jresult = result;
92134   return jresult;
92135 }
92136
92137
92138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
92139   float jresult ;
92140   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92141   float arg2 ;
92142   float arg3 ;
92143   float result;
92144
92145   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92146   arg2 = (float)jarg2;
92147   arg3 = (float)jarg3;
92148   {
92149     try {
92150       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
92151     } catch (std::out_of_range& e) {
92152       {
92153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92154       };
92155     } catch (std::exception& e) {
92156       {
92157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92158       };
92159     } catch (...) {
92160       {
92161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92162       };
92163     }
92164   }
92165   jresult = result;
92166   return jresult;
92167 }
92168
92169
92170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
92171   float jresult ;
92172   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92173   float arg2 ;
92174   float result;
92175
92176   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92177   arg2 = (float)jarg2;
92178   {
92179     try {
92180       result = (float)(*arg1)->SnapAndClamp(arg2);
92181     } catch (std::out_of_range& e) {
92182       {
92183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92184       };
92185     } catch (std::exception& e) {
92186       {
92187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92188       };
92189     } catch (...) {
92190       {
92191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92192       };
92193     }
92194   }
92195   jresult = result;
92196   return jresult;
92197 }
92198
92199
92200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
92201   float jresult ;
92202   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92203   float arg2 ;
92204   float arg3 ;
92205   float arg4 ;
92206   float arg5 ;
92207   Dali::Toolkit::ClampState *arg6 = 0 ;
92208   float result;
92209
92210   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92211   arg2 = (float)jarg2;
92212   arg3 = (float)jarg3;
92213   arg4 = (float)jarg4;
92214   arg5 = (float)jarg5;
92215   arg6 = (Dali::Toolkit::ClampState *)jarg6;
92216   if (!arg6) {
92217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92218     return 0;
92219   }
92220   {
92221     try {
92222       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
92223     } catch (std::out_of_range& e) {
92224       {
92225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92226       };
92227     } catch (std::exception& e) {
92228       {
92229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92230       };
92231     } catch (...) {
92232       {
92233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92234       };
92235     }
92236   }
92237   jresult = result;
92238   return jresult;
92239 }
92240
92241
92242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
92243   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92244
92245   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92246   {
92247     try {
92248       (*arg1)->Reference();
92249     } catch (std::out_of_range& e) {
92250       {
92251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92252       };
92253     } catch (std::exception& e) {
92254       {
92255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92256       };
92257     } catch (...) {
92258       {
92259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92260       };
92261     }
92262   }
92263 }
92264
92265
92266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
92267   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92268
92269   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92270   {
92271     try {
92272       (*arg1)->Unreference();
92273     } catch (std::out_of_range& e) {
92274       {
92275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92276       };
92277     } catch (std::exception& e) {
92278       {
92279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92280       };
92281     } catch (...) {
92282       {
92283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92284       };
92285     }
92286   }
92287 }
92288
92289
92290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
92291   int jresult ;
92292   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92293   int result;
92294
92295   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92296   {
92297     try {
92298       result = (int)(*arg1)->ReferenceCount();
92299     } catch (std::out_of_range& e) {
92300       {
92301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92302       };
92303     } catch (std::exception& e) {
92304       {
92305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92306       };
92307     } catch (...) {
92308       {
92309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92310       };
92311     }
92312   }
92313   jresult = result;
92314   return jresult;
92315 }
92316
92317
92318 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
92319     return (Dali::RefObject *)jarg1;
92320 }
92321
92322 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
92323     return (Dali::SignalObserver *)jarg1;
92324 }
92325
92326 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
92327     return (Dali::ConnectionTrackerInterface *)jarg1;
92328 }
92329
92330 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
92331     return (Dali::BaseHandle *)jarg1;
92332 }
92333
92334 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
92335     return (Dali::BaseHandle *)jarg1;
92336 }
92337
92338 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
92339     return (Dali::BaseHandle *)jarg1;
92340 }
92341
92342 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
92343     return (Dali::BaseHandle *)jarg1;
92344 }
92345
92346 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
92347     return (Dali::BaseHandle *)jarg1;
92348 }
92349
92350 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
92351     return (Dali::BaseHandle *)jarg1;
92352 }
92353
92354 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
92355     return (Dali::BaseHandle *)jarg1;
92356 }
92357
92358 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
92359     return (Dali::BaseHandle *)jarg1;
92360 }
92361
92362 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
92363     return (Dali::BaseHandle *)jarg1;
92364 }
92365
92366 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
92367     return (Dali::BaseHandle *)jarg1;
92368 }
92369
92370 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
92371     return (Dali::BaseHandle *)jarg1;
92372 }
92373
92374 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
92375     return (Dali::BaseHandle *)jarg1;
92376 }
92377
92378 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
92379     return (Dali::BaseHandle *)jarg1;
92380 }
92381
92382 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
92383     return (Dali::Handle *)jarg1;
92384 }
92385
92386 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
92387     return (Dali::Handle *)jarg1;
92388 }
92389
92390 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
92391     return (Dali::BaseHandle *)jarg1;
92392 }
92393
92394 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
92395     return (Dali::BaseHandle *)jarg1;
92396 }
92397
92398 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
92399     return (Dali::Handle *)jarg1;
92400 }
92401
92402 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
92403     return (Dali::BaseHandle *)jarg1;
92404 }
92405
92406 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
92407     return (Dali::Handle *)jarg1;
92408 }
92409
92410 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
92411     return (Dali::GestureDetector *)jarg1;
92412 }
92413
92414 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
92415     return (Dali::Gesture *)jarg1;
92416 }
92417
92418 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
92419     return (Dali::Handle *)jarg1;
92420 }
92421
92422 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
92423     return (Dali::Actor *)jarg1;
92424 }
92425
92426 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
92427     return (Dali::BaseHandle *)jarg1;
92428 }
92429
92430 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
92431     return (Dali::RefObject *)jarg1;
92432 }
92433
92434 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
92435     return (Dali::Actor *)jarg1;
92436 }
92437
92438 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
92439     return (Dali::GestureDetector *)jarg1;
92440 }
92441
92442 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
92443     return (Dali::Gesture *)jarg1;
92444 }
92445
92446 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
92447     return (Dali::GestureDetector *)jarg1;
92448 }
92449
92450 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
92451     return (Dali::Gesture *)jarg1;
92452 }
92453
92454 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
92455     return (Dali::GestureDetector *)jarg1;
92456 }
92457
92458 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
92459     return (Dali::Gesture *)jarg1;
92460 }
92461
92462 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
92463     return (Dali::BaseHandle *)jarg1;
92464 }
92465
92466 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
92467     return (Dali::Handle *)jarg1;
92468 }
92469
92470 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
92471     return (Dali::BaseHandle *)jarg1;
92472 }
92473
92474 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
92475     return (Dali::Handle *)jarg1;
92476 }
92477
92478 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
92479     return (Dali::Handle *)jarg1;
92480 }
92481
92482 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
92483     return (Dali::Image *)jarg1;
92484 }
92485
92486 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
92487     return (Dali::Image *)jarg1;
92488 }
92489
92490 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
92491     return (Dali::Image *)jarg1;
92492 }
92493
92494 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
92495     return (Dali::RefObject *)jarg1;
92496 }
92497
92498 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
92499     return (Dali::Image *)jarg1;
92500 }
92501
92502 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
92503     return (Dali::Image *)jarg1;
92504 }
92505
92506 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
92507     return (Dali::ResourceImage *)jarg1;
92508 }
92509
92510 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
92511     return (Dali::Actor *)jarg1;
92512 }
92513
92514 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
92515     return (Dali::BaseHandle *)jarg1;
92516 }
92517
92518 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
92519     return (Dali::BaseHandle *)jarg1;
92520 }
92521
92522 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
92523     return (Dali::BaseHandle *)jarg1;
92524 }
92525
92526 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
92527     return (Dali::BaseHandle *)jarg1;
92528 }
92529
92530 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
92531     return (Dali::BaseHandle *)jarg1;
92532 }
92533
92534 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
92535     return (Dali::BaseHandle *)jarg1;
92536 }
92537
92538 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
92539     return (Dali::CustomActorImpl *)jarg1;
92540 }
92541
92542 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
92543     return (Dali::CustomActor *)jarg1;
92544 }
92545
92546 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
92547     return (Dali::BaseHandle *)jarg1;
92548 }
92549
92550 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
92551     return (Dali::Toolkit::Control *)jarg1;
92552 }
92553
92554 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
92555     return (Dali::Toolkit::Control *)jarg1;
92556 }
92557
92558 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
92559     return (Dali::Toolkit::Button *)jarg1;
92560 }
92561
92562 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
92563     return (Dali::Toolkit::Button *)jarg1;
92564 }
92565
92566 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
92567     return (Dali::Toolkit::Button *)jarg1;
92568 }
92569
92570 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
92571     return (Dali::Toolkit::Control *)jarg1;
92572 }
92573
92574 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
92575     return (Dali::Toolkit::Control *)jarg1;
92576 }
92577
92578 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
92579     return (Dali::Toolkit::Control *)jarg1;
92580 }
92581
92582 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
92583     return (Dali::Toolkit::Control *)jarg1;
92584 }
92585
92586 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
92587     return (Dali::Toolkit::Control *)jarg1;
92588 }
92589
92590 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
92591     return (Dali::RefObject *)jarg1;
92592 }
92593
92594 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
92595     return (Dali::Toolkit::Scrollable *)jarg1;
92596 }
92597
92598 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
92599     return (Dali::BaseHandle *)jarg1;
92600 }
92601
92602 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
92603     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
92604 }
92605
92606 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
92607     return (Dali::RefObject *)jarg1;
92608 }
92609
92610 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
92611     return (Dali::Toolkit::Ruler *)jarg1;
92612 }
92613
92614 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
92615     return (Dali::Toolkit::Ruler *)jarg1;
92616 }
92617
92618 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
92619     return (Dali::Toolkit::Scrollable *)jarg1;
92620 }
92621
92622 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
92623     return (Dali::Toolkit::Control *)jarg1;
92624 }
92625
92626 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
92627     return (Dali::Toolkit::Control *)jarg1;
92628 }
92629
92630 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
92631     return (Dali::Toolkit::Control *)jarg1;
92632 }
92633
92634 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
92635     return (Dali::Toolkit::Control *)jarg1;
92636 }
92637
92638 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
92639     return (Dali::BaseHandle *)jarg1;
92640 }
92641
92642 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
92643     return (Dali::BaseHandle *)jarg1;
92644 }
92645
92646 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
92647     return (Dali::Toolkit::Control *)jarg1;
92648 }
92649
92650 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
92651     return (Dali::Toolkit::Control *)jarg1;
92652 }
92653
92654 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
92655     return (Dali::Toolkit::Control *)jarg1;
92656 }
92657
92658 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
92659     return (Dali::Toolkit::Control *)jarg1;
92660 }
92661
92662 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
92663     return (Dali::Toolkit::Control *)jarg1;
92664 }
92665
92666 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
92667     return (Dali::Toolkit::Control *)jarg1;
92668 }
92669
92670 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
92671     return (Dali::Toolkit::PageTurnView *)jarg1;
92672 }
92673
92674 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
92675     return (Dali::Toolkit::PageTurnView *)jarg1;
92676 }
92677
92678 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
92679     return (Dali::Toolkit::Button *)jarg1;
92680 }
92681
92682 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
92683     return (Dali::BaseHandle *)jarg1;
92684 }
92685
92686 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
92687     return (Dali::BaseHandle *)jarg1;
92688 }
92689
92690 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
92691     return (Dali::BaseHandle *)jarg1;
92692 }
92693
92694 #ifdef __cplusplus
92695 }
92696 #endif
92697