dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/public-api/math/matrix.h>
 427 #include <dali/public-api/math/matrix3.h>
 428 #include <dali/public-api/math/viewport.h>
 429 #include <dali/public-api/object/property-key.h>
 430 #include <dali/devel-api/object/csharp-type-info.h>
 431 #include <dali/devel-api/object/csharp-type-registry.h>
 432
 433 #include <dali/public-api/adaptor-framework/timer.h>
 434 #include <dali/public-api/adaptor-framework/window.h>
 435 #include <dali/public-api/adaptor-framework/style-change.h>
 436 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 437 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 438
 439 #include <dali/devel-api/images/nine-patch-image.h>
 440
 441 #include <dali-toolkit/devel-api/builder/builder.h>
 442
 443 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 444
 445 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 446 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 447 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 448 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 449 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 452 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 453
 454 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 455 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 456 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 457
 458 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 459
 460 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 461
 462 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 463
 464 // add here SWIG version check
 465
 466 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 467 // disable Swig-dependent warnings
 468
 469 // 'identifier1' has C-linkage specified,
 470 // but returns UDT 'identifier2' which is incompatible with C
 471 #pragma warning(disable: 4190)
 472
 473 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 474 #pragma warning(disable: 4800)
 475
 476 // debug info too long etc etc
 477 #pragma warning(disable: 4786)
 478 #endif
 479
 480
 481 #include <stdexcept>
 482
 483
 484 #include <string>
 485
 486
 487 #include <vector>
 488 #include <algorithm>
 489 #include <stdexcept>
 490
 491
 492 #include <map>
 493 #include <algorithm>
 494 #include <stdexcept>
 495
 496
 497 #include <utility>
 498
 499
 500 typedef float floatp;
 501
 502 SWIGINTERN floatp *new_floatp(){
 503   return new float();
 504 }
 505 SWIGINTERN void delete_floatp(floatp *self){
 506   if (self) delete self;
 507 }
 508 SWIGINTERN void floatp_assign(floatp *self,float value){
 509   *self = value;
 510 }
 511 SWIGINTERN float floatp_value(floatp *self){
 512   return *self;
 513 }
 514 SWIGINTERN float *floatp_cast(floatp *self){
 515   return self;
 516 }
 517 SWIGINTERN floatp *floatp_frompointer(float *t){
 518   return (floatp *) t;
 519 }
 520
 521 typedef int intp;
 522
 523 SWIGINTERN intp *new_intp(){
 524   return new int();
 525 }
 526 SWIGINTERN void delete_intp(intp *self){
 527   if (self) delete self;
 528 }
 529 SWIGINTERN void intp_assign(intp *self,int value){
 530   *self = value;
 531 }
 532 SWIGINTERN int intp_value(intp *self){
 533   return *self;
 534 }
 535 SWIGINTERN int *intp_cast(intp *self){
 536   return self;
 537 }
 538 SWIGINTERN intp *intp_frompointer(int *t){
 539   return (intp *) t;
 540 }
 541
 542 typedef double doublep;
 543
 544 SWIGINTERN doublep *new_doublep(){
 545   return new double();
 546 }
 547 SWIGINTERN void delete_doublep(doublep *self){
 548   if (self) delete self;
 549 }
 550 SWIGINTERN void doublep_assign(doublep *self,double value){
 551   *self = value;
 552 }
 553 SWIGINTERN double doublep_value(doublep *self){
 554   return *self;
 555 }
 556 SWIGINTERN double *doublep_cast(doublep *self){
 557   return self;
 558 }
 559 SWIGINTERN doublep *doublep_frompointer(double *t){
 560   return (doublep *) t;
 561 }
 562
 563 typedef unsigned int uintp;
 564
 565 SWIGINTERN uintp *new_uintp(){
 566   return new unsigned int();
 567 }
 568 SWIGINTERN void delete_uintp(uintp *self){
 569   if (self) delete self;
 570 }
 571 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 572   *self = value;
 573 }
 574 SWIGINTERN unsigned int uintp_value(uintp *self){
 575   return *self;
 576 }
 577 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 578   return self;
 579 }
 580 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 581   return (uintp *) t;
 582 }
 583
 584 typedef unsigned short ushortp;
 585
 586 SWIGINTERN ushortp *new_ushortp(){
 587   return new unsigned short();
 588 }
 589 SWIGINTERN void delete_ushortp(ushortp *self){
 590   if (self) delete self;
 591 }
 592 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 593   *self = value;
 594 }
 595 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 596   return *self;
 597 }
 598 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 599   return self;
 600 }
 601 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 602   return (ushortp *) t;
 603 }
 604
 605 unsigned int int_to_uint(int x) {
 606    return (unsigned int) x;
 607 }
 608
 609
 610 using namespace Dali;
 611 using namespace Dali::Toolkit;
 612
 613 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 614
 615      // C++ code. DALi uses Handle <-> Body design pattern.
 616      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 617      // Handles in DALi can be converted into a boolean type
 618      // to check if the handle has a valid body attached to it.
 619      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 620      if( *self )
 621      {
 622        return true;
 623      }
 624      else
 625      {
 626        return false;
 627      }
 628     }
 629 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 630
 631      // C++ code. Check if two handles reference the same implemtion
 632      if( *self == rhs)
 633      {
 634        return true;
 635      }
 636      else
 637      {
 638        return false;
 639      }
 640     }
 641 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 642      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 643    }
 644 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 645      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 646    }
 647 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 648         std::vector< Dali::TouchPoint >* pv = 0;
 649         if (capacity >= 0) {
 650           pv = new std::vector< Dali::TouchPoint >();
 651           pv->reserve(capacity);
 652        } else {
 653           throw std::out_of_range("capacity");
 654        }
 655        return pv;
 656       }
 657 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 658         if (index>=0 && index<(int)self->size())
 659           return (*self)[index];
 660         else
 661           throw std::out_of_range("index");
 662       }
 663 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 664         if (index>=0 && index<(int)self->size())
 665           return (*self)[index];
 666         else
 667           throw std::out_of_range("index");
 668       }
 669 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 670         if (index>=0 && index<(int)self->size())
 671           (*self)[index] = val;
 672         else
 673           throw std::out_of_range("index");
 674       }
 675 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 676         self->insert(self->end(), values.begin(), values.end());
 677       }
 678 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 679         if (index < 0)
 680           throw std::out_of_range("index");
 681         if (count < 0)
 682           throw std::out_of_range("count");
 683         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 684           throw std::invalid_argument("invalid range");
 685         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 686       }
 687 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 688         if (index>=0 && index<(int)self->size()+1)
 689           self->insert(self->begin()+index, x);
 690         else
 691           throw std::out_of_range("index");
 692       }
 693 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 694         if (index>=0 && index<(int)self->size()+1)
 695           self->insert(self->begin()+index, values.begin(), values.end());
 696         else
 697           throw std::out_of_range("index");
 698       }
 699 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 700         if (index>=0 && index<(int)self->size())
 701           self->erase(self->begin() + index);
 702         else
 703           throw std::out_of_range("index");
 704       }
 705 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 706         if (index < 0)
 707           throw std::out_of_range("index");
 708         if (count < 0)
 709           throw std::out_of_range("count");
 710         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 711           throw std::invalid_argument("invalid range");
 712         self->erase(self->begin()+index, self->begin()+index+count);
 713       }
 714 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 715         if (count < 0)
 716           throw std::out_of_range("count");
 717         return new std::vector< Dali::TouchPoint >(count, value);
 718       }
 719 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 720         std::reverse(self->begin(), self->end());
 721       }
 722 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 723         if (index < 0)
 724           throw std::out_of_range("index");
 725         if (count < 0)
 726           throw std::out_of_range("count");
 727         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 728           throw std::invalid_argument("invalid range");
 729         std::reverse(self->begin()+index, self->begin()+index+count);
 730       }
 731 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 732         if (index < 0)
 733           throw std::out_of_range("index");
 734         if (index+values.size() > self->size())
 735           throw std::out_of_range("index");
 736         std::copy(values.begin(), values.end(), self->begin()+index);
 737       }
 738 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 739          return self->Empty();
 740       }
 741 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 742         return self->GetConnectionCount();
 743       }
 744 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 745           self->Connect( func );
 746       }
 747 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 748           self->Disconnect( func );
 749       }
 750 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 751           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 752 /*@SWIG@*/ self->Emit( arg );
 753       }
 754 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 755          return self->Empty();
 756       }
 757 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 758         return self->GetConnectionCount();
 759       }
 760 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 761           self->Connect( func );
 762       }
 763 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 764           self->Disconnect( func );
 765       }
 766 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 767           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 768 /*@SWIG@*/ self->Emit( arg );
 769       }
 770 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 771          return self->Empty();
 772       }
 773 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 774         return self->GetConnectionCount();
 775       }
 776 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 777           self->Connect( func );
 778       }
 779 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 780           self->Disconnect( func );
 781       }
 782 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 783           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 784 /*@SWIG@*/ self->Emit( arg );
 785       }
 786 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 787          return self->Empty();
 788       }
 789 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 790         return self->GetConnectionCount();
 791       }
 792 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 793           self->Connect( func );
 794       }
 795 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 796           self->Disconnect( func );
 797       }
 798 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 799           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 800 /*@SWIG@*/ self->Emit( arg );
 801       }
 802 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 803          return self->Empty();
 804       }
 805 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 806         return self->GetConnectionCount();
 807       }
 808 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 809           self->Connect( func );
 810       }
 811 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 812           self->Disconnect( func );
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 815           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 816 /*@SWIG@*/ self->Emit( arg );
 817       }
 818 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 819          return self->Empty();
 820       }
 821 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 822         return self->GetConnectionCount();
 823       }
 824 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 825         self->Connect( func );
 826       }
 827 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,void (*func)(Dali::Actor,Dali::LongPressGesture const &)){
 828         self->Disconnect( func );
 829       }
 830 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *self,Dali::Actor arg1,Dali::LongPressGesture const &arg2){
 831         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 832 /*@SWIG@*/ self->Emit( arg1, arg2 );
 833       }
 834 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 835          return self->Empty();
 836       }
 837 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > const *self){
 838         return self->GetConnectionCount();
 839       }
 840 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 841         self->Connect( func );
 842       }
 843 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,bool (*func)(Dali::Actor,Dali::TouchData const &)){
 844         self->Disconnect( func );
 845       }
 846 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *self,Dali::Actor arg1,Dali::TouchData const &arg2){
 847         return self->Emit( arg1, arg2 );
 848       }
 849 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 850          return self->Empty();
 851       }
 852 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > const *self){
 853         return self->GetConnectionCount();
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 856         self->Connect( func );
 857       }
 858 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,bool (*func)(Dali::Actor,Dali::HoverEvent const &)){
 859         self->Disconnect( func );
 860       }
 861 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *self,Dali::Actor arg1,Dali::HoverEvent const &arg2){
 862         return self->Emit( arg1, arg2 );
 863       }
 864 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 865          return self->Empty();
 866       }
 867 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > const *self){
 868         return self->GetConnectionCount();
 869       }
 870 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 871         self->Connect( func );
 872       }
 873 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,bool (*func)(Dali::Actor,Dali::WheelEvent const &)){
 874         self->Disconnect( func );
 875       }
 876 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *self,Dali::Actor arg1,Dali::WheelEvent const &arg2){
 877         return self->Emit( arg1, arg2 );
 878       }
 879 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 880          return self->Empty();
 881       }
 882 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 883         return self->GetConnectionCount();
 884       }
 885 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 886           self->Connect( func );
 887       }
 888 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 889           self->Disconnect( func );
 890       }
 891 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 892           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 893 /*@SWIG@*/ self->Emit( arg );
 894       }
 895 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 896          return self->Empty();
 897       }
 898 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 899         return self->GetConnectionCount();
 900       }
 901 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 902           self->Connect( func );
 903       }
 904 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::KeyEvent const &) > *self,void (*func)(Dali::KeyEvent const &)){
 905           self->Disconnect( func );
 906       }
 907 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::KeyEvent const &) > *self,Dali::KeyEvent const &arg){
 908           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 909 /*@SWIG@*/ self->Emit( arg );
 910       }
 911 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 912          return self->Empty();
 913       }
 914 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchData const &) > const *self){
 915         return self->GetConnectionCount();
 916       }
 917 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 918           self->Connect( func );
 919       }
 920 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchData const &) > *self,void (*func)(Dali::TouchData const &)){
 921           self->Disconnect( func );
 922       }
 923 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchData const &) > *self,Dali::TouchData const &arg){
 924           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 925 /*@SWIG@*/ self->Emit( arg );
 926       }
 927 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 928          return self->Empty();
 929       }
 930 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 931         return self->GetConnectionCount();
 932       }
 933 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 934           self->Connect( func );
 935       }
 936 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::WheelEvent const &) > *self,void (*func)(Dali::WheelEvent const &)){
 937           self->Disconnect( func );
 938       }
 939 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::WheelEvent const &) > *self,Dali::WheelEvent const &arg){
 940           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 941 /*@SWIG@*/ self->Emit( arg );
 942       }
 943 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 944          return self->Empty();
 945       }
 946 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > const *self){
 947         return self->GetConnectionCount();
 948       }
 949 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 950         self->Connect( func );
 951       }
 952 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,void (*func)(Dali::Actor,Dali::PanGesture const &)){
 953         self->Disconnect( func );
 954       }
 955 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *self,Dali::Actor arg1,Dali::PanGesture const &arg2){
 956         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 957 /*@SWIG@*/ self->Emit( arg1, arg2 );
 958       }
 959 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 960          return self->Empty();
 961       }
 962 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > const *self){
 963         return self->GetConnectionCount();
 964       }
 965 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 966         self->Connect( func );
 967       }
 968 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,void (*func)(Dali::Actor,Dali::PinchGesture const &)){
 969         self->Disconnect( func );
 970       }
 971 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *self,Dali::Actor arg1,Dali::PinchGesture const &arg2){
 972         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 973 /*@SWIG@*/ self->Emit( arg1, arg2 );
 974       }
 975 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 976          return self->Empty();
 977       }
 978 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
 979         return self->GetConnectionCount();
 980       }
 981 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 982         self->Connect( func );
 983       }
 984 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,void (*func)(Dali::Actor,Dali::TapGesture const &)){
 985         self->Disconnect( func );
 986       }
 987 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *self,Dali::Actor arg1,Dali::TapGesture const &arg2){
 988         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 989 /*@SWIG@*/ self->Emit( arg1, arg2 );
 990       }
 991 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
 992          return self->Empty();
 993       }
 994 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
 995         return self->GetConnectionCount();
 996       }
 997 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
 998           self->Connect( func );
 999       }
1000 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1001           self->Disconnect( func );
1002       }
1003 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1004           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1005 /*@SWIG@*/ self->Emit( arg );
1006       }
1007 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1008          return self->Empty();
1009       }
1010 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1011         return self->GetConnectionCount();
1012       }
1013 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1014           self->Connect( func );
1015       }
1016 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1017           self->Disconnect( func );
1018       }
1019 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1020           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1021 /*@SWIG@*/ self->Emit( arg );
1022       }
1023
1024   // keep argcs and argv so they're always available to DALi
1025   int argC = 1;
1026   char **argV = NULL;
1027
1028 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1029          return self->Empty();
1030       }
1031 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1032         return self->GetConnectionCount();
1033       }
1034 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1035           self->Connect( func );
1036       }
1037 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1038           self->Disconnect( func );
1039       }
1040 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1041           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1042 /*@SWIG@*/ self->Emit( arg );
1043       }
1044 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1045          return self->Empty();
1046       }
1047 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,void *) > const *self){
1048         return self->GetConnectionCount();
1049       }
1050 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1051         self->Connect( func );
1052       }
1053 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1054         self->Disconnect( func );
1055       }
1056 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,void *) > *self,Dali::Application &arg1,void *arg2){
1057         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1058 /*@SWIG@*/ self->Emit( arg1, arg2 );
1059       }
1060 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1061         std::vector< unsigned int >* pv = 0;
1062         if (capacity >= 0) {
1063           pv = new std::vector< unsigned int >();
1064           pv->reserve(capacity);
1065        } else {
1066           throw std::out_of_range("capacity");
1067        }
1068        return pv;
1069       }
1070 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1071         if (index>=0 && index<(int)self->size())
1072           return (*self)[index];
1073         else
1074           throw std::out_of_range("index");
1075       }
1076 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1077         if (index>=0 && index<(int)self->size())
1078           return (*self)[index];
1079         else
1080           throw std::out_of_range("index");
1081       }
1082 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1083         if (index>=0 && index<(int)self->size())
1084           (*self)[index] = val;
1085         else
1086           throw std::out_of_range("index");
1087       }
1088 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1089         self->insert(self->end(), values.begin(), values.end());
1090       }
1091 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1092         if (index < 0)
1093           throw std::out_of_range("index");
1094         if (count < 0)
1095           throw std::out_of_range("count");
1096         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1097           throw std::invalid_argument("invalid range");
1098         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1099       }
1100 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1101         if (index>=0 && index<(int)self->size()+1)
1102           self->insert(self->begin()+index, x);
1103         else
1104           throw std::out_of_range("index");
1105       }
1106 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1107         if (index>=0 && index<(int)self->size()+1)
1108           self->insert(self->begin()+index, values.begin(), values.end());
1109         else
1110           throw std::out_of_range("index");
1111       }
1112 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1113         if (index>=0 && index<(int)self->size())
1114           self->erase(self->begin() + index);
1115         else
1116           throw std::out_of_range("index");
1117       }
1118 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1119         if (index < 0)
1120           throw std::out_of_range("index");
1121         if (count < 0)
1122           throw std::out_of_range("count");
1123         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1124           throw std::invalid_argument("invalid range");
1125         self->erase(self->begin()+index, self->begin()+index+count);
1126       }
1127 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1128         if (count < 0)
1129           throw std::out_of_range("count");
1130         return new std::vector< unsigned int >(count, value);
1131       }
1132 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1133         std::reverse(self->begin(), self->end());
1134       }
1135 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1136         if (index < 0)
1137           throw std::out_of_range("index");
1138         if (count < 0)
1139           throw std::out_of_range("count");
1140         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1141           throw std::invalid_argument("invalid range");
1142         std::reverse(self->begin()+index, self->begin()+index+count);
1143       }
1144 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1145         if (index < 0)
1146           throw std::out_of_range("index");
1147         if (index+values.size() > self->size())
1148           throw std::out_of_range("index");
1149         std::copy(values.begin(), values.end(), self->begin()+index);
1150       }
1151 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1152         return std::find(self->begin(), self->end(), value) != self->end();
1153       }
1154 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1155         int index = -1;
1156         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1157         if (it != self->end())
1158           index = (int)(it - self->begin());
1159         return index;
1160       }
1161 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1162         int index = -1;
1163         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1164         if (rit != self->rend())
1165           index = (int)(self->rend() - 1 - rit);
1166         return index;
1167       }
1168 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1169         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1170         if (it != self->end()) {
1171           self->erase(it);
1172           return true;
1173         }
1174         return false;
1175       }
1176 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *new_std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg___SWIG_2(int capacity){
1177         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1178         if (capacity >= 0) {
1179           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1180           pv->reserve(capacity);
1181        } else {
1182           throw std::out_of_range("capacity");
1183        }
1184        return pv;
1185       }
1186 SWIGINTERN std::pair< unsigned int,Dali::Actor > std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1187         if (index>=0 && index<(int)self->size())
1188           return (*self)[index];
1189         else
1190           throw std::out_of_range("index");
1191       }
1192 SWIGINTERN std::pair< unsigned int,Dali::Actor > const &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1193         if (index>=0 && index<(int)self->size())
1194           return (*self)[index];
1195         else
1196           throw std::out_of_range("index");
1197       }
1198 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1199         if (index>=0 && index<(int)self->size())
1200           (*self)[index] = val;
1201         else
1202           throw std::out_of_range("index");
1203       }
1204 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1205         self->insert(self->end(), values.begin(), values.end());
1206       }
1207 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1208         if (index < 0)
1209           throw std::out_of_range("index");
1210         if (count < 0)
1211           throw std::out_of_range("count");
1212         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1213           throw std::invalid_argument("invalid range");
1214         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1215       }
1216 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Insert(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &x){
1217         if (index>=0 && index<(int)self->size()+1)
1218           self->insert(self->begin()+index, x);
1219         else
1220           throw std::out_of_range("index");
1221       }
1222 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__InsertRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1223         if (index>=0 && index<(int)self->size()+1)
1224           self->insert(self->begin()+index, values.begin(), values.end());
1225         else
1226           throw std::out_of_range("index");
1227       }
1228 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index){
1229         if (index>=0 && index<(int)self->size())
1230           self->erase(self->begin() + index);
1231         else
1232           throw std::out_of_range("index");
1233       }
1234 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1235         if (index < 0)
1236           throw std::out_of_range("index");
1237         if (count < 0)
1238           throw std::out_of_range("count");
1239         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1240           throw std::invalid_argument("invalid range");
1241         self->erase(self->begin()+index, self->begin()+index+count);
1242       }
1243 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Repeat(std::pair< unsigned int,Dali::Actor > const &value,int count){
1244         if (count < 0)
1245           throw std::out_of_range("count");
1246         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1247       }
1248 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(std::vector< std::pair< unsigned int,Dali::Actor > > *self){
1249         std::reverse(self->begin(), self->end());
1250       }
1251 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1252         if (index < 0)
1253           throw std::out_of_range("index");
1254         if (count < 0)
1255           throw std::out_of_range("count");
1256         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1257           throw std::invalid_argument("invalid range");
1258         std::reverse(self->begin()+index, self->begin()+index+count);
1259       }
1260 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1261         if (index < 0)
1262           throw std::out_of_range("index");
1263         if (index+values.size() > self->size())
1264           throw std::out_of_range("index");
1265         std::copy(values.begin(), values.end(), self->begin()+index);
1266       }
1267 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1268         std::vector< Dali::Actor >* pv = 0;
1269         if (capacity >= 0) {
1270           pv = new std::vector< Dali::Actor >();
1271           pv->reserve(capacity);
1272        } else {
1273           throw std::out_of_range("capacity");
1274        }
1275        return pv;
1276       }
1277 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1278         if (index>=0 && index<(int)self->size())
1279           return (*self)[index];
1280         else
1281           throw std::out_of_range("index");
1282       }
1283 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1284         if (index>=0 && index<(int)self->size())
1285           return (*self)[index];
1286         else
1287           throw std::out_of_range("index");
1288       }
1289 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1290         if (index>=0 && index<(int)self->size())
1291           (*self)[index] = val;
1292         else
1293           throw std::out_of_range("index");
1294       }
1295 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1296         self->insert(self->end(), values.begin(), values.end());
1297       }
1298 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1299         if (index < 0)
1300           throw std::out_of_range("index");
1301         if (count < 0)
1302           throw std::out_of_range("count");
1303         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1304           throw std::invalid_argument("invalid range");
1305         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1306       }
1307 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1308         if (index>=0 && index<(int)self->size()+1)
1309           self->insert(self->begin()+index, x);
1310         else
1311           throw std::out_of_range("index");
1312       }
1313 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1314         if (index>=0 && index<(int)self->size()+1)
1315           self->insert(self->begin()+index, values.begin(), values.end());
1316         else
1317           throw std::out_of_range("index");
1318       }
1319 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1320         if (index>=0 && index<(int)self->size())
1321           self->erase(self->begin() + index);
1322         else
1323           throw std::out_of_range("index");
1324       }
1325 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1326         if (index < 0)
1327           throw std::out_of_range("index");
1328         if (count < 0)
1329           throw std::out_of_range("count");
1330         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1331           throw std::invalid_argument("invalid range");
1332         self->erase(self->begin()+index, self->begin()+index+count);
1333       }
1334 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1335         if (count < 0)
1336           throw std::out_of_range("count");
1337         return new std::vector< Dali::Actor >(count, value);
1338       }
1339 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1340         std::reverse(self->begin(), self->end());
1341       }
1342 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1343         if (index < 0)
1344           throw std::out_of_range("index");
1345         if (count < 0)
1346           throw std::out_of_range("count");
1347         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1348           throw std::invalid_argument("invalid range");
1349         std::reverse(self->begin()+index, self->begin()+index+count);
1350       }
1351 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1352         if (index < 0)
1353           throw std::out_of_range("index");
1354         if (index+values.size() > self->size())
1355           throw std::out_of_range("index");
1356         std::copy(values.begin(), values.end(), self->begin()+index);
1357       }
1358 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1359          return self->Empty();
1360       }
1361 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1362         return self->GetConnectionCount();
1363       }
1364 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1365           self->Connect( func );
1366       }
1367 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,bool (*func)(Dali::Toolkit::AccessibilityManager &)){
1368           self->Disconnect( func );
1369       }
1370 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *self,Dali::Toolkit::AccessibilityManager &arg){
1371           return self->Emit( arg );
1372       }
1373 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1374          return self->Empty();
1375       }
1376 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > const *self){
1377         return self->GetConnectionCount();
1378       }
1379 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1380         self->Connect( func );
1381       }
1382 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,void (*func)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)){
1383         self->Disconnect( func );
1384       }
1385 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *self,Dali::Actor arg1,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg2){
1386         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1387 /*@SWIG@*/ self->Emit( arg1, arg2 );
1388       }
1389 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1390          return self->Empty();
1391       }
1392 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1393         return self->GetConnectionCount();
1394       }
1395 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1396         self->Connect( func );
1397       }
1398 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,void (*func)(Dali::Actor,Dali::Actor)){
1399         self->Disconnect( func );
1400       }
1401 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,Dali::Actor) > *self,Dali::Actor arg1,Dali::Actor arg2){
1402         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1403 /*@SWIG@*/ self->Emit( arg1, arg2 );
1404       }
1405 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1406          return self->Empty();
1407       }
1408 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1409         return self->GetConnectionCount();
1410       }
1411 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1412         self->Connect( func );
1413       }
1414 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor,bool) > *self,void (*func)(Dali::Actor,bool)){
1415         self->Disconnect( func );
1416       }
1417 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Actor,bool) > *self,Dali::Actor arg1,bool arg2){
1418         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1419 /*@SWIG@*/ self->Emit( arg1, arg2 );
1420       }
1421 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1422          return self->Empty();
1423       }
1424 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1425         return self->GetConnectionCount();
1426       }
1427 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1428         self->Connect( func );
1429       }
1430 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,void (*func)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)){
1431         self->Disconnect( func );
1432       }
1433 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *self,Dali::Toolkit::StyleManager arg1,Dali::StyleChange::Type arg2){
1434         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1435 /*@SWIG@*/ self->Emit( arg1, arg2 );
1436       }
1437 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1438          return self->Empty();
1439       }
1440 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1441         return self->GetConnectionCount();
1442       }
1443 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1444           self->Connect( func );
1445       }
1446 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Button) > *self,bool (*func)(Dali::Toolkit::Button)){
1447           self->Disconnect( func );
1448       }
1449 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1450           return self->Emit( arg );
1451       }
1452 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1453          return self->Empty();
1454       }
1455 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1456         return self->GetConnectionCount();
1457       }
1458 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1459           self->Connect( func );
1460       }
1461 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,void (*func)(Dali::Toolkit::GaussianBlurView)){
1462           self->Disconnect( func );
1463       }
1464 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1465           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1466 /*@SWIG@*/ self->Emit( arg );
1467       }
1468 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1469          return self->Empty();
1470       }
1471 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > const *self){
1472         return self->GetConnectionCount();
1473       }
1474 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1475           return self->Connect( func );
1476       }
1477 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,void (*func)(Dali::Toolkit::PageTurnView,unsigned int,bool)){
1478           self->Disconnect( func );
1479       }
1480 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *self,Dali::Toolkit::PageTurnView arg1,unsigned int arg2,bool arg3){
1481           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1482 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1483       }
1484 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1485          return self->Empty();
1486       }
1487 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1488         return self->GetConnectionCount();
1489       }
1490 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1491           self->Connect( func );
1492       }
1493 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,void (*func)(Dali::Toolkit::PageTurnView)){
1494           self->Disconnect( func );
1495       }
1496 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1497           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1498 /*@SWIG@*/ self->Emit( arg );
1499       }
1500 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1501          return self->Empty();
1502       }
1503 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > const *self){
1504         return self->GetConnectionCount();
1505       }
1506 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1507           self->Connect( func );
1508       }
1509 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,void (*func)(Dali::Toolkit::ScrollView::SnapEvent const &)){
1510           self->Disconnect( func );
1511       }
1512 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *self,Dali::Toolkit::ScrollView::SnapEvent const &arg){
1513           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1514 /*@SWIG@*/ self->Emit( arg );
1515       }
1516 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1517          return self->Empty();
1518       }
1519 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1520         return self->GetConnectionCount();
1521       }
1522 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1523           self->Connect( func );
1524       }
1525 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Vector2 const &) > *self,void (*func)(Dali::Vector2 const &)){
1526           self->Disconnect( func );
1527       }
1528 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Vector2 const &) > *self,Dali::Vector2 const &arg){
1529           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1530 /*@SWIG@*/ self->Emit( arg );
1531       }
1532 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1533          return self->Empty();
1534       }
1535 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1536         return self->GetConnectionCount();
1537       }
1538 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1539           self->Connect( func );
1540       }
1541 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1542           self->Disconnect( func );
1543       }
1544 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1545           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1546 /*@SWIG@*/ self->Emit( arg );
1547       }
1548 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1549          return self->Empty();
1550       }
1551 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1552         return self->GetConnectionCount();
1553       }
1554 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1555           self->Connect( func );
1556       }
1557 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1558           self->Disconnect( func );
1559       }
1560 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1561           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1562 /*@SWIG@*/ self->Emit( arg );
1563       }
1564 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1565          return self->Empty();
1566       }
1567 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > const *self){
1568         return self->GetConnectionCount();
1569       }
1570 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1571         self->Connect( func );
1572       }
1573 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,bool (*func)(Dali::Toolkit::Control,Dali::KeyEvent const &)){
1574         self->Disconnect( func );
1575       }
1576 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *self,Dali::Toolkit::Control arg1,Dali::KeyEvent const &arg2){
1577         return self->Emit( arg1, arg2 );
1578       }
1579 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1580          return self->Empty();
1581       }
1582 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1583         return self->GetConnectionCount();
1584       }
1585 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1586           self->Connect( func );
1587       }
1588 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::Control) > *self,void (*func)(Dali::Toolkit::Control)){
1589           self->Disconnect( func );
1590       }
1591 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1592           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1593 /*@SWIG@*/ self->Emit( arg );
1594       }
1595 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1596          return self->Empty();
1597       }
1598 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1599         return self->GetConnectionCount();
1600       }
1601 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1602           self->Connect( func );
1603       }
1604 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,void (*func)(Dali::Toolkit::VideoView &)){
1605           self->Disconnect( func );
1606       }
1607 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::VideoView &) > *self,Dali::Toolkit::VideoView &arg){
1608           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1609 /*@SWIG@*/ self->Emit( arg );
1610       }
1611 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1612          return self->Empty();
1613       }
1614 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1615         return self->GetConnectionCount();
1616       }
1617 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1618         self->Connect( func );
1619       }
1620 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,bool (*func)(Dali::Toolkit::Slider,float)){
1621         self->Disconnect( func );
1622       }
1623 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,float) > *self,Dali::Toolkit::Slider arg1,float arg2){
1624         return self->Emit( arg1, arg2 );
1625       }
1626 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1627          return self->Empty();
1628       }
1629 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1630         return self->GetConnectionCount();
1631       }
1632 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1633         self->Connect( func );
1634       }
1635 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,bool (*func)(Dali::Toolkit::Slider,int)){
1636         self->Disconnect( func );
1637       }
1638 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Slider,int) > *self,Dali::Toolkit::Slider arg1,int arg2){
1639         return self->Emit( arg1, arg2 );
1640       }
1641
1642
1643 /* ---------------------------------------------------
1644  * C++ director class methods
1645  * --------------------------------------------------- */
1646
1647 #include "dali_wrap.h"
1648
1649 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1650   swig_init_callbacks();
1651 }
1652
1653 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1654
1655 }
1656
1657
1658 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1659   int jdepth  ;
1660
1661   if (!swig_callbackOnStageConnection) {
1662     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1663     return;
1664   } else {
1665     jdepth = depth;
1666     swig_callbackOnStageConnection(jdepth);
1667   }
1668 }
1669
1670 void SwigDirector_ViewImpl::OnStageDisconnection() {
1671   if (!swig_callbackOnStageDisconnection) {
1672     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1673     return;
1674   } else {
1675     swig_callbackOnStageDisconnection();
1676   }
1677 }
1678
1679 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1680   void * jchild = 0 ;
1681
1682   if (!swig_callbackOnChildAdd) {
1683     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1684     return;
1685   } else {
1686     jchild = (Dali::Actor *) &child;
1687     swig_callbackOnChildAdd(jchild);
1688   }
1689 }
1690
1691 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1692   void * jchild = 0 ;
1693
1694   if (!swig_callbackOnChildRemove) {
1695     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1696     return;
1697   } else {
1698     jchild = (Dali::Actor *) &child;
1699     swig_callbackOnChildRemove(jchild);
1700   }
1701 }
1702
1703 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1704   int jindex  ;
1705   void * jpropertyValue  ;
1706
1707   if (!swig_callbackOnPropertySet) {
1708     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1709     return;
1710   } else {
1711     jindex = index;
1712     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1713     swig_callbackOnPropertySet(jindex, jpropertyValue);
1714   }
1715 }
1716
1717 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1718   void * jtargetSize = 0 ;
1719
1720   if (!swig_callbackOnSizeSet) {
1721     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1722     return;
1723   } else {
1724     jtargetSize = (Dali::Vector3 *) &targetSize;
1725     swig_callbackOnSizeSet(jtargetSize);
1726   }
1727 }
1728
1729 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1730   void * janimation = 0 ;
1731   void * jtargetSize = 0 ;
1732
1733   if (!swig_callbackOnSizeAnimation) {
1734     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1735     return;
1736   } else {
1737     janimation = (Dali::Animation *) &animation;
1738     jtargetSize = (Dali::Vector3 *) &targetSize;
1739     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1740   }
1741 }
1742
1743 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1744   bool c_result = SwigValueInit< bool >() ;
1745   unsigned int jresult = 0 ;
1746   void * jarg0 = 0 ;
1747
1748   if (!swig_callbackOnTouchEvent) {
1749     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1750   } else {
1751     jarg0 = (Dali::TouchEvent *) &event;
1752     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1753     c_result = jresult ? true : false;
1754   }
1755   return c_result;
1756 }
1757
1758 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1759   bool c_result = SwigValueInit< bool >() ;
1760   unsigned int jresult = 0 ;
1761   void * jarg0 = 0 ;
1762
1763   if (!swig_callbackOnHoverEvent) {
1764     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1765   } else {
1766     jarg0 = (Dali::HoverEvent *) &event;
1767     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1768     c_result = jresult ? true : false;
1769   }
1770   return c_result;
1771 }
1772
1773 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1774   bool c_result = SwigValueInit< bool >() ;
1775   unsigned int jresult = 0 ;
1776   void * jarg0 = 0 ;
1777
1778   if (!swig_callbackOnKeyEvent) {
1779     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1780   } else {
1781     jarg0 = (Dali::KeyEvent *) &event;
1782     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1783     c_result = jresult ? true : false;
1784   }
1785   return c_result;
1786 }
1787
1788 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1789   bool c_result = SwigValueInit< bool >() ;
1790   unsigned int jresult = 0 ;
1791   void * jarg0 = 0 ;
1792
1793   if (!swig_callbackOnWheelEvent) {
1794     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1795   } else {
1796     jarg0 = (Dali::WheelEvent *) &event;
1797     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1798     c_result = jresult ? true : false;
1799   }
1800   return c_result;
1801 }
1802
1803 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1804   void * jsize = 0 ;
1805   void * jcontainer = 0 ;
1806
1807   if (!swig_callbackOnRelayout) {
1808     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1809     return;
1810   } else {
1811     jsize = (Dali::Vector2 *) &size;
1812     jcontainer = (Dali::RelayoutContainer *) &container;
1813     swig_callbackOnRelayout(jsize, jcontainer);
1814   }
1815 }
1816
1817 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1818   int jpolicy  ;
1819   int jdimension  ;
1820
1821   if (!swig_callbackOnSetResizePolicy) {
1822     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1823     return;
1824   } else {
1825     jpolicy = (int)policy;
1826     jdimension = (int)dimension;
1827     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1828   }
1829 }
1830
1831 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1832   Dali::Vector3 c_result ;
1833   void * jresult = 0 ;
1834
1835   if (!swig_callbackGetNaturalSize) {
1836     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1837   } else {
1838     jresult = (void *) swig_callbackGetNaturalSize();
1839     if (!jresult) {
1840       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1841       return c_result;
1842     }
1843     c_result = *(Dali::Vector3 *)jresult;
1844   }
1845   return c_result;
1846 }
1847
1848 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1849   float c_result = SwigValueInit< float >() ;
1850   float jresult = 0 ;
1851   void * jchild = 0 ;
1852   int jdimension  ;
1853
1854   if (!swig_callbackCalculateChildSize) {
1855     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1856   } else {
1857     jchild = (Dali::Actor *) &child;
1858     jdimension = (int)dimension;
1859     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1860     c_result = (float)jresult;
1861   }
1862   return c_result;
1863 }
1864
1865 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1866   float c_result = SwigValueInit< float >() ;
1867   float jresult = 0 ;
1868   float jwidth  ;
1869
1870   if (!swig_callbackGetHeightForWidth) {
1871     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1872   } else {
1873     jwidth = width;
1874     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1875     c_result = (float)jresult;
1876   }
1877   return c_result;
1878 }
1879
1880 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1881   float c_result = SwigValueInit< float >() ;
1882   float jresult = 0 ;
1883   float jheight  ;
1884
1885   if (!swig_callbackGetWidthForHeight) {
1886     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1887   } else {
1888     jheight = height;
1889     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1890     c_result = (float)jresult;
1891   }
1892   return c_result;
1893 }
1894
1895 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1896   bool c_result = SwigValueInit< bool >() ;
1897   unsigned int jresult = 0 ;
1898   int jdimension  ;
1899
1900   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1901     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1902   } else {
1903     jdimension = (int)dimension;
1904     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1905     c_result = jresult ? true : false;
1906   }
1907   return c_result;
1908 }
1909
1910 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1911   int jdimension  ;
1912
1913   if (!swig_callbackOnCalculateRelayoutSize) {
1914     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1915     return;
1916   } else {
1917     jdimension = (int)dimension;
1918     swig_callbackOnCalculateRelayoutSize(jdimension);
1919   }
1920 }
1921
1922 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1923   float jsize  ;
1924   int jdimension  ;
1925
1926   if (!swig_callbackOnLayoutNegotiated) {
1927     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1928     return;
1929   } else {
1930     jsize = size;
1931     jdimension = (int)dimension;
1932     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1933   }
1934 }
1935
1936 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1937   return Dali::CustomActorImpl::GetExtension();
1938 }
1939
1940 void SwigDirector_ViewImpl::OnInitialize() {
1941   if (!swig_callbackOnInitialize) {
1942     Dali::Toolkit::Internal::Control::OnInitialize();
1943     return;
1944   } else {
1945     swig_callbackOnInitialize();
1946   }
1947 }
1948
1949 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1950   void * jchild = 0 ;
1951
1952   if (!swig_callbackOnControlChildAdd) {
1953     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1954     return;
1955   } else {
1956     jchild = (Dali::Actor *) &child;
1957     swig_callbackOnControlChildAdd(jchild);
1958   }
1959 }
1960
1961 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1962   void * jchild = 0 ;
1963
1964   if (!swig_callbackOnControlChildRemove) {
1965     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
1966     return;
1967   } else {
1968     jchild = (Dali::Actor *) &child;
1969     swig_callbackOnControlChildRemove(jchild);
1970   }
1971 }
1972
1973 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
1974   void * jstyleManager  ;
1975   int jchange  ;
1976
1977   if (!swig_callbackOnStyleChange) {
1978     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
1979     return;
1980   } else {
1981     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
1982     jchange = (int)change;
1983     swig_callbackOnStyleChange(jstyleManager, jchange);
1984   }
1985 }
1986
1987 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
1988   bool c_result = SwigValueInit< bool >() ;
1989   unsigned int jresult = 0 ;
1990
1991   if (!swig_callbackOnAccessibilityActivated) {
1992     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
1993   } else {
1994     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
1995     c_result = jresult ? true : false;
1996   }
1997   return c_result;
1998 }
1999
2000 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2001   bool c_result = SwigValueInit< bool >() ;
2002   unsigned int jresult = 0 ;
2003   void * jgesture  ;
2004
2005   if (!swig_callbackOnAccessibilityPan) {
2006     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2007   } else {
2008     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2009     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2010     c_result = jresult ? true : false;
2011   }
2012   return c_result;
2013 }
2014
2015 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2016   bool c_result = SwigValueInit< bool >() ;
2017   unsigned int jresult = 0 ;
2018   void * jtouchEvent = 0 ;
2019
2020   if (!swig_callbackOnAccessibilityTouch) {
2021     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2022   } else {
2023     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2024     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2025     c_result = jresult ? true : false;
2026   }
2027   return c_result;
2028 }
2029
2030 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2031   bool c_result = SwigValueInit< bool >() ;
2032   unsigned int jresult = 0 ;
2033   unsigned int jisIncrease  ;
2034
2035   if (!swig_callbackOnAccessibilityValueChange) {
2036     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2037   } else {
2038     jisIncrease = isIncrease;
2039     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2040     c_result = jresult ? true : false;
2041   }
2042   return c_result;
2043 }
2044
2045 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2046   bool c_result = SwigValueInit< bool >() ;
2047   unsigned int jresult = 0 ;
2048
2049   if (!swig_callbackOnAccessibilityZoom) {
2050     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2051   } else {
2052     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2053     c_result = jresult ? true : false;
2054   }
2055   return c_result;
2056 }
2057
2058 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2059   if (!swig_callbackOnKeyInputFocusGained) {
2060     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2061     return;
2062   } else {
2063     swig_callbackOnKeyInputFocusGained();
2064   }
2065 }
2066
2067 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2068   if (!swig_callbackOnKeyInputFocusLost) {
2069     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2070     return;
2071   } else {
2072     swig_callbackOnKeyInputFocusLost();
2073   }
2074 }
2075
2076 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2077   Dali::Actor c_result ;
2078   void * jresult = 0 ;
2079   void * jcurrentFocusedActor  ;
2080   int jdirection  ;
2081   unsigned int jloopEnabled  ;
2082
2083   if (!swig_callbackGetNextKeyboardFocusableActor) {
2084     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2085   } else {
2086     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2087     jdirection = (int)direction;
2088     jloopEnabled = loopEnabled;
2089     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2090     if (!jresult) {
2091       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2092       return c_result;
2093     }
2094     c_result = *(Dali::Actor *)jresult;
2095   }
2096   return c_result;
2097 }
2098
2099 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2100   void * jcommitedFocusableActor  ;
2101
2102   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2103     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2104     return;
2105   } else {
2106     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2107     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2108   }
2109 }
2110
2111 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2112   bool c_result = SwigValueInit< bool >() ;
2113   unsigned int jresult = 0 ;
2114
2115   if (!swig_callbackOnKeyboardEnter) {
2116     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2117   } else {
2118     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2119     c_result = jresult ? true : false;
2120   }
2121   return c_result;
2122 }
2123
2124 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2125   void * jpinch = 0 ;
2126
2127   if (!swig_callbackOnPinch) {
2128     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2129     return;
2130   } else {
2131     jpinch = (Dali::PinchGesture *) &pinch;
2132     swig_callbackOnPinch(jpinch);
2133   }
2134 }
2135
2136 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2137   void * jpan = 0 ;
2138
2139   if (!swig_callbackOnPan) {
2140     Dali::Toolkit::Internal::Control::OnPan(pan);
2141     return;
2142   } else {
2143     jpan = (Dali::PanGesture *) &pan;
2144     swig_callbackOnPan(jpan);
2145   }
2146 }
2147
2148 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2149   void * jtap = 0 ;
2150
2151   if (!swig_callbackOnTap) {
2152     Dali::Toolkit::Internal::Control::OnTap(tap);
2153     return;
2154   } else {
2155     jtap = (Dali::TapGesture *) &tap;
2156     swig_callbackOnTap(jtap);
2157   }
2158 }
2159
2160 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2161   void * jlongPress = 0 ;
2162
2163   if (!swig_callbackOnLongPress) {
2164     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2165     return;
2166   } else {
2167     jlongPress = (Dali::LongPressGesture *) &longPress;
2168     swig_callbackOnLongPress(jlongPress);
2169   }
2170 }
2171
2172 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2173   void * jslotObserver = 0 ;
2174   void * jcallback = 0 ;
2175
2176   if (!swig_callbackSignalConnected) {
2177     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2178     return;
2179   } else {
2180     jslotObserver = (void *) slotObserver;
2181     jcallback = (void *) callback;
2182     swig_callbackSignalConnected(jslotObserver, jcallback);
2183   }
2184 }
2185
2186 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2187   void * jslotObserver = 0 ;
2188   void * jcallback = 0 ;
2189
2190   if (!swig_callbackSignalDisconnected) {
2191     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2192     return;
2193   } else {
2194     jslotObserver = (void *) slotObserver;
2195     jcallback = (void *) callback;
2196     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2197   }
2198 }
2199
2200 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2201   return Dali::Toolkit::Internal::Control::GetControlExtension();
2202 }
2203
2204 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2205   swig_callbackOnStageConnection = callbackOnStageConnection;
2206   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2207   swig_callbackOnChildAdd = callbackOnChildAdd;
2208   swig_callbackOnChildRemove = callbackOnChildRemove;
2209   swig_callbackOnPropertySet = callbackOnPropertySet;
2210   swig_callbackOnSizeSet = callbackOnSizeSet;
2211   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2212   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2213   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2214   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2215   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2216   swig_callbackOnRelayout = callbackOnRelayout;
2217   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2218   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2219   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2220   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2221   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2222   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2223   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2224   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2225   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2226   swig_callbackOnInitialize = callbackOnInitialize;
2227   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2228   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2229   swig_callbackOnStyleChange = callbackOnStyleChange;
2230   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2231   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2232   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2233   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2234   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2235   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2236   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2237   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2238   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2239   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2240   swig_callbackOnPinch = callbackOnPinch;
2241   swig_callbackOnPan = callbackOnPan;
2242   swig_callbackOnTap = callbackOnTap;
2243   swig_callbackOnLongPress = callbackOnLongPress;
2244   swig_callbackSignalConnected = callbackSignalConnected;
2245   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2246 }
2247
2248 void SwigDirector_ViewImpl::swig_init_callbacks() {
2249   swig_callbackOnStageConnection = 0;
2250   swig_callbackOnStageDisconnection = 0;
2251   swig_callbackOnChildAdd = 0;
2252   swig_callbackOnChildRemove = 0;
2253   swig_callbackOnPropertySet = 0;
2254   swig_callbackOnSizeSet = 0;
2255   swig_callbackOnSizeAnimation = 0;
2256   swig_callbackOnTouchEvent = 0;
2257   swig_callbackOnHoverEvent = 0;
2258   swig_callbackOnKeyEvent = 0;
2259   swig_callbackOnWheelEvent = 0;
2260   swig_callbackOnRelayout = 0;
2261   swig_callbackOnSetResizePolicy = 0;
2262   swig_callbackGetNaturalSize = 0;
2263   swig_callbackCalculateChildSize = 0;
2264   swig_callbackGetHeightForWidth = 0;
2265   swig_callbackGetWidthForHeight = 0;
2266   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2267   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2268   swig_callbackOnCalculateRelayoutSize = 0;
2269   swig_callbackOnLayoutNegotiated = 0;
2270   swig_callbackOnInitialize = 0;
2271   swig_callbackOnControlChildAdd = 0;
2272   swig_callbackOnControlChildRemove = 0;
2273   swig_callbackOnStyleChange = 0;
2274   swig_callbackOnAccessibilityActivated = 0;
2275   swig_callbackOnAccessibilityPan = 0;
2276   swig_callbackOnAccessibilityTouch = 0;
2277   swig_callbackOnAccessibilityValueChange = 0;
2278   swig_callbackOnAccessibilityZoom = 0;
2279   swig_callbackOnKeyInputFocusGained = 0;
2280   swig_callbackOnKeyInputFocusLost = 0;
2281   swig_callbackGetNextKeyboardFocusableActor = 0;
2282   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2283   swig_callbackOnKeyboardEnter = 0;
2284   swig_callbackOnPinch = 0;
2285   swig_callbackOnPan = 0;
2286   swig_callbackOnTap = 0;
2287   swig_callbackOnLongPress = 0;
2288   swig_callbackSignalConnected = 0;
2289   swig_callbackSignalDisconnected = 0;
2290 }
2291
2292 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2293   swig_init_callbacks();
2294 }
2295
2296 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2297
2298 }
2299
2300
2301 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2302   unsigned int c_result = SwigValueInit< unsigned int >() ;
2303   unsigned int jresult = 0 ;
2304
2305   if (!swig_callbackGetNumberOfItems) {
2306     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2307   } else {
2308     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2309     c_result = (unsigned int)jresult;
2310   }
2311   return c_result;
2312 }
2313
2314 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2315   Dali::Actor c_result ;
2316   void * jresult = 0 ;
2317   unsigned int jitemId  ;
2318
2319   if (!swig_callbackNewItem) {
2320     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2321   } else {
2322     jitemId = itemId;
2323     jresult = (void *) swig_callbackNewItem(jitemId);
2324     if (!jresult) {
2325       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2326       return c_result;
2327     }
2328     c_result = *(Dali::Actor *)jresult;
2329   }
2330   return c_result;
2331 }
2332
2333 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2334   unsigned int jitemId  ;
2335   void * jactor  ;
2336
2337   if (!swig_callbackItemReleased) {
2338     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2339     return;
2340   } else {
2341     jitemId = itemId;
2342     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2343     swig_callbackItemReleased(jitemId, jactor);
2344   }
2345 }
2346
2347 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2348   return Dali::Toolkit::ItemFactory::GetExtension();
2349 }
2350
2351 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2352   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2353   swig_callbackNewItem = callbackNewItem;
2354   swig_callbackItemReleased = callbackItemReleased;
2355 }
2356
2357 void SwigDirector_ItemFactory::swig_init_callbacks() {
2358   swig_callbackGetNumberOfItems = 0;
2359   swig_callbackNewItem = 0;
2360   swig_callbackItemReleased = 0;
2361 }
2362
2363
2364 #ifdef __cplusplus
2365 extern "C" {
2366 #endif
2367
2368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2369   void * jresult ;
2370   floatp *result = 0 ;
2371
2372   {
2373     try {
2374       result = (floatp *)new_floatp();
2375     } catch (std::out_of_range& e) {
2376       {
2377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2378       };
2379     } catch (std::exception& e) {
2380       {
2381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2382       };
2383     } catch (...) {
2384       {
2385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2386       };
2387     }
2388   }
2389   jresult = (void *)result;
2390   return jresult;
2391 }
2392
2393
2394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2395   floatp *arg1 = (floatp *) 0 ;
2396
2397   arg1 = (floatp *)jarg1;
2398   {
2399     try {
2400       delete_floatp(arg1);
2401     } catch (std::out_of_range& e) {
2402       {
2403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2404       };
2405     } catch (std::exception& e) {
2406       {
2407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2408       };
2409     } catch (...) {
2410       {
2411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2412       };
2413     }
2414   }
2415 }
2416
2417
2418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2419   floatp *arg1 = (floatp *) 0 ;
2420   float arg2 ;
2421
2422   arg1 = (floatp *)jarg1;
2423   arg2 = (float)jarg2;
2424   {
2425     try {
2426       floatp_assign(arg1,arg2);
2427     } catch (std::out_of_range& e) {
2428       {
2429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2430       };
2431     } catch (std::exception& e) {
2432       {
2433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2434       };
2435     } catch (...) {
2436       {
2437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2438       };
2439     }
2440   }
2441 }
2442
2443
2444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2445   float jresult ;
2446   floatp *arg1 = (floatp *) 0 ;
2447   float result;
2448
2449   arg1 = (floatp *)jarg1;
2450   {
2451     try {
2452       result = (float)floatp_value(arg1);
2453     } catch (std::out_of_range& e) {
2454       {
2455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2456       };
2457     } catch (std::exception& e) {
2458       {
2459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2460       };
2461     } catch (...) {
2462       {
2463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2464       };
2465     }
2466   }
2467   jresult = result;
2468   return jresult;
2469 }
2470
2471
2472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2473   void * jresult ;
2474   floatp *arg1 = (floatp *) 0 ;
2475   float *result = 0 ;
2476
2477   arg1 = (floatp *)jarg1;
2478   {
2479     try {
2480       result = (float *)floatp_cast(arg1);
2481     } catch (std::out_of_range& e) {
2482       {
2483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2484       };
2485     } catch (std::exception& e) {
2486       {
2487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2488       };
2489     } catch (...) {
2490       {
2491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2492       };
2493     }
2494   }
2495   jresult = (void *)result;
2496   return jresult;
2497 }
2498
2499
2500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2501   void * jresult ;
2502   float *arg1 = (float *) 0 ;
2503   floatp *result = 0 ;
2504
2505   arg1 = (float *)jarg1;
2506   {
2507     try {
2508       result = (floatp *)floatp_frompointer(arg1);
2509     } catch (std::out_of_range& e) {
2510       {
2511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2512       };
2513     } catch (std::exception& e) {
2514       {
2515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2516       };
2517     } catch (...) {
2518       {
2519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2520       };
2521     }
2522   }
2523   jresult = (void *)result;
2524   return jresult;
2525 }
2526
2527
2528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2529   void * jresult ;
2530   intp *result = 0 ;
2531
2532   {
2533     try {
2534       result = (intp *)new_intp();
2535     } catch (std::out_of_range& e) {
2536       {
2537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2538       };
2539     } catch (std::exception& e) {
2540       {
2541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2542       };
2543     } catch (...) {
2544       {
2545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2546       };
2547     }
2548   }
2549   jresult = (void *)result;
2550   return jresult;
2551 }
2552
2553
2554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2555   intp *arg1 = (intp *) 0 ;
2556
2557   arg1 = (intp *)jarg1;
2558   {
2559     try {
2560       delete_intp(arg1);
2561     } catch (std::out_of_range& e) {
2562       {
2563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2564       };
2565     } catch (std::exception& e) {
2566       {
2567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2568       };
2569     } catch (...) {
2570       {
2571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2572       };
2573     }
2574   }
2575 }
2576
2577
2578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2579   intp *arg1 = (intp *) 0 ;
2580   int arg2 ;
2581
2582   arg1 = (intp *)jarg1;
2583   arg2 = (int)jarg2;
2584   {
2585     try {
2586       intp_assign(arg1,arg2);
2587     } catch (std::out_of_range& e) {
2588       {
2589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2590       };
2591     } catch (std::exception& e) {
2592       {
2593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2594       };
2595     } catch (...) {
2596       {
2597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2598       };
2599     }
2600   }
2601 }
2602
2603
2604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2605   int jresult ;
2606   intp *arg1 = (intp *) 0 ;
2607   int result;
2608
2609   arg1 = (intp *)jarg1;
2610   {
2611     try {
2612       result = (int)intp_value(arg1);
2613     } catch (std::out_of_range& e) {
2614       {
2615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2616       };
2617     } catch (std::exception& e) {
2618       {
2619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2620       };
2621     } catch (...) {
2622       {
2623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2624       };
2625     }
2626   }
2627   jresult = result;
2628   return jresult;
2629 }
2630
2631
2632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2633   void * jresult ;
2634   intp *arg1 = (intp *) 0 ;
2635   int *result = 0 ;
2636
2637   arg1 = (intp *)jarg1;
2638   {
2639     try {
2640       result = (int *)intp_cast(arg1);
2641     } catch (std::out_of_range& e) {
2642       {
2643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2644       };
2645     } catch (std::exception& e) {
2646       {
2647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2648       };
2649     } catch (...) {
2650       {
2651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2652       };
2653     }
2654   }
2655   jresult = (void *)result;
2656   return jresult;
2657 }
2658
2659
2660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2661   void * jresult ;
2662   int *arg1 = (int *) 0 ;
2663   intp *result = 0 ;
2664
2665   arg1 = (int *)jarg1;
2666   {
2667     try {
2668       result = (intp *)intp_frompointer(arg1);
2669     } catch (std::out_of_range& e) {
2670       {
2671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2672       };
2673     } catch (std::exception& e) {
2674       {
2675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2676       };
2677     } catch (...) {
2678       {
2679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2680       };
2681     }
2682   }
2683   jresult = (void *)result;
2684   return jresult;
2685 }
2686
2687
2688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2689   void * jresult ;
2690   doublep *result = 0 ;
2691
2692   {
2693     try {
2694       result = (doublep *)new_doublep();
2695     } catch (std::out_of_range& e) {
2696       {
2697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2698       };
2699     } catch (std::exception& e) {
2700       {
2701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2702       };
2703     } catch (...) {
2704       {
2705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2706       };
2707     }
2708   }
2709   jresult = (void *)result;
2710   return jresult;
2711 }
2712
2713
2714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2715   doublep *arg1 = (doublep *) 0 ;
2716
2717   arg1 = (doublep *)jarg1;
2718   {
2719     try {
2720       delete_doublep(arg1);
2721     } catch (std::out_of_range& e) {
2722       {
2723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2724       };
2725     } catch (std::exception& e) {
2726       {
2727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2728       };
2729     } catch (...) {
2730       {
2731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2732       };
2733     }
2734   }
2735 }
2736
2737
2738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2739   doublep *arg1 = (doublep *) 0 ;
2740   double arg2 ;
2741
2742   arg1 = (doublep *)jarg1;
2743   arg2 = (double)jarg2;
2744   {
2745     try {
2746       doublep_assign(arg1,arg2);
2747     } catch (std::out_of_range& e) {
2748       {
2749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2750       };
2751     } catch (std::exception& e) {
2752       {
2753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2754       };
2755     } catch (...) {
2756       {
2757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2758       };
2759     }
2760   }
2761 }
2762
2763
2764 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2765   double jresult ;
2766   doublep *arg1 = (doublep *) 0 ;
2767   double result;
2768
2769   arg1 = (doublep *)jarg1;
2770   {
2771     try {
2772       result = (double)doublep_value(arg1);
2773     } catch (std::out_of_range& e) {
2774       {
2775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2776       };
2777     } catch (std::exception& e) {
2778       {
2779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2780       };
2781     } catch (...) {
2782       {
2783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2784       };
2785     }
2786   }
2787   jresult = result;
2788   return jresult;
2789 }
2790
2791
2792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2793   void * jresult ;
2794   doublep *arg1 = (doublep *) 0 ;
2795   double *result = 0 ;
2796
2797   arg1 = (doublep *)jarg1;
2798   {
2799     try {
2800       result = (double *)doublep_cast(arg1);
2801     } catch (std::out_of_range& e) {
2802       {
2803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2804       };
2805     } catch (std::exception& e) {
2806       {
2807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2808       };
2809     } catch (...) {
2810       {
2811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2812       };
2813     }
2814   }
2815   jresult = (void *)result;
2816   return jresult;
2817 }
2818
2819
2820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2821   void * jresult ;
2822   double *arg1 = (double *) 0 ;
2823   doublep *result = 0 ;
2824
2825   arg1 = (double *)jarg1;
2826   {
2827     try {
2828       result = (doublep *)doublep_frompointer(arg1);
2829     } catch (std::out_of_range& e) {
2830       {
2831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2832       };
2833     } catch (std::exception& e) {
2834       {
2835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2836       };
2837     } catch (...) {
2838       {
2839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2840       };
2841     }
2842   }
2843   jresult = (void *)result;
2844   return jresult;
2845 }
2846
2847
2848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2849   void * jresult ;
2850   uintp *result = 0 ;
2851
2852   {
2853     try {
2854       result = (uintp *)new_uintp();
2855     } catch (std::out_of_range& e) {
2856       {
2857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2858       };
2859     } catch (std::exception& e) {
2860       {
2861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2862       };
2863     } catch (...) {
2864       {
2865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2866       };
2867     }
2868   }
2869   jresult = (void *)result;
2870   return jresult;
2871 }
2872
2873
2874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2875   uintp *arg1 = (uintp *) 0 ;
2876
2877   arg1 = (uintp *)jarg1;
2878   {
2879     try {
2880       delete_uintp(arg1);
2881     } catch (std::out_of_range& e) {
2882       {
2883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2884       };
2885     } catch (std::exception& e) {
2886       {
2887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2888       };
2889     } catch (...) {
2890       {
2891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2892       };
2893     }
2894   }
2895 }
2896
2897
2898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2899   uintp *arg1 = (uintp *) 0 ;
2900   unsigned int arg2 ;
2901
2902   arg1 = (uintp *)jarg1;
2903   arg2 = (unsigned int)jarg2;
2904   {
2905     try {
2906       uintp_assign(arg1,arg2);
2907     } catch (std::out_of_range& e) {
2908       {
2909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2910       };
2911     } catch (std::exception& e) {
2912       {
2913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2914       };
2915     } catch (...) {
2916       {
2917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2918       };
2919     }
2920   }
2921 }
2922
2923
2924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
2925   unsigned int jresult ;
2926   uintp *arg1 = (uintp *) 0 ;
2927   unsigned int result;
2928
2929   arg1 = (uintp *)jarg1;
2930   {
2931     try {
2932       result = (unsigned int)uintp_value(arg1);
2933     } catch (std::out_of_range& e) {
2934       {
2935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2936       };
2937     } catch (std::exception& e) {
2938       {
2939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2940       };
2941     } catch (...) {
2942       {
2943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2944       };
2945     }
2946   }
2947   jresult = result;
2948   return jresult;
2949 }
2950
2951
2952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
2953   void * jresult ;
2954   uintp *arg1 = (uintp *) 0 ;
2955   unsigned int *result = 0 ;
2956
2957   arg1 = (uintp *)jarg1;
2958   {
2959     try {
2960       result = (unsigned int *)uintp_cast(arg1);
2961     } catch (std::out_of_range& e) {
2962       {
2963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2964       };
2965     } catch (std::exception& e) {
2966       {
2967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2968       };
2969     } catch (...) {
2970       {
2971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2972       };
2973     }
2974   }
2975   jresult = (void *)result;
2976   return jresult;
2977 }
2978
2979
2980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
2981   void * jresult ;
2982   unsigned int *arg1 = (unsigned int *) 0 ;
2983   uintp *result = 0 ;
2984
2985   arg1 = (unsigned int *)jarg1;
2986   {
2987     try {
2988       result = (uintp *)uintp_frompointer(arg1);
2989     } catch (std::out_of_range& e) {
2990       {
2991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2992       };
2993     } catch (std::exception& e) {
2994       {
2995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2996       };
2997     } catch (...) {
2998       {
2999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3000       };
3001     }
3002   }
3003   jresult = (void *)result;
3004   return jresult;
3005 }
3006
3007
3008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3009   void * jresult ;
3010   ushortp *result = 0 ;
3011
3012   {
3013     try {
3014       result = (ushortp *)new_ushortp();
3015     } catch (std::out_of_range& e) {
3016       {
3017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3018       };
3019     } catch (std::exception& e) {
3020       {
3021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3022       };
3023     } catch (...) {
3024       {
3025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3026       };
3027     }
3028   }
3029   jresult = (void *)result;
3030   return jresult;
3031 }
3032
3033
3034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3035   ushortp *arg1 = (ushortp *) 0 ;
3036
3037   arg1 = (ushortp *)jarg1;
3038   {
3039     try {
3040       delete_ushortp(arg1);
3041     } catch (std::out_of_range& e) {
3042       {
3043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3044       };
3045     } catch (std::exception& e) {
3046       {
3047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3048       };
3049     } catch (...) {
3050       {
3051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3052       };
3053     }
3054   }
3055 }
3056
3057
3058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3059   ushortp *arg1 = (ushortp *) 0 ;
3060   unsigned short arg2 ;
3061
3062   arg1 = (ushortp *)jarg1;
3063   arg2 = (unsigned short)jarg2;
3064   {
3065     try {
3066       ushortp_assign(arg1,arg2);
3067     } catch (std::out_of_range& e) {
3068       {
3069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3070       };
3071     } catch (std::exception& e) {
3072       {
3073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3074       };
3075     } catch (...) {
3076       {
3077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3078       };
3079     }
3080   }
3081 }
3082
3083
3084 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3085   unsigned short jresult ;
3086   ushortp *arg1 = (ushortp *) 0 ;
3087   unsigned short result;
3088
3089   arg1 = (ushortp *)jarg1;
3090   {
3091     try {
3092       result = (unsigned short)ushortp_value(arg1);
3093     } catch (std::out_of_range& e) {
3094       {
3095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3096       };
3097     } catch (std::exception& e) {
3098       {
3099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3100       };
3101     } catch (...) {
3102       {
3103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3104       };
3105     }
3106   }
3107   jresult = result;
3108   return jresult;
3109 }
3110
3111
3112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3113   void * jresult ;
3114   ushortp *arg1 = (ushortp *) 0 ;
3115   unsigned short *result = 0 ;
3116
3117   arg1 = (ushortp *)jarg1;
3118   {
3119     try {
3120       result = (unsigned short *)ushortp_cast(arg1);
3121     } catch (std::out_of_range& e) {
3122       {
3123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3124       };
3125     } catch (std::exception& e) {
3126       {
3127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3128       };
3129     } catch (...) {
3130       {
3131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3132       };
3133     }
3134   }
3135   jresult = (void *)result;
3136   return jresult;
3137 }
3138
3139
3140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3141   void * jresult ;
3142   unsigned short *arg1 = (unsigned short *) 0 ;
3143   ushortp *result = 0 ;
3144
3145   arg1 = (unsigned short *)jarg1;
3146   {
3147     try {
3148       result = (ushortp *)ushortp_frompointer(arg1);
3149     } catch (std::out_of_range& e) {
3150       {
3151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3152       };
3153     } catch (std::exception& e) {
3154       {
3155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3156       };
3157     } catch (...) {
3158       {
3159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3160       };
3161     }
3162   }
3163   jresult = (void *)result;
3164   return jresult;
3165 }
3166
3167
3168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3169   unsigned int jresult ;
3170   int arg1 ;
3171   unsigned int result;
3172
3173   arg1 = (int)jarg1;
3174   {
3175     try {
3176       result = (unsigned int)int_to_uint(arg1);
3177     } catch (std::out_of_range& e) {
3178       {
3179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3180       };
3181     } catch (std::exception& e) {
3182       {
3183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3184       };
3185     } catch (...) {
3186       {
3187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3188       };
3189     }
3190   }
3191   jresult = result;
3192   return jresult;
3193 }
3194
3195
3196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3197   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3198
3199   arg1 = (Dali::RefObject *)jarg1;
3200   {
3201     try {
3202       (arg1)->Reference();
3203     } catch (std::out_of_range& e) {
3204       {
3205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3206       };
3207     } catch (std::exception& e) {
3208       {
3209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3210       };
3211     } catch (...) {
3212       {
3213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3214       };
3215     }
3216   }
3217 }
3218
3219
3220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3221   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3222
3223   arg1 = (Dali::RefObject *)jarg1;
3224   {
3225     try {
3226       (arg1)->Unreference();
3227     } catch (std::out_of_range& e) {
3228       {
3229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3230       };
3231     } catch (std::exception& e) {
3232       {
3233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3234       };
3235     } catch (...) {
3236       {
3237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3238       };
3239     }
3240   }
3241 }
3242
3243
3244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3245   int jresult ;
3246   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3247   int result;
3248
3249   arg1 = (Dali::RefObject *)jarg1;
3250   {
3251     try {
3252       result = (int)(arg1)->ReferenceCount();
3253     } catch (std::out_of_range& e) {
3254       {
3255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3256       };
3257     } catch (std::exception& e) {
3258       {
3259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3260       };
3261     } catch (...) {
3262       {
3263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3264       };
3265     }
3266   }
3267   jresult = result;
3268   return jresult;
3269 }
3270
3271
3272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3273   void * jresult ;
3274   Dali::Any *result = 0 ;
3275
3276   {
3277     try {
3278       result = (Dali::Any *)new Dali::Any();
3279     } catch (std::out_of_range& e) {
3280       {
3281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3282       };
3283     } catch (std::exception& e) {
3284       {
3285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3286       };
3287     } catch (...) {
3288       {
3289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3290       };
3291     }
3292   }
3293   jresult = (void *)result;
3294   return jresult;
3295 }
3296
3297
3298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3299   Dali::Any *arg1 = (Dali::Any *) 0 ;
3300
3301   arg1 = (Dali::Any *)jarg1;
3302   {
3303     try {
3304       delete arg1;
3305     } catch (std::out_of_range& e) {
3306       {
3307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3308       };
3309     } catch (std::exception& e) {
3310       {
3311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3312       };
3313     } catch (...) {
3314       {
3315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3316       };
3317     }
3318   }
3319 }
3320
3321
3322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3323   char *arg1 = (char *) 0 ;
3324
3325   arg1 = (char *)jarg1;
3326   {
3327     try {
3328       Dali::Any::AssertAlways((char const *)arg1);
3329     } catch (std::out_of_range& e) {
3330       {
3331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3332       };
3333     } catch (std::exception& e) {
3334       {
3335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3336       };
3337     } catch (...) {
3338       {
3339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3340       };
3341     }
3342   }
3343 }
3344
3345
3346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3347   void * jresult ;
3348   Dali::Any *arg1 = 0 ;
3349   Dali::Any *result = 0 ;
3350
3351   arg1 = (Dali::Any *)jarg1;
3352   if (!arg1) {
3353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3354     return 0;
3355   }
3356   {
3357     try {
3358       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3359     } catch (std::out_of_range& e) {
3360       {
3361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3362       };
3363     } catch (std::exception& e) {
3364       {
3365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3366       };
3367     } catch (...) {
3368       {
3369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3370       };
3371     }
3372   }
3373   jresult = (void *)result;
3374   return jresult;
3375 }
3376
3377
3378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3379   void * jresult ;
3380   Dali::Any *arg1 = (Dali::Any *) 0 ;
3381   Dali::Any *arg2 = 0 ;
3382   Dali::Any *result = 0 ;
3383
3384   arg1 = (Dali::Any *)jarg1;
3385   arg2 = (Dali::Any *)jarg2;
3386   if (!arg2) {
3387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3388     return 0;
3389   }
3390   {
3391     try {
3392       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3393     } catch (std::out_of_range& e) {
3394       {
3395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3396       };
3397     } catch (std::exception& e) {
3398       {
3399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3400       };
3401     } catch (...) {
3402       {
3403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3404       };
3405     }
3406   }
3407   jresult = (void *)result;
3408   return jresult;
3409 }
3410
3411
3412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3413   void * jresult ;
3414   Dali::Any *arg1 = (Dali::Any *) 0 ;
3415   std::type_info *result = 0 ;
3416
3417   arg1 = (Dali::Any *)jarg1;
3418   {
3419     try {
3420       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3421     } catch (std::out_of_range& e) {
3422       {
3423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3424       };
3425     } catch (std::exception& e) {
3426       {
3427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3428       };
3429     } catch (...) {
3430       {
3431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3432       };
3433     }
3434   }
3435   jresult = (void *)result;
3436   return jresult;
3437 }
3438
3439
3440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3441   unsigned int jresult ;
3442   Dali::Any *arg1 = (Dali::Any *) 0 ;
3443   bool result;
3444
3445   arg1 = (Dali::Any *)jarg1;
3446   {
3447     try {
3448       result = (bool)((Dali::Any const *)arg1)->Empty();
3449     } catch (std::out_of_range& e) {
3450       {
3451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3452       };
3453     } catch (std::exception& e) {
3454       {
3455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3456       };
3457     } catch (...) {
3458       {
3459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3460       };
3461     }
3462   }
3463   jresult = result;
3464   return jresult;
3465 }
3466
3467
3468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3469   void * jresult ;
3470   std::type_info *arg1 = 0 ;
3471   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3472   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3473   Dali::Any::AnyContainerBase *result = 0 ;
3474
3475   arg1 = (std::type_info *)jarg1;
3476   if (!arg1) {
3477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3478     return 0;
3479   }
3480   arg2 = (Dali::Any::CloneFunc)jarg2;
3481   arg3 = (Dali::Any::DeleteFunc)jarg3;
3482   {
3483     try {
3484       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3485     } catch (std::out_of_range& e) {
3486       {
3487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3488       };
3489     } catch (std::exception& e) {
3490       {
3491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3492       };
3493     } catch (...) {
3494       {
3495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3496       };
3497     }
3498   }
3499   jresult = (void *)result;
3500   return jresult;
3501 }
3502
3503
3504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3505   void * jresult ;
3506   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3507   std::type_info *result = 0 ;
3508
3509   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3510   {
3511     try {
3512       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3513     } catch (std::out_of_range& e) {
3514       {
3515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3516       };
3517     } catch (std::exception& e) {
3518       {
3519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3520       };
3521     } catch (...) {
3522       {
3523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3524       };
3525     }
3526   }
3527   jresult = (void *)result;
3528   return jresult;
3529 }
3530
3531
3532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3533   void * jresult ;
3534   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3535   ::std::type_info *result = 0 ;
3536
3537   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3538   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3539   jresult = (void *)result;
3540   return jresult;
3541 }
3542
3543
3544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3545   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3546   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3547
3548   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3549   arg2 = (Dali::Any::CloneFunc)jarg2;
3550   if (arg1) (arg1)->mCloneFunc = arg2;
3551 }
3552
3553
3554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3555   void * jresult ;
3556   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3557   Dali::Any::CloneFunc result;
3558
3559   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3560   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3561   jresult = (void *)result;
3562   return jresult;
3563 }
3564
3565
3566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3567   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3568   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3569
3570   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3571   arg2 = (Dali::Any::DeleteFunc)jarg2;
3572   if (arg1) (arg1)->mDeleteFunc = arg2;
3573 }
3574
3575
3576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3577   void * jresult ;
3578   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3579   Dali::Any::DeleteFunc result;
3580
3581   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3582   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3583   jresult = (void *)result;
3584   return jresult;
3585 }
3586
3587
3588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3589   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3590
3591   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3592   {
3593     try {
3594       delete arg1;
3595     } catch (std::out_of_range& e) {
3596       {
3597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3598       };
3599     } catch (std::exception& e) {
3600       {
3601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3602       };
3603     } catch (...) {
3604       {
3605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3606       };
3607     }
3608   }
3609 }
3610
3611
3612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3613   Dali::Any *arg1 = (Dali::Any *) 0 ;
3614   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3615
3616   arg1 = (Dali::Any *)jarg1;
3617   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3618   if (arg1) (arg1)->mContainer = arg2;
3619 }
3620
3621
3622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3623   void * jresult ;
3624   Dali::Any *arg1 = (Dali::Any *) 0 ;
3625   Dali::Any::AnyContainerBase *result = 0 ;
3626
3627   arg1 = (Dali::Any *)jarg1;
3628   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3629   jresult = (void *)result;
3630   return jresult;
3631 }
3632
3633
3634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3635   char *arg1 = (char *) 0 ;
3636   char *arg2 = (char *) 0 ;
3637
3638   arg1 = (char *)jarg1;
3639   arg2 = (char *)jarg2;
3640   {
3641     try {
3642       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3643     } catch (std::out_of_range& e) {
3644       {
3645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3646       };
3647     } catch (std::exception& e) {
3648       {
3649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3650       };
3651     } catch (...) {
3652       {
3653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3654       };
3655     }
3656   }
3657 }
3658
3659
3660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3661   void * jresult ;
3662   char *arg1 = (char *) 0 ;
3663   char *arg2 = (char *) 0 ;
3664   Dali::DaliException *result = 0 ;
3665
3666   arg1 = (char *)jarg1;
3667   arg2 = (char *)jarg2;
3668   {
3669     try {
3670       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3671     } catch (std::out_of_range& e) {
3672       {
3673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3674       };
3675     } catch (std::exception& e) {
3676       {
3677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3678       };
3679     } catch (...) {
3680       {
3681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3682       };
3683     }
3684   }
3685   jresult = (void *)result;
3686   return jresult;
3687 }
3688
3689
3690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3691   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3692   char *arg2 = (char *) 0 ;
3693
3694   arg1 = (Dali::DaliException *)jarg1;
3695   arg2 = (char *)jarg2;
3696   {
3697     if (arg2) {
3698       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3699       strcpy((char *)arg1->location, (const char *)arg2);
3700     } else {
3701       arg1->location = 0;
3702     }
3703   }
3704 }
3705
3706
3707 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3708   char * jresult ;
3709   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3710   char *result = 0 ;
3711
3712   arg1 = (Dali::DaliException *)jarg1;
3713   result = (char *) ((arg1)->location);
3714   jresult = SWIG_csharp_string_callback((const char *)result);
3715   return jresult;
3716 }
3717
3718
3719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3720   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3721   char *arg2 = (char *) 0 ;
3722
3723   arg1 = (Dali::DaliException *)jarg1;
3724   arg2 = (char *)jarg2;
3725   {
3726     if (arg2) {
3727       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3728       strcpy((char *)arg1->condition, (const char *)arg2);
3729     } else {
3730       arg1->condition = 0;
3731     }
3732   }
3733 }
3734
3735
3736 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3737   char * jresult ;
3738   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3739   char *result = 0 ;
3740
3741   arg1 = (Dali::DaliException *)jarg1;
3742   result = (char *) ((arg1)->condition);
3743   jresult = SWIG_csharp_string_callback((const char *)result);
3744   return jresult;
3745 }
3746
3747
3748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3749   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3750
3751   arg1 = (Dali::DaliException *)jarg1;
3752   {
3753     try {
3754       delete arg1;
3755     } catch (std::out_of_range& e) {
3756       {
3757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3758       };
3759     } catch (std::exception& e) {
3760       {
3761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3762       };
3763     } catch (...) {
3764       {
3765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3766       };
3767     }
3768   }
3769 }
3770
3771
3772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3773   void * jresult ;
3774   Dali::Vector2 *result = 0 ;
3775
3776   {
3777     try {
3778       result = (Dali::Vector2 *)new Dali::Vector2();
3779     } catch (std::out_of_range& e) {
3780       {
3781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3782       };
3783     } catch (std::exception& e) {
3784       {
3785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3786       };
3787     } catch (...) {
3788       {
3789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3790       };
3791     }
3792   }
3793   jresult = (void *)result;
3794   return jresult;
3795 }
3796
3797
3798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3799   void * jresult ;
3800   float arg1 ;
3801   float arg2 ;
3802   Dali::Vector2 *result = 0 ;
3803
3804   arg1 = (float)jarg1;
3805   arg2 = (float)jarg2;
3806   {
3807     try {
3808       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3809     } catch (std::out_of_range& e) {
3810       {
3811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3812       };
3813     } catch (std::exception& e) {
3814       {
3815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3816       };
3817     } catch (...) {
3818       {
3819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3820       };
3821     }
3822   }
3823   jresult = (void *)result;
3824   return jresult;
3825 }
3826
3827
3828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3829   void * jresult ;
3830   float *arg1 = (float *) 0 ;
3831   Dali::Vector2 *result = 0 ;
3832
3833   arg1 = jarg1;
3834   {
3835     try {
3836       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3837     } catch (std::out_of_range& e) {
3838       {
3839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3840       };
3841     } catch (std::exception& e) {
3842       {
3843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3844       };
3845     } catch (...) {
3846       {
3847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3848       };
3849     }
3850   }
3851   jresult = (void *)result;
3852
3853
3854   return jresult;
3855 }
3856
3857
3858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3859   void * jresult ;
3860   Dali::Vector3 *arg1 = 0 ;
3861   Dali::Vector2 *result = 0 ;
3862
3863   arg1 = (Dali::Vector3 *)jarg1;
3864   if (!arg1) {
3865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3866     return 0;
3867   }
3868   {
3869     try {
3870       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3871     } catch (std::out_of_range& e) {
3872       {
3873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3874       };
3875     } catch (std::exception& e) {
3876       {
3877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3878       };
3879     } catch (...) {
3880       {
3881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3882       };
3883     }
3884   }
3885   jresult = (void *)result;
3886   return jresult;
3887 }
3888
3889
3890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3891   void * jresult ;
3892   Dali::Vector4 *arg1 = 0 ;
3893   Dali::Vector2 *result = 0 ;
3894
3895   arg1 = (Dali::Vector4 *)jarg1;
3896   if (!arg1) {
3897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3898     return 0;
3899   }
3900   {
3901     try {
3902       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3903     } catch (std::out_of_range& e) {
3904       {
3905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3906       };
3907     } catch (std::exception& e) {
3908       {
3909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3910       };
3911     } catch (...) {
3912       {
3913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3914       };
3915     }
3916   }
3917   jresult = (void *)result;
3918   return jresult;
3919 }
3920
3921
3922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
3923   void * jresult ;
3924   Dali::Vector2 *result = 0 ;
3925
3926   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
3927   jresult = (void *)result;
3928   return jresult;
3929 }
3930
3931
3932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
3933   void * jresult ;
3934   Dali::Vector2 *result = 0 ;
3935
3936   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
3937   jresult = (void *)result;
3938   return jresult;
3939 }
3940
3941
3942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
3943   void * jresult ;
3944   Dali::Vector2 *result = 0 ;
3945
3946   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
3947   jresult = (void *)result;
3948   return jresult;
3949 }
3950
3951
3952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
3953   void * jresult ;
3954   Dali::Vector2 *result = 0 ;
3955
3956   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
3957   jresult = (void *)result;
3958   return jresult;
3959 }
3960
3961
3962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
3963   void * jresult ;
3964   Dali::Vector2 *result = 0 ;
3965
3966   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
3967   jresult = (void *)result;
3968   return jresult;
3969 }
3970
3971
3972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
3973   void * jresult ;
3974   Dali::Vector2 *result = 0 ;
3975
3976   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
3977   jresult = (void *)result;
3978   return jresult;
3979 }
3980
3981
3982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
3983   void * jresult ;
3984   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
3985   float *arg2 = (float *) 0 ;
3986   Dali::Vector2 *result = 0 ;
3987
3988   arg1 = (Dali::Vector2 *)jarg1;
3989   arg2 = jarg2;
3990   {
3991     try {
3992       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
3993     } catch (std::out_of_range& e) {
3994       {
3995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3996       };
3997     } catch (std::exception& e) {
3998       {
3999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4000       };
4001     } catch (...) {
4002       {
4003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4004       };
4005     }
4006   }
4007   jresult = (void *)result;
4008
4009
4010   return jresult;
4011 }
4012
4013
4014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4015   void * jresult ;
4016   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4017   Dali::Vector3 *arg2 = 0 ;
4018   Dali::Vector2 *result = 0 ;
4019
4020   arg1 = (Dali::Vector2 *)jarg1;
4021   arg2 = (Dali::Vector3 *)jarg2;
4022   if (!arg2) {
4023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4024     return 0;
4025   }
4026   {
4027     try {
4028       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4029     } catch (std::out_of_range& e) {
4030       {
4031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4032       };
4033     } catch (std::exception& e) {
4034       {
4035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4036       };
4037     } catch (...) {
4038       {
4039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4040       };
4041     }
4042   }
4043   jresult = (void *)result;
4044   return jresult;
4045 }
4046
4047
4048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4049   void * jresult ;
4050   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4051   Dali::Vector4 *arg2 = 0 ;
4052   Dali::Vector2 *result = 0 ;
4053
4054   arg1 = (Dali::Vector2 *)jarg1;
4055   arg2 = (Dali::Vector4 *)jarg2;
4056   if (!arg2) {
4057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4058     return 0;
4059   }
4060   {
4061     try {
4062       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4063     } catch (std::out_of_range& e) {
4064       {
4065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4066       };
4067     } catch (std::exception& e) {
4068       {
4069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4070       };
4071     } catch (...) {
4072       {
4073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4074       };
4075     }
4076   }
4077   jresult = (void *)result;
4078   return jresult;
4079 }
4080
4081
4082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4083   void * jresult ;
4084   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4085   Dali::Vector2 *arg2 = 0 ;
4086   Dali::Vector2 result;
4087
4088   arg1 = (Dali::Vector2 *)jarg1;
4089   arg2 = (Dali::Vector2 *)jarg2;
4090   if (!arg2) {
4091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4092     return 0;
4093   }
4094   {
4095     try {
4096       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4097     } catch (std::out_of_range& e) {
4098       {
4099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4100       };
4101     } catch (std::exception& e) {
4102       {
4103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4104       };
4105     } catch (...) {
4106       {
4107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4108       };
4109     }
4110   }
4111   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4112   return jresult;
4113 }
4114
4115
4116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4117   void * jresult ;
4118   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4119   Dali::Vector2 *arg2 = 0 ;
4120   Dali::Vector2 *result = 0 ;
4121
4122   arg1 = (Dali::Vector2 *)jarg1;
4123   arg2 = (Dali::Vector2 *)jarg2;
4124   if (!arg2) {
4125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4126     return 0;
4127   }
4128   {
4129     try {
4130       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4131     } catch (std::out_of_range& e) {
4132       {
4133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4134       };
4135     } catch (std::exception& e) {
4136       {
4137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4138       };
4139     } catch (...) {
4140       {
4141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4142       };
4143     }
4144   }
4145   jresult = (void *)result;
4146   return jresult;
4147 }
4148
4149
4150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4151   void * jresult ;
4152   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4153   Dali::Vector2 *arg2 = 0 ;
4154   Dali::Vector2 result;
4155
4156   arg1 = (Dali::Vector2 *)jarg1;
4157   arg2 = (Dali::Vector2 *)jarg2;
4158   if (!arg2) {
4159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4160     return 0;
4161   }
4162   {
4163     try {
4164       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4165     } catch (std::out_of_range& e) {
4166       {
4167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4168       };
4169     } catch (std::exception& e) {
4170       {
4171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4172       };
4173     } catch (...) {
4174       {
4175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4176       };
4177     }
4178   }
4179   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4180   return jresult;
4181 }
4182
4183
4184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4185   void * jresult ;
4186   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4187   Dali::Vector2 *arg2 = 0 ;
4188   Dali::Vector2 *result = 0 ;
4189
4190   arg1 = (Dali::Vector2 *)jarg1;
4191   arg2 = (Dali::Vector2 *)jarg2;
4192   if (!arg2) {
4193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4194     return 0;
4195   }
4196   {
4197     try {
4198       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4199     } catch (std::out_of_range& e) {
4200       {
4201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4202       };
4203     } catch (std::exception& e) {
4204       {
4205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4206       };
4207     } catch (...) {
4208       {
4209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4210       };
4211     }
4212   }
4213   jresult = (void *)result;
4214   return jresult;
4215 }
4216
4217
4218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4219   void * jresult ;
4220   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4221   Dali::Vector2 *arg2 = 0 ;
4222   Dali::Vector2 result;
4223
4224   arg1 = (Dali::Vector2 *)jarg1;
4225   arg2 = (Dali::Vector2 *)jarg2;
4226   if (!arg2) {
4227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4228     return 0;
4229   }
4230   {
4231     try {
4232       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4233     } catch (std::out_of_range& e) {
4234       {
4235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4236       };
4237     } catch (std::exception& e) {
4238       {
4239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4240       };
4241     } catch (...) {
4242       {
4243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4244       };
4245     }
4246   }
4247   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4248   return jresult;
4249 }
4250
4251
4252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4253   void * jresult ;
4254   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4255   float arg2 ;
4256   Dali::Vector2 result;
4257
4258   arg1 = (Dali::Vector2 *)jarg1;
4259   arg2 = (float)jarg2;
4260   {
4261     try {
4262       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4263     } catch (std::out_of_range& e) {
4264       {
4265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4266       };
4267     } catch (std::exception& e) {
4268       {
4269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4270       };
4271     } catch (...) {
4272       {
4273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4274       };
4275     }
4276   }
4277   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4278   return jresult;
4279 }
4280
4281
4282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4283   void * jresult ;
4284   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4285   Dali::Vector2 *arg2 = 0 ;
4286   Dali::Vector2 *result = 0 ;
4287
4288   arg1 = (Dali::Vector2 *)jarg1;
4289   arg2 = (Dali::Vector2 *)jarg2;
4290   if (!arg2) {
4291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4292     return 0;
4293   }
4294   {
4295     try {
4296       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4297     } catch (std::out_of_range& e) {
4298       {
4299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4300       };
4301     } catch (std::exception& e) {
4302       {
4303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4304       };
4305     } catch (...) {
4306       {
4307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4308       };
4309     }
4310   }
4311   jresult = (void *)result;
4312   return jresult;
4313 }
4314
4315
4316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4317   void * jresult ;
4318   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4319   float arg2 ;
4320   Dali::Vector2 *result = 0 ;
4321
4322   arg1 = (Dali::Vector2 *)jarg1;
4323   arg2 = (float)jarg2;
4324   {
4325     try {
4326       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4327     } catch (std::out_of_range& e) {
4328       {
4329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4330       };
4331     } catch (std::exception& e) {
4332       {
4333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4334       };
4335     } catch (...) {
4336       {
4337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4338       };
4339     }
4340   }
4341   jresult = (void *)result;
4342   return jresult;
4343 }
4344
4345
4346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4347   void * jresult ;
4348   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4349   Dali::Vector2 *arg2 = 0 ;
4350   Dali::Vector2 result;
4351
4352   arg1 = (Dali::Vector2 *)jarg1;
4353   arg2 = (Dali::Vector2 *)jarg2;
4354   if (!arg2) {
4355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4356     return 0;
4357   }
4358   {
4359     try {
4360       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4361     } catch (std::out_of_range& e) {
4362       {
4363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4364       };
4365     } catch (std::exception& e) {
4366       {
4367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4368       };
4369     } catch (...) {
4370       {
4371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4372       };
4373     }
4374   }
4375   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4376   return jresult;
4377 }
4378
4379
4380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4381   void * jresult ;
4382   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4383   float arg2 ;
4384   Dali::Vector2 result;
4385
4386   arg1 = (Dali::Vector2 *)jarg1;
4387   arg2 = (float)jarg2;
4388   {
4389     try {
4390       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4391     } catch (std::out_of_range& e) {
4392       {
4393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4394       };
4395     } catch (std::exception& e) {
4396       {
4397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4398       };
4399     } catch (...) {
4400       {
4401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4402       };
4403     }
4404   }
4405   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4406   return jresult;
4407 }
4408
4409
4410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4411   void * jresult ;
4412   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4413   Dali::Vector2 *arg2 = 0 ;
4414   Dali::Vector2 *result = 0 ;
4415
4416   arg1 = (Dali::Vector2 *)jarg1;
4417   arg2 = (Dali::Vector2 *)jarg2;
4418   if (!arg2) {
4419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4420     return 0;
4421   }
4422   {
4423     try {
4424       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4425     } catch (std::out_of_range& e) {
4426       {
4427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4428       };
4429     } catch (std::exception& e) {
4430       {
4431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4432       };
4433     } catch (...) {
4434       {
4435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4436       };
4437     }
4438   }
4439   jresult = (void *)result;
4440   return jresult;
4441 }
4442
4443
4444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4445   void * jresult ;
4446   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4447   float arg2 ;
4448   Dali::Vector2 *result = 0 ;
4449
4450   arg1 = (Dali::Vector2 *)jarg1;
4451   arg2 = (float)jarg2;
4452   {
4453     try {
4454       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4455     } catch (std::out_of_range& e) {
4456       {
4457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4458       };
4459     } catch (std::exception& e) {
4460       {
4461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4462       };
4463     } catch (...) {
4464       {
4465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4466       };
4467     }
4468   }
4469   jresult = (void *)result;
4470   return jresult;
4471 }
4472
4473
4474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4475   void * jresult ;
4476   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4477   Dali::Vector2 result;
4478
4479   arg1 = (Dali::Vector2 *)jarg1;
4480   {
4481     try {
4482       result = ((Dali::Vector2 const *)arg1)->operator -();
4483     } catch (std::out_of_range& e) {
4484       {
4485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4486       };
4487     } catch (std::exception& e) {
4488       {
4489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4490       };
4491     } catch (...) {
4492       {
4493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4494       };
4495     }
4496   }
4497   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4498   return jresult;
4499 }
4500
4501
4502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4503   unsigned int jresult ;
4504   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4505   Dali::Vector2 *arg2 = 0 ;
4506   bool result;
4507
4508   arg1 = (Dali::Vector2 *)jarg1;
4509   arg2 = (Dali::Vector2 *)jarg2;
4510   if (!arg2) {
4511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4512     return 0;
4513   }
4514   {
4515     try {
4516       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4517     } catch (std::out_of_range& e) {
4518       {
4519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4520       };
4521     } catch (std::exception& e) {
4522       {
4523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4524       };
4525     } catch (...) {
4526       {
4527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4528       };
4529     }
4530   }
4531   jresult = result;
4532   return jresult;
4533 }
4534
4535
4536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4537   unsigned int jresult ;
4538   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4539   Dali::Vector2 *arg2 = 0 ;
4540   bool result;
4541
4542   arg1 = (Dali::Vector2 *)jarg1;
4543   arg2 = (Dali::Vector2 *)jarg2;
4544   if (!arg2) {
4545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4546     return 0;
4547   }
4548   {
4549     try {
4550       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4551     } catch (std::out_of_range& e) {
4552       {
4553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4554       };
4555     } catch (std::exception& e) {
4556       {
4557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4558       };
4559     } catch (...) {
4560       {
4561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4562       };
4563     }
4564   }
4565   jresult = result;
4566   return jresult;
4567 }
4568
4569
4570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4571   float jresult ;
4572   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4573   unsigned int arg2 ;
4574   float *result = 0 ;
4575
4576   arg1 = (Dali::Vector2 *)jarg1;
4577   arg2 = (unsigned int)jarg2;
4578   {
4579     try {
4580       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4581     } catch (std::out_of_range& e) {
4582       {
4583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4584       };
4585     } catch (std::exception& e) {
4586       {
4587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4588       };
4589     } catch (...) {
4590       {
4591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4592       };
4593     }
4594   }
4595   jresult = *result;
4596   return jresult;
4597 }
4598
4599
4600 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4601   float jresult ;
4602   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4603   float result;
4604
4605   arg1 = (Dali::Vector2 *)jarg1;
4606   {
4607     try {
4608       result = (float)((Dali::Vector2 const *)arg1)->Length();
4609     } catch (std::out_of_range& e) {
4610       {
4611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4612       };
4613     } catch (std::exception& e) {
4614       {
4615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4616       };
4617     } catch (...) {
4618       {
4619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4620       };
4621     }
4622   }
4623   jresult = result;
4624   return jresult;
4625 }
4626
4627
4628 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4629   float jresult ;
4630   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4631   float result;
4632
4633   arg1 = (Dali::Vector2 *)jarg1;
4634   {
4635     try {
4636       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4637     } catch (std::out_of_range& e) {
4638       {
4639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4640       };
4641     } catch (std::exception& e) {
4642       {
4643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4644       };
4645     } catch (...) {
4646       {
4647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4648       };
4649     }
4650   }
4651   jresult = result;
4652   return jresult;
4653 }
4654
4655
4656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4657   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4658
4659   arg1 = (Dali::Vector2 *)jarg1;
4660   {
4661     try {
4662       (arg1)->Normalize();
4663     } catch (std::out_of_range& e) {
4664       {
4665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4666       };
4667     } catch (std::exception& e) {
4668       {
4669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4670       };
4671     } catch (...) {
4672       {
4673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4674       };
4675     }
4676   }
4677 }
4678
4679
4680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4681   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4682   Dali::Vector2 *arg2 = 0 ;
4683   Dali::Vector2 *arg3 = 0 ;
4684
4685   arg1 = (Dali::Vector2 *)jarg1;
4686   arg2 = (Dali::Vector2 *)jarg2;
4687   if (!arg2) {
4688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4689     return ;
4690   }
4691   arg3 = (Dali::Vector2 *)jarg3;
4692   if (!arg3) {
4693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4694     return ;
4695   }
4696   {
4697     try {
4698       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4699     } catch (std::out_of_range& e) {
4700       {
4701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4702       };
4703     } catch (std::exception& e) {
4704       {
4705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4706       };
4707     } catch (...) {
4708       {
4709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4710       };
4711     }
4712   }
4713 }
4714
4715
4716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4717   void * jresult ;
4718   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4719   float *result = 0 ;
4720
4721   arg1 = (Dali::Vector2 *)jarg1;
4722   {
4723     try {
4724       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4725     } catch (std::out_of_range& e) {
4726       {
4727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4728       };
4729     } catch (std::exception& e) {
4730       {
4731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4732       };
4733     } catch (...) {
4734       {
4735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4736       };
4737     }
4738   }
4739   jresult = (void *)result;
4740   return jresult;
4741 }
4742
4743
4744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4745   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4746   float arg2 ;
4747
4748   arg1 = (Dali::Vector2 *)jarg1;
4749   arg2 = (float)jarg2;
4750   if (arg1) (arg1)->x = arg2;
4751 }
4752
4753
4754 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4755   float jresult ;
4756   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4757   float result;
4758
4759   arg1 = (Dali::Vector2 *)jarg1;
4760   result = (float) ((arg1)->x);
4761   jresult = result;
4762   return jresult;
4763 }
4764
4765
4766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4767   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4768   float arg2 ;
4769
4770   arg1 = (Dali::Vector2 *)jarg1;
4771   arg2 = (float)jarg2;
4772   if (arg1) (arg1)->width = arg2;
4773 }
4774
4775
4776 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4777   float jresult ;
4778   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4779   float result;
4780
4781   arg1 = (Dali::Vector2 *)jarg1;
4782   result = (float) ((arg1)->width);
4783   jresult = result;
4784   return jresult;
4785 }
4786
4787
4788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4789   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4790   float arg2 ;
4791
4792   arg1 = (Dali::Vector2 *)jarg1;
4793   arg2 = (float)jarg2;
4794   if (arg1) (arg1)->y = arg2;
4795 }
4796
4797
4798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4799   float jresult ;
4800   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4801   float result;
4802
4803   arg1 = (Dali::Vector2 *)jarg1;
4804   result = (float) ((arg1)->y);
4805   jresult = result;
4806   return jresult;
4807 }
4808
4809
4810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4811   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4812   float arg2 ;
4813
4814   arg1 = (Dali::Vector2 *)jarg1;
4815   arg2 = (float)jarg2;
4816   if (arg1) (arg1)->height = arg2;
4817 }
4818
4819
4820 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4821   float jresult ;
4822   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4823   float result;
4824
4825   arg1 = (Dali::Vector2 *)jarg1;
4826   result = (float) ((arg1)->height);
4827   jresult = result;
4828   return jresult;
4829 }
4830
4831
4832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4833   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4834
4835   arg1 = (Dali::Vector2 *)jarg1;
4836   {
4837     try {
4838       delete arg1;
4839     } catch (std::out_of_range& e) {
4840       {
4841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4842       };
4843     } catch (std::exception& e) {
4844       {
4845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4846       };
4847     } catch (...) {
4848       {
4849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4850       };
4851     }
4852   }
4853 }
4854
4855
4856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4857   void * jresult ;
4858   Dali::Vector2 *arg1 = 0 ;
4859   Dali::Vector2 *arg2 = 0 ;
4860   Dali::Vector2 result;
4861
4862   arg1 = (Dali::Vector2 *)jarg1;
4863   if (!arg1) {
4864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4865     return 0;
4866   }
4867   arg2 = (Dali::Vector2 *)jarg2;
4868   if (!arg2) {
4869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4870     return 0;
4871   }
4872   {
4873     try {
4874       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4875     } catch (std::out_of_range& e) {
4876       {
4877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4878       };
4879     } catch (std::exception& e) {
4880       {
4881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4882       };
4883     } catch (...) {
4884       {
4885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4886       };
4887     }
4888   }
4889   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4890   return jresult;
4891 }
4892
4893
4894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4895   void * jresult ;
4896   Dali::Vector2 *arg1 = 0 ;
4897   Dali::Vector2 *arg2 = 0 ;
4898   Dali::Vector2 result;
4899
4900   arg1 = (Dali::Vector2 *)jarg1;
4901   if (!arg1) {
4902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4903     return 0;
4904   }
4905   arg2 = (Dali::Vector2 *)jarg2;
4906   if (!arg2) {
4907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4908     return 0;
4909   }
4910   {
4911     try {
4912       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4913     } catch (std::out_of_range& e) {
4914       {
4915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4916       };
4917     } catch (std::exception& e) {
4918       {
4919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4920       };
4921     } catch (...) {
4922       {
4923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4924       };
4925     }
4926   }
4927   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4928   return jresult;
4929 }
4930
4931
4932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
4933   void * jresult ;
4934   Dali::Vector2 *arg1 = 0 ;
4935   float *arg2 = 0 ;
4936   float *arg3 = 0 ;
4937   float temp2 ;
4938   float temp3 ;
4939   Dali::Vector2 result;
4940
4941   arg1 = (Dali::Vector2 *)jarg1;
4942   if (!arg1) {
4943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4944     return 0;
4945   }
4946   temp2 = (float)jarg2;
4947   arg2 = &temp2;
4948   temp3 = (float)jarg3;
4949   arg3 = &temp3;
4950   {
4951     try {
4952       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
4953     } catch (std::out_of_range& e) {
4954       {
4955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4956       };
4957     } catch (std::exception& e) {
4958       {
4959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4960       };
4961     } catch (...) {
4962       {
4963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4964       };
4965     }
4966   }
4967   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4968   return jresult;
4969 }
4970
4971
4972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
4973   void * jresult ;
4974   Dali::Vector3 *result = 0 ;
4975
4976   {
4977     try {
4978       result = (Dali::Vector3 *)new Dali::Vector3();
4979     } catch (std::out_of_range& e) {
4980       {
4981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4982       };
4983     } catch (std::exception& e) {
4984       {
4985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4986       };
4987     } catch (...) {
4988       {
4989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4990       };
4991     }
4992   }
4993   jresult = (void *)result;
4994   return jresult;
4995 }
4996
4997
4998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
4999   void * jresult ;
5000   float arg1 ;
5001   float arg2 ;
5002   float arg3 ;
5003   Dali::Vector3 *result = 0 ;
5004
5005   arg1 = (float)jarg1;
5006   arg2 = (float)jarg2;
5007   arg3 = (float)jarg3;
5008   {
5009     try {
5010       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5011     } catch (std::out_of_range& e) {
5012       {
5013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5014       };
5015     } catch (std::exception& e) {
5016       {
5017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5018       };
5019     } catch (...) {
5020       {
5021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5022       };
5023     }
5024   }
5025   jresult = (void *)result;
5026   return jresult;
5027 }
5028
5029
5030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5031   void * jresult ;
5032   float *arg1 = (float *) 0 ;
5033   Dali::Vector3 *result = 0 ;
5034
5035   arg1 = jarg1;
5036   {
5037     try {
5038       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5039     } catch (std::out_of_range& e) {
5040       {
5041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5042       };
5043     } catch (std::exception& e) {
5044       {
5045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5046       };
5047     } catch (...) {
5048       {
5049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5050       };
5051     }
5052   }
5053   jresult = (void *)result;
5054
5055
5056   return jresult;
5057 }
5058
5059
5060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5061   void * jresult ;
5062   Dali::Vector2 *arg1 = 0 ;
5063   Dali::Vector3 *result = 0 ;
5064
5065   arg1 = (Dali::Vector2 *)jarg1;
5066   if (!arg1) {
5067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5068     return 0;
5069   }
5070   {
5071     try {
5072       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5073     } catch (std::out_of_range& e) {
5074       {
5075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5076       };
5077     } catch (std::exception& e) {
5078       {
5079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5080       };
5081     } catch (...) {
5082       {
5083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5084       };
5085     }
5086   }
5087   jresult = (void *)result;
5088   return jresult;
5089 }
5090
5091
5092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5093   void * jresult ;
5094   Dali::Vector4 *arg1 = 0 ;
5095   Dali::Vector3 *result = 0 ;
5096
5097   arg1 = (Dali::Vector4 *)jarg1;
5098   if (!arg1) {
5099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5100     return 0;
5101   }
5102   {
5103     try {
5104       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5105     } catch (std::out_of_range& e) {
5106       {
5107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5108       };
5109     } catch (std::exception& e) {
5110       {
5111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5112       };
5113     } catch (...) {
5114       {
5115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5116       };
5117     }
5118   }
5119   jresult = (void *)result;
5120   return jresult;
5121 }
5122
5123
5124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5125   void * jresult ;
5126   Dali::Vector3 *result = 0 ;
5127
5128   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5129   jresult = (void *)result;
5130   return jresult;
5131 }
5132
5133
5134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5135   void * jresult ;
5136   Dali::Vector3 *result = 0 ;
5137
5138   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5139   jresult = (void *)result;
5140   return jresult;
5141 }
5142
5143
5144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5145   void * jresult ;
5146   Dali::Vector3 *result = 0 ;
5147
5148   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5149   jresult = (void *)result;
5150   return jresult;
5151 }
5152
5153
5154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5155   void * jresult ;
5156   Dali::Vector3 *result = 0 ;
5157
5158   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5159   jresult = (void *)result;
5160   return jresult;
5161 }
5162
5163
5164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5165   void * jresult ;
5166   Dali::Vector3 *result = 0 ;
5167
5168   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5169   jresult = (void *)result;
5170   return jresult;
5171 }
5172
5173
5174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5175   void * jresult ;
5176   Dali::Vector3 *result = 0 ;
5177
5178   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5179   jresult = (void *)result;
5180   return jresult;
5181 }
5182
5183
5184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5185   void * jresult ;
5186   Dali::Vector3 *result = 0 ;
5187
5188   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5189   jresult = (void *)result;
5190   return jresult;
5191 }
5192
5193
5194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5195   void * jresult ;
5196   Dali::Vector3 *result = 0 ;
5197
5198   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5199   jresult = (void *)result;
5200   return jresult;
5201 }
5202
5203
5204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5205   void * jresult ;
5206   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5207   float *arg2 = (float *) 0 ;
5208   Dali::Vector3 *result = 0 ;
5209
5210   arg1 = (Dali::Vector3 *)jarg1;
5211   arg2 = jarg2;
5212   {
5213     try {
5214       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5215     } catch (std::out_of_range& e) {
5216       {
5217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5218       };
5219     } catch (std::exception& e) {
5220       {
5221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5222       };
5223     } catch (...) {
5224       {
5225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5226       };
5227     }
5228   }
5229   jresult = (void *)result;
5230
5231
5232   return jresult;
5233 }
5234
5235
5236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5237   void * jresult ;
5238   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5239   Dali::Vector2 *arg2 = 0 ;
5240   Dali::Vector3 *result = 0 ;
5241
5242   arg1 = (Dali::Vector3 *)jarg1;
5243   arg2 = (Dali::Vector2 *)jarg2;
5244   if (!arg2) {
5245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5246     return 0;
5247   }
5248   {
5249     try {
5250       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5251     } catch (std::out_of_range& e) {
5252       {
5253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5254       };
5255     } catch (std::exception& e) {
5256       {
5257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5258       };
5259     } catch (...) {
5260       {
5261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5262       };
5263     }
5264   }
5265   jresult = (void *)result;
5266   return jresult;
5267 }
5268
5269
5270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5271   void * jresult ;
5272   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5273   Dali::Vector4 *arg2 = 0 ;
5274   Dali::Vector3 *result = 0 ;
5275
5276   arg1 = (Dali::Vector3 *)jarg1;
5277   arg2 = (Dali::Vector4 *)jarg2;
5278   if (!arg2) {
5279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5280     return 0;
5281   }
5282   {
5283     try {
5284       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5285     } catch (std::out_of_range& e) {
5286       {
5287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5288       };
5289     } catch (std::exception& e) {
5290       {
5291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5292       };
5293     } catch (...) {
5294       {
5295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5296       };
5297     }
5298   }
5299   jresult = (void *)result;
5300   return jresult;
5301 }
5302
5303
5304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5305   void * jresult ;
5306   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5307   Dali::Vector3 *arg2 = 0 ;
5308   Dali::Vector3 result;
5309
5310   arg1 = (Dali::Vector3 *)jarg1;
5311   arg2 = (Dali::Vector3 *)jarg2;
5312   if (!arg2) {
5313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5314     return 0;
5315   }
5316   {
5317     try {
5318       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5319     } catch (std::out_of_range& e) {
5320       {
5321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5322       };
5323     } catch (std::exception& e) {
5324       {
5325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5326       };
5327     } catch (...) {
5328       {
5329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5330       };
5331     }
5332   }
5333   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5334   return jresult;
5335 }
5336
5337
5338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5339   void * jresult ;
5340   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5341   Dali::Vector3 *arg2 = 0 ;
5342   Dali::Vector3 *result = 0 ;
5343
5344   arg1 = (Dali::Vector3 *)jarg1;
5345   arg2 = (Dali::Vector3 *)jarg2;
5346   if (!arg2) {
5347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5348     return 0;
5349   }
5350   {
5351     try {
5352       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5353     } catch (std::out_of_range& e) {
5354       {
5355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5356       };
5357     } catch (std::exception& e) {
5358       {
5359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5360       };
5361     } catch (...) {
5362       {
5363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5364       };
5365     }
5366   }
5367   jresult = (void *)result;
5368   return jresult;
5369 }
5370
5371
5372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5373   void * jresult ;
5374   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5375   Dali::Vector3 *arg2 = 0 ;
5376   Dali::Vector3 result;
5377
5378   arg1 = (Dali::Vector3 *)jarg1;
5379   arg2 = (Dali::Vector3 *)jarg2;
5380   if (!arg2) {
5381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5382     return 0;
5383   }
5384   {
5385     try {
5386       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5387     } catch (std::out_of_range& e) {
5388       {
5389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5390       };
5391     } catch (std::exception& e) {
5392       {
5393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5394       };
5395     } catch (...) {
5396       {
5397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5398       };
5399     }
5400   }
5401   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5402   return jresult;
5403 }
5404
5405
5406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5407   void * jresult ;
5408   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5409   Dali::Vector3 *arg2 = 0 ;
5410   Dali::Vector3 *result = 0 ;
5411
5412   arg1 = (Dali::Vector3 *)jarg1;
5413   arg2 = (Dali::Vector3 *)jarg2;
5414   if (!arg2) {
5415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5416     return 0;
5417   }
5418   {
5419     try {
5420       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5421     } catch (std::out_of_range& e) {
5422       {
5423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5424       };
5425     } catch (std::exception& e) {
5426       {
5427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5428       };
5429     } catch (...) {
5430       {
5431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5432       };
5433     }
5434   }
5435   jresult = (void *)result;
5436   return jresult;
5437 }
5438
5439
5440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5441   void * jresult ;
5442   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5443   Dali::Vector3 *arg2 = 0 ;
5444   Dali::Vector3 result;
5445
5446   arg1 = (Dali::Vector3 *)jarg1;
5447   arg2 = (Dali::Vector3 *)jarg2;
5448   if (!arg2) {
5449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5450     return 0;
5451   }
5452   {
5453     try {
5454       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5455     } catch (std::out_of_range& e) {
5456       {
5457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5458       };
5459     } catch (std::exception& e) {
5460       {
5461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5462       };
5463     } catch (...) {
5464       {
5465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5466       };
5467     }
5468   }
5469   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5470   return jresult;
5471 }
5472
5473
5474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5475   void * jresult ;
5476   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5477   float arg2 ;
5478   Dali::Vector3 result;
5479
5480   arg1 = (Dali::Vector3 *)jarg1;
5481   arg2 = (float)jarg2;
5482   {
5483     try {
5484       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5485     } catch (std::out_of_range& e) {
5486       {
5487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5488       };
5489     } catch (std::exception& e) {
5490       {
5491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5492       };
5493     } catch (...) {
5494       {
5495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5496       };
5497     }
5498   }
5499   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5500   return jresult;
5501 }
5502
5503
5504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5505   void * jresult ;
5506   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5507   Dali::Vector3 *arg2 = 0 ;
5508   Dali::Vector3 *result = 0 ;
5509
5510   arg1 = (Dali::Vector3 *)jarg1;
5511   arg2 = (Dali::Vector3 *)jarg2;
5512   if (!arg2) {
5513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5514     return 0;
5515   }
5516   {
5517     try {
5518       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5519     } catch (std::out_of_range& e) {
5520       {
5521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5522       };
5523     } catch (std::exception& e) {
5524       {
5525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5526       };
5527     } catch (...) {
5528       {
5529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5530       };
5531     }
5532   }
5533   jresult = (void *)result;
5534   return jresult;
5535 }
5536
5537
5538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5539   void * jresult ;
5540   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5541   float arg2 ;
5542   Dali::Vector3 *result = 0 ;
5543
5544   arg1 = (Dali::Vector3 *)jarg1;
5545   arg2 = (float)jarg2;
5546   {
5547     try {
5548       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5549     } catch (std::out_of_range& e) {
5550       {
5551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5552       };
5553     } catch (std::exception& e) {
5554       {
5555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5556       };
5557     } catch (...) {
5558       {
5559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5560       };
5561     }
5562   }
5563   jresult = (void *)result;
5564   return jresult;
5565 }
5566
5567
5568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5569   void * jresult ;
5570   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5571   Dali::Quaternion *arg2 = 0 ;
5572   Dali::Vector3 *result = 0 ;
5573
5574   arg1 = (Dali::Vector3 *)jarg1;
5575   arg2 = (Dali::Quaternion *)jarg2;
5576   if (!arg2) {
5577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5578     return 0;
5579   }
5580   {
5581     try {
5582       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5583     } catch (std::out_of_range& e) {
5584       {
5585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5586       };
5587     } catch (std::exception& e) {
5588       {
5589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5590       };
5591     } catch (...) {
5592       {
5593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5594       };
5595     }
5596   }
5597   jresult = (void *)result;
5598   return jresult;
5599 }
5600
5601
5602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5603   void * jresult ;
5604   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5605   Dali::Vector3 *arg2 = 0 ;
5606   Dali::Vector3 result;
5607
5608   arg1 = (Dali::Vector3 *)jarg1;
5609   arg2 = (Dali::Vector3 *)jarg2;
5610   if (!arg2) {
5611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5612     return 0;
5613   }
5614   {
5615     try {
5616       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5617     } catch (std::out_of_range& e) {
5618       {
5619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5620       };
5621     } catch (std::exception& e) {
5622       {
5623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5624       };
5625     } catch (...) {
5626       {
5627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5628       };
5629     }
5630   }
5631   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5632   return jresult;
5633 }
5634
5635
5636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5637   void * jresult ;
5638   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5639   float arg2 ;
5640   Dali::Vector3 result;
5641
5642   arg1 = (Dali::Vector3 *)jarg1;
5643   arg2 = (float)jarg2;
5644   {
5645     try {
5646       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5647     } catch (std::out_of_range& e) {
5648       {
5649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5650       };
5651     } catch (std::exception& e) {
5652       {
5653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5654       };
5655     } catch (...) {
5656       {
5657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5658       };
5659     }
5660   }
5661   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5662   return jresult;
5663 }
5664
5665
5666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5667   void * jresult ;
5668   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5669   Dali::Vector3 *arg2 = 0 ;
5670   Dali::Vector3 *result = 0 ;
5671
5672   arg1 = (Dali::Vector3 *)jarg1;
5673   arg2 = (Dali::Vector3 *)jarg2;
5674   if (!arg2) {
5675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5676     return 0;
5677   }
5678   {
5679     try {
5680       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5681     } catch (std::out_of_range& e) {
5682       {
5683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5684       };
5685     } catch (std::exception& e) {
5686       {
5687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5688       };
5689     } catch (...) {
5690       {
5691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5692       };
5693     }
5694   }
5695   jresult = (void *)result;
5696   return jresult;
5697 }
5698
5699
5700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5701   void * jresult ;
5702   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5703   float arg2 ;
5704   Dali::Vector3 *result = 0 ;
5705
5706   arg1 = (Dali::Vector3 *)jarg1;
5707   arg2 = (float)jarg2;
5708   {
5709     try {
5710       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5711     } catch (std::out_of_range& e) {
5712       {
5713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5714       };
5715     } catch (std::exception& e) {
5716       {
5717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5718       };
5719     } catch (...) {
5720       {
5721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5722       };
5723     }
5724   }
5725   jresult = (void *)result;
5726   return jresult;
5727 }
5728
5729
5730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5731   void * jresult ;
5732   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5733   Dali::Vector3 result;
5734
5735   arg1 = (Dali::Vector3 *)jarg1;
5736   {
5737     try {
5738       result = ((Dali::Vector3 const *)arg1)->operator -();
5739     } catch (std::out_of_range& e) {
5740       {
5741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5742       };
5743     } catch (std::exception& e) {
5744       {
5745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5746       };
5747     } catch (...) {
5748       {
5749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5750       };
5751     }
5752   }
5753   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5754   return jresult;
5755 }
5756
5757
5758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5759   unsigned int jresult ;
5760   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5761   Dali::Vector3 *arg2 = 0 ;
5762   bool result;
5763
5764   arg1 = (Dali::Vector3 *)jarg1;
5765   arg2 = (Dali::Vector3 *)jarg2;
5766   if (!arg2) {
5767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5768     return 0;
5769   }
5770   {
5771     try {
5772       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5773     } catch (std::out_of_range& e) {
5774       {
5775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5776       };
5777     } catch (std::exception& e) {
5778       {
5779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5780       };
5781     } catch (...) {
5782       {
5783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5784       };
5785     }
5786   }
5787   jresult = result;
5788   return jresult;
5789 }
5790
5791
5792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5793   unsigned int jresult ;
5794   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5795   Dali::Vector3 *arg2 = 0 ;
5796   bool result;
5797
5798   arg1 = (Dali::Vector3 *)jarg1;
5799   arg2 = (Dali::Vector3 *)jarg2;
5800   if (!arg2) {
5801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5802     return 0;
5803   }
5804   {
5805     try {
5806       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5807     } catch (std::out_of_range& e) {
5808       {
5809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5810       };
5811     } catch (std::exception& e) {
5812       {
5813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5814       };
5815     } catch (...) {
5816       {
5817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5818       };
5819     }
5820   }
5821   jresult = result;
5822   return jresult;
5823 }
5824
5825
5826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5827   float jresult ;
5828   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5829   unsigned int arg2 ;
5830   float *result = 0 ;
5831
5832   arg1 = (Dali::Vector3 *)jarg1;
5833   arg2 = (unsigned int)jarg2;
5834   {
5835     try {
5836       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5837     } catch (std::out_of_range& e) {
5838       {
5839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5840       };
5841     } catch (std::exception& e) {
5842       {
5843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5844       };
5845     } catch (...) {
5846       {
5847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5848       };
5849     }
5850   }
5851   jresult = *result;
5852   return jresult;
5853 }
5854
5855
5856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5857   float jresult ;
5858   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5859   Dali::Vector3 *arg2 = 0 ;
5860   float result;
5861
5862   arg1 = (Dali::Vector3 *)jarg1;
5863   arg2 = (Dali::Vector3 *)jarg2;
5864   if (!arg2) {
5865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5866     return 0;
5867   }
5868   {
5869     try {
5870       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5871     } catch (std::out_of_range& e) {
5872       {
5873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5874       };
5875     } catch (std::exception& e) {
5876       {
5877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5878       };
5879     } catch (...) {
5880       {
5881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5882       };
5883     }
5884   }
5885   jresult = result;
5886   return jresult;
5887 }
5888
5889
5890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5891   void * jresult ;
5892   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5893   Dali::Vector3 *arg2 = 0 ;
5894   Dali::Vector3 result;
5895
5896   arg1 = (Dali::Vector3 *)jarg1;
5897   arg2 = (Dali::Vector3 *)jarg2;
5898   if (!arg2) {
5899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5900     return 0;
5901   }
5902   {
5903     try {
5904       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5905     } catch (std::out_of_range& e) {
5906       {
5907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5908       };
5909     } catch (std::exception& e) {
5910       {
5911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5912       };
5913     } catch (...) {
5914       {
5915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5916       };
5917     }
5918   }
5919   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5920   return jresult;
5921 }
5922
5923
5924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
5925   float jresult ;
5926   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5927   float result;
5928
5929   arg1 = (Dali::Vector3 *)jarg1;
5930   {
5931     try {
5932       result = (float)((Dali::Vector3 const *)arg1)->Length();
5933     } catch (std::out_of_range& e) {
5934       {
5935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5936       };
5937     } catch (std::exception& e) {
5938       {
5939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5940       };
5941     } catch (...) {
5942       {
5943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5944       };
5945     }
5946   }
5947   jresult = result;
5948   return jresult;
5949 }
5950
5951
5952 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
5953   float jresult ;
5954   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5955   float result;
5956
5957   arg1 = (Dali::Vector3 *)jarg1;
5958   {
5959     try {
5960       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
5961     } catch (std::out_of_range& e) {
5962       {
5963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5964       };
5965     } catch (std::exception& e) {
5966       {
5967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5968       };
5969     } catch (...) {
5970       {
5971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5972       };
5973     }
5974   }
5975   jresult = result;
5976   return jresult;
5977 }
5978
5979
5980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
5981   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5982
5983   arg1 = (Dali::Vector3 *)jarg1;
5984   {
5985     try {
5986       (arg1)->Normalize();
5987     } catch (std::out_of_range& e) {
5988       {
5989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5990       };
5991     } catch (std::exception& e) {
5992       {
5993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5994       };
5995     } catch (...) {
5996       {
5997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5998       };
5999     }
6000   }
6001 }
6002
6003
6004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6005   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6006   Dali::Vector3 *arg2 = 0 ;
6007   Dali::Vector3 *arg3 = 0 ;
6008
6009   arg1 = (Dali::Vector3 *)jarg1;
6010   arg2 = (Dali::Vector3 *)jarg2;
6011   if (!arg2) {
6012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6013     return ;
6014   }
6015   arg3 = (Dali::Vector3 *)jarg3;
6016   if (!arg3) {
6017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6018     return ;
6019   }
6020   {
6021     try {
6022       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6023     } catch (std::out_of_range& e) {
6024       {
6025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6026       };
6027     } catch (std::exception& e) {
6028       {
6029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6030       };
6031     } catch (...) {
6032       {
6033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6034       };
6035     }
6036   }
6037 }
6038
6039
6040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6041   void * jresult ;
6042   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6043   float *result = 0 ;
6044
6045   arg1 = (Dali::Vector3 *)jarg1;
6046   {
6047     try {
6048       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6049     } catch (std::out_of_range& e) {
6050       {
6051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6052       };
6053     } catch (std::exception& e) {
6054       {
6055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6056       };
6057     } catch (...) {
6058       {
6059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6060       };
6061     }
6062   }
6063   jresult = (void *)result;
6064   return jresult;
6065 }
6066
6067
6068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6069   void * jresult ;
6070   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6071   Dali::Vector2 *result = 0 ;
6072
6073   arg1 = (Dali::Vector3 *)jarg1;
6074   {
6075     try {
6076       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6077     } catch (std::out_of_range& e) {
6078       {
6079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6080       };
6081     } catch (std::exception& e) {
6082       {
6083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6084       };
6085     } catch (...) {
6086       {
6087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6088       };
6089     }
6090   }
6091   jresult = (void *)result;
6092   return jresult;
6093 }
6094
6095
6096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6097   void * jresult ;
6098   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6099   Dali::Vector2 *result = 0 ;
6100
6101   arg1 = (Dali::Vector3 *)jarg1;
6102   {
6103     try {
6104       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6105     } catch (std::out_of_range& e) {
6106       {
6107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6108       };
6109     } catch (std::exception& e) {
6110       {
6111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6112       };
6113     } catch (...) {
6114       {
6115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6116       };
6117     }
6118   }
6119   jresult = (void *)result;
6120   return jresult;
6121 }
6122
6123
6124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6125   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6126   float arg2 ;
6127
6128   arg1 = (Dali::Vector3 *)jarg1;
6129   arg2 = (float)jarg2;
6130   if (arg1) (arg1)->x = arg2;
6131 }
6132
6133
6134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6135   float jresult ;
6136   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6137   float result;
6138
6139   arg1 = (Dali::Vector3 *)jarg1;
6140   result = (float) ((arg1)->x);
6141   jresult = result;
6142   return jresult;
6143 }
6144
6145
6146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6147   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6148   float arg2 ;
6149
6150   arg1 = (Dali::Vector3 *)jarg1;
6151   arg2 = (float)jarg2;
6152   if (arg1) (arg1)->width = arg2;
6153 }
6154
6155
6156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6157   float jresult ;
6158   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6159   float result;
6160
6161   arg1 = (Dali::Vector3 *)jarg1;
6162   result = (float) ((arg1)->width);
6163   jresult = result;
6164   return jresult;
6165 }
6166
6167
6168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6169   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6170   float arg2 ;
6171
6172   arg1 = (Dali::Vector3 *)jarg1;
6173   arg2 = (float)jarg2;
6174   if (arg1) (arg1)->r = arg2;
6175 }
6176
6177
6178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6179   float jresult ;
6180   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6181   float result;
6182
6183   arg1 = (Dali::Vector3 *)jarg1;
6184   result = (float) ((arg1)->r);
6185   jresult = result;
6186   return jresult;
6187 }
6188
6189
6190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6191   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6192   float arg2 ;
6193
6194   arg1 = (Dali::Vector3 *)jarg1;
6195   arg2 = (float)jarg2;
6196   if (arg1) (arg1)->y = arg2;
6197 }
6198
6199
6200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6201   float jresult ;
6202   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6203   float result;
6204
6205   arg1 = (Dali::Vector3 *)jarg1;
6206   result = (float) ((arg1)->y);
6207   jresult = result;
6208   return jresult;
6209 }
6210
6211
6212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6213   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6214   float arg2 ;
6215
6216   arg1 = (Dali::Vector3 *)jarg1;
6217   arg2 = (float)jarg2;
6218   if (arg1) (arg1)->height = arg2;
6219 }
6220
6221
6222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6223   float jresult ;
6224   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6225   float result;
6226
6227   arg1 = (Dali::Vector3 *)jarg1;
6228   result = (float) ((arg1)->height);
6229   jresult = result;
6230   return jresult;
6231 }
6232
6233
6234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6235   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6236   float arg2 ;
6237
6238   arg1 = (Dali::Vector3 *)jarg1;
6239   arg2 = (float)jarg2;
6240   if (arg1) (arg1)->g = arg2;
6241 }
6242
6243
6244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6245   float jresult ;
6246   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6247   float result;
6248
6249   arg1 = (Dali::Vector3 *)jarg1;
6250   result = (float) ((arg1)->g);
6251   jresult = result;
6252   return jresult;
6253 }
6254
6255
6256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6257   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6258   float arg2 ;
6259
6260   arg1 = (Dali::Vector3 *)jarg1;
6261   arg2 = (float)jarg2;
6262   if (arg1) (arg1)->z = arg2;
6263 }
6264
6265
6266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6267   float jresult ;
6268   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6269   float result;
6270
6271   arg1 = (Dali::Vector3 *)jarg1;
6272   result = (float) ((arg1)->z);
6273   jresult = result;
6274   return jresult;
6275 }
6276
6277
6278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6279   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6280   float arg2 ;
6281
6282   arg1 = (Dali::Vector3 *)jarg1;
6283   arg2 = (float)jarg2;
6284   if (arg1) (arg1)->depth = arg2;
6285 }
6286
6287
6288 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6289   float jresult ;
6290   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6291   float result;
6292
6293   arg1 = (Dali::Vector3 *)jarg1;
6294   result = (float) ((arg1)->depth);
6295   jresult = result;
6296   return jresult;
6297 }
6298
6299
6300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6301   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6302   float arg2 ;
6303
6304   arg1 = (Dali::Vector3 *)jarg1;
6305   arg2 = (float)jarg2;
6306   if (arg1) (arg1)->b = arg2;
6307 }
6308
6309
6310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6311   float jresult ;
6312   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6313   float result;
6314
6315   arg1 = (Dali::Vector3 *)jarg1;
6316   result = (float) ((arg1)->b);
6317   jresult = result;
6318   return jresult;
6319 }
6320
6321
6322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6323   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6324
6325   arg1 = (Dali::Vector3 *)jarg1;
6326   {
6327     try {
6328       delete arg1;
6329     } catch (std::out_of_range& e) {
6330       {
6331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6332       };
6333     } catch (std::exception& e) {
6334       {
6335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6336       };
6337     } catch (...) {
6338       {
6339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6340       };
6341     }
6342   }
6343 }
6344
6345
6346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6347   void * jresult ;
6348   Dali::Vector3 *arg1 = 0 ;
6349   Dali::Vector3 *arg2 = 0 ;
6350   Dali::Vector3 result;
6351
6352   arg1 = (Dali::Vector3 *)jarg1;
6353   if (!arg1) {
6354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6355     return 0;
6356   }
6357   arg2 = (Dali::Vector3 *)jarg2;
6358   if (!arg2) {
6359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6360     return 0;
6361   }
6362   {
6363     try {
6364       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6365     } catch (std::out_of_range& e) {
6366       {
6367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6368       };
6369     } catch (std::exception& e) {
6370       {
6371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6372       };
6373     } catch (...) {
6374       {
6375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6376       };
6377     }
6378   }
6379   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6380   return jresult;
6381 }
6382
6383
6384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6385   void * jresult ;
6386   Dali::Vector3 *arg1 = 0 ;
6387   Dali::Vector3 *arg2 = 0 ;
6388   Dali::Vector3 result;
6389
6390   arg1 = (Dali::Vector3 *)jarg1;
6391   if (!arg1) {
6392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6393     return 0;
6394   }
6395   arg2 = (Dali::Vector3 *)jarg2;
6396   if (!arg2) {
6397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6398     return 0;
6399   }
6400   {
6401     try {
6402       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6403     } catch (std::out_of_range& e) {
6404       {
6405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6406       };
6407     } catch (std::exception& e) {
6408       {
6409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6410       };
6411     } catch (...) {
6412       {
6413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6414       };
6415     }
6416   }
6417   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6418   return jresult;
6419 }
6420
6421
6422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6423   void * jresult ;
6424   Dali::Vector3 *arg1 = 0 ;
6425   float *arg2 = 0 ;
6426   float *arg3 = 0 ;
6427   float temp2 ;
6428   float temp3 ;
6429   Dali::Vector3 result;
6430
6431   arg1 = (Dali::Vector3 *)jarg1;
6432   if (!arg1) {
6433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6434     return 0;
6435   }
6436   temp2 = (float)jarg2;
6437   arg2 = &temp2;
6438   temp3 = (float)jarg3;
6439   arg3 = &temp3;
6440   {
6441     try {
6442       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6443     } catch (std::out_of_range& e) {
6444       {
6445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6446       };
6447     } catch (std::exception& e) {
6448       {
6449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6450       };
6451     } catch (...) {
6452       {
6453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6454       };
6455     }
6456   }
6457   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6458   return jresult;
6459 }
6460
6461
6462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6463   void * jresult ;
6464   Dali::Vector4 *result = 0 ;
6465
6466   {
6467     try {
6468       result = (Dali::Vector4 *)new Dali::Vector4();
6469     } catch (std::out_of_range& e) {
6470       {
6471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6472       };
6473     } catch (std::exception& e) {
6474       {
6475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6476       };
6477     } catch (...) {
6478       {
6479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6480       };
6481     }
6482   }
6483   jresult = (void *)result;
6484   return jresult;
6485 }
6486
6487
6488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6489   void * jresult ;
6490   float arg1 ;
6491   float arg2 ;
6492   float arg3 ;
6493   float arg4 ;
6494   Dali::Vector4 *result = 0 ;
6495
6496   arg1 = (float)jarg1;
6497   arg2 = (float)jarg2;
6498   arg3 = (float)jarg3;
6499   arg4 = (float)jarg4;
6500   {
6501     try {
6502       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6503     } catch (std::out_of_range& e) {
6504       {
6505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6506       };
6507     } catch (std::exception& e) {
6508       {
6509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6510       };
6511     } catch (...) {
6512       {
6513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6514       };
6515     }
6516   }
6517   jresult = (void *)result;
6518   return jresult;
6519 }
6520
6521
6522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6523   void * jresult ;
6524   float *arg1 = (float *) 0 ;
6525   Dali::Vector4 *result = 0 ;
6526
6527   arg1 = jarg1;
6528   {
6529     try {
6530       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6531     } catch (std::out_of_range& e) {
6532       {
6533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6534       };
6535     } catch (std::exception& e) {
6536       {
6537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6538       };
6539     } catch (...) {
6540       {
6541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6542       };
6543     }
6544   }
6545   jresult = (void *)result;
6546
6547
6548   return jresult;
6549 }
6550
6551
6552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6553   void * jresult ;
6554   Dali::Vector2 *arg1 = 0 ;
6555   Dali::Vector4 *result = 0 ;
6556
6557   arg1 = (Dali::Vector2 *)jarg1;
6558   if (!arg1) {
6559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6560     return 0;
6561   }
6562   {
6563     try {
6564       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6565     } catch (std::out_of_range& e) {
6566       {
6567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6568       };
6569     } catch (std::exception& e) {
6570       {
6571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6572       };
6573     } catch (...) {
6574       {
6575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6576       };
6577     }
6578   }
6579   jresult = (void *)result;
6580   return jresult;
6581 }
6582
6583
6584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6585   void * jresult ;
6586   Dali::Vector3 *arg1 = 0 ;
6587   Dali::Vector4 *result = 0 ;
6588
6589   arg1 = (Dali::Vector3 *)jarg1;
6590   if (!arg1) {
6591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6592     return 0;
6593   }
6594   {
6595     try {
6596       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6597     } catch (std::out_of_range& e) {
6598       {
6599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6600       };
6601     } catch (std::exception& e) {
6602       {
6603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6604       };
6605     } catch (...) {
6606       {
6607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6608       };
6609     }
6610   }
6611   jresult = (void *)result;
6612   return jresult;
6613 }
6614
6615
6616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6617   void * jresult ;
6618   Dali::Vector4 *result = 0 ;
6619
6620   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6621   jresult = (void *)result;
6622   return jresult;
6623 }
6624
6625
6626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6627   void * jresult ;
6628   Dali::Vector4 *result = 0 ;
6629
6630   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6631   jresult = (void *)result;
6632   return jresult;
6633 }
6634
6635
6636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6637   void * jresult ;
6638   Dali::Vector4 *result = 0 ;
6639
6640   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6641   jresult = (void *)result;
6642   return jresult;
6643 }
6644
6645
6646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6647   void * jresult ;
6648   Dali::Vector4 *result = 0 ;
6649
6650   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6651   jresult = (void *)result;
6652   return jresult;
6653 }
6654
6655
6656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6657   void * jresult ;
6658   Dali::Vector4 *result = 0 ;
6659
6660   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6661   jresult = (void *)result;
6662   return jresult;
6663 }
6664
6665
6666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6667   void * jresult ;
6668   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6669   float *arg2 = (float *) 0 ;
6670   Dali::Vector4 *result = 0 ;
6671
6672   arg1 = (Dali::Vector4 *)jarg1;
6673   arg2 = jarg2;
6674   {
6675     try {
6676       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6677     } catch (std::out_of_range& e) {
6678       {
6679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6680       };
6681     } catch (std::exception& e) {
6682       {
6683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6684       };
6685     } catch (...) {
6686       {
6687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6688       };
6689     }
6690   }
6691   jresult = (void *)result;
6692
6693
6694   return jresult;
6695 }
6696
6697
6698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6699   void * jresult ;
6700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6701   Dali::Vector2 *arg2 = 0 ;
6702   Dali::Vector4 *result = 0 ;
6703
6704   arg1 = (Dali::Vector4 *)jarg1;
6705   arg2 = (Dali::Vector2 *)jarg2;
6706   if (!arg2) {
6707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6708     return 0;
6709   }
6710   {
6711     try {
6712       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6713     } catch (std::out_of_range& e) {
6714       {
6715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6716       };
6717     } catch (std::exception& e) {
6718       {
6719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6720       };
6721     } catch (...) {
6722       {
6723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6724       };
6725     }
6726   }
6727   jresult = (void *)result;
6728   return jresult;
6729 }
6730
6731
6732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6733   void * jresult ;
6734   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6735   Dali::Vector3 *arg2 = 0 ;
6736   Dali::Vector4 *result = 0 ;
6737
6738   arg1 = (Dali::Vector4 *)jarg1;
6739   arg2 = (Dali::Vector3 *)jarg2;
6740   if (!arg2) {
6741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6742     return 0;
6743   }
6744   {
6745     try {
6746       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6747     } catch (std::out_of_range& e) {
6748       {
6749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6750       };
6751     } catch (std::exception& e) {
6752       {
6753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6754       };
6755     } catch (...) {
6756       {
6757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6758       };
6759     }
6760   }
6761   jresult = (void *)result;
6762   return jresult;
6763 }
6764
6765
6766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6767   void * jresult ;
6768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6769   Dali::Vector4 *arg2 = 0 ;
6770   Dali::Vector4 result;
6771
6772   arg1 = (Dali::Vector4 *)jarg1;
6773   arg2 = (Dali::Vector4 *)jarg2;
6774   if (!arg2) {
6775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6776     return 0;
6777   }
6778   {
6779     try {
6780       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6781     } catch (std::out_of_range& e) {
6782       {
6783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6784       };
6785     } catch (std::exception& e) {
6786       {
6787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6788       };
6789     } catch (...) {
6790       {
6791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6792       };
6793     }
6794   }
6795   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6796   return jresult;
6797 }
6798
6799
6800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6801   void * jresult ;
6802   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6803   Dali::Vector4 *arg2 = 0 ;
6804   Dali::Vector4 *result = 0 ;
6805
6806   arg1 = (Dali::Vector4 *)jarg1;
6807   arg2 = (Dali::Vector4 *)jarg2;
6808   if (!arg2) {
6809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6810     return 0;
6811   }
6812   {
6813     try {
6814       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6815     } catch (std::out_of_range& e) {
6816       {
6817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6818       };
6819     } catch (std::exception& e) {
6820       {
6821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6822       };
6823     } catch (...) {
6824       {
6825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6826       };
6827     }
6828   }
6829   jresult = (void *)result;
6830   return jresult;
6831 }
6832
6833
6834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6835   void * jresult ;
6836   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6837   Dali::Vector4 *arg2 = 0 ;
6838   Dali::Vector4 result;
6839
6840   arg1 = (Dali::Vector4 *)jarg1;
6841   arg2 = (Dali::Vector4 *)jarg2;
6842   if (!arg2) {
6843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6844     return 0;
6845   }
6846   {
6847     try {
6848       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6849     } catch (std::out_of_range& e) {
6850       {
6851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6852       };
6853     } catch (std::exception& e) {
6854       {
6855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6856       };
6857     } catch (...) {
6858       {
6859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6860       };
6861     }
6862   }
6863   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6864   return jresult;
6865 }
6866
6867
6868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6869   void * jresult ;
6870   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6871   Dali::Vector4 *arg2 = 0 ;
6872   Dali::Vector4 *result = 0 ;
6873
6874   arg1 = (Dali::Vector4 *)jarg1;
6875   arg2 = (Dali::Vector4 *)jarg2;
6876   if (!arg2) {
6877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6878     return 0;
6879   }
6880   {
6881     try {
6882       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6883     } catch (std::out_of_range& e) {
6884       {
6885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6886       };
6887     } catch (std::exception& e) {
6888       {
6889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6890       };
6891     } catch (...) {
6892       {
6893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6894       };
6895     }
6896   }
6897   jresult = (void *)result;
6898   return jresult;
6899 }
6900
6901
6902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6903   void * jresult ;
6904   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6905   Dali::Vector4 *arg2 = 0 ;
6906   Dali::Vector4 result;
6907
6908   arg1 = (Dali::Vector4 *)jarg1;
6909   arg2 = (Dali::Vector4 *)jarg2;
6910   if (!arg2) {
6911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6912     return 0;
6913   }
6914   {
6915     try {
6916       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6917     } catch (std::out_of_range& e) {
6918       {
6919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6920       };
6921     } catch (std::exception& e) {
6922       {
6923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6924       };
6925     } catch (...) {
6926       {
6927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6928       };
6929     }
6930   }
6931   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6932   return jresult;
6933 }
6934
6935
6936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
6937   void * jresult ;
6938   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6939   float arg2 ;
6940   Dali::Vector4 result;
6941
6942   arg1 = (Dali::Vector4 *)jarg1;
6943   arg2 = (float)jarg2;
6944   {
6945     try {
6946       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
6947     } catch (std::out_of_range& e) {
6948       {
6949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6950       };
6951     } catch (std::exception& e) {
6952       {
6953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6954       };
6955     } catch (...) {
6956       {
6957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6958       };
6959     }
6960   }
6961   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6962   return jresult;
6963 }
6964
6965
6966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6967   void * jresult ;
6968   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6969   Dali::Vector4 *arg2 = 0 ;
6970   Dali::Vector4 *result = 0 ;
6971
6972   arg1 = (Dali::Vector4 *)jarg1;
6973   arg2 = (Dali::Vector4 *)jarg2;
6974   if (!arg2) {
6975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6976     return 0;
6977   }
6978   {
6979     try {
6980       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
6981     } catch (std::out_of_range& e) {
6982       {
6983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6984       };
6985     } catch (std::exception& e) {
6986       {
6987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6988       };
6989     } catch (...) {
6990       {
6991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6992       };
6993     }
6994   }
6995   jresult = (void *)result;
6996   return jresult;
6997 }
6998
6999
7000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7001   void * jresult ;
7002   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7003   float arg2 ;
7004   Dali::Vector4 *result = 0 ;
7005
7006   arg1 = (Dali::Vector4 *)jarg1;
7007   arg2 = (float)jarg2;
7008   {
7009     try {
7010       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7011     } catch (std::out_of_range& e) {
7012       {
7013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7014       };
7015     } catch (std::exception& e) {
7016       {
7017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7018       };
7019     } catch (...) {
7020       {
7021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7022       };
7023     }
7024   }
7025   jresult = (void *)result;
7026   return jresult;
7027 }
7028
7029
7030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7031   void * jresult ;
7032   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7033   Dali::Vector4 *arg2 = 0 ;
7034   Dali::Vector4 result;
7035
7036   arg1 = (Dali::Vector4 *)jarg1;
7037   arg2 = (Dali::Vector4 *)jarg2;
7038   if (!arg2) {
7039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7040     return 0;
7041   }
7042   {
7043     try {
7044       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7045     } catch (std::out_of_range& e) {
7046       {
7047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7048       };
7049     } catch (std::exception& e) {
7050       {
7051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7052       };
7053     } catch (...) {
7054       {
7055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7056       };
7057     }
7058   }
7059   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7060   return jresult;
7061 }
7062
7063
7064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7065   void * jresult ;
7066   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7067   float arg2 ;
7068   Dali::Vector4 result;
7069
7070   arg1 = (Dali::Vector4 *)jarg1;
7071   arg2 = (float)jarg2;
7072   {
7073     try {
7074       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7075     } catch (std::out_of_range& e) {
7076       {
7077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7078       };
7079     } catch (std::exception& e) {
7080       {
7081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7082       };
7083     } catch (...) {
7084       {
7085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7086       };
7087     }
7088   }
7089   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7090   return jresult;
7091 }
7092
7093
7094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7095   void * jresult ;
7096   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7097   Dali::Vector4 *arg2 = 0 ;
7098   Dali::Vector4 *result = 0 ;
7099
7100   arg1 = (Dali::Vector4 *)jarg1;
7101   arg2 = (Dali::Vector4 *)jarg2;
7102   if (!arg2) {
7103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7104     return 0;
7105   }
7106   {
7107     try {
7108       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7109     } catch (std::out_of_range& e) {
7110       {
7111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7112       };
7113     } catch (std::exception& e) {
7114       {
7115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7116       };
7117     } catch (...) {
7118       {
7119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7120       };
7121     }
7122   }
7123   jresult = (void *)result;
7124   return jresult;
7125 }
7126
7127
7128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7129   void * jresult ;
7130   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7131   float arg2 ;
7132   Dali::Vector4 *result = 0 ;
7133
7134   arg1 = (Dali::Vector4 *)jarg1;
7135   arg2 = (float)jarg2;
7136   {
7137     try {
7138       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7139     } catch (std::out_of_range& e) {
7140       {
7141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7142       };
7143     } catch (std::exception& e) {
7144       {
7145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7146       };
7147     } catch (...) {
7148       {
7149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7150       };
7151     }
7152   }
7153   jresult = (void *)result;
7154   return jresult;
7155 }
7156
7157
7158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7159   void * jresult ;
7160   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7161   Dali::Vector4 result;
7162
7163   arg1 = (Dali::Vector4 *)jarg1;
7164   {
7165     try {
7166       result = ((Dali::Vector4 const *)arg1)->operator -();
7167     } catch (std::out_of_range& e) {
7168       {
7169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7170       };
7171     } catch (std::exception& e) {
7172       {
7173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7174       };
7175     } catch (...) {
7176       {
7177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7178       };
7179     }
7180   }
7181   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7182   return jresult;
7183 }
7184
7185
7186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7187   unsigned int jresult ;
7188   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7189   Dali::Vector4 *arg2 = 0 ;
7190   bool result;
7191
7192   arg1 = (Dali::Vector4 *)jarg1;
7193   arg2 = (Dali::Vector4 *)jarg2;
7194   if (!arg2) {
7195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7196     return 0;
7197   }
7198   {
7199     try {
7200       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7201     } catch (std::out_of_range& e) {
7202       {
7203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7204       };
7205     } catch (std::exception& e) {
7206       {
7207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7208       };
7209     } catch (...) {
7210       {
7211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7212       };
7213     }
7214   }
7215   jresult = result;
7216   return jresult;
7217 }
7218
7219
7220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7221   unsigned int jresult ;
7222   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7223   Dali::Vector4 *arg2 = 0 ;
7224   bool result;
7225
7226   arg1 = (Dali::Vector4 *)jarg1;
7227   arg2 = (Dali::Vector4 *)jarg2;
7228   if (!arg2) {
7229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7230     return 0;
7231   }
7232   {
7233     try {
7234       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7235     } catch (std::out_of_range& e) {
7236       {
7237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7238       };
7239     } catch (std::exception& e) {
7240       {
7241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7242       };
7243     } catch (...) {
7244       {
7245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7246       };
7247     }
7248   }
7249   jresult = result;
7250   return jresult;
7251 }
7252
7253
7254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7255   float jresult ;
7256   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7257   unsigned int arg2 ;
7258   float *result = 0 ;
7259
7260   arg1 = (Dali::Vector4 *)jarg1;
7261   arg2 = (unsigned int)jarg2;
7262   {
7263     try {
7264       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7265     } catch (std::out_of_range& e) {
7266       {
7267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7268       };
7269     } catch (std::exception& e) {
7270       {
7271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7272       };
7273     } catch (...) {
7274       {
7275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7276       };
7277     }
7278   }
7279   jresult = *result;
7280   return jresult;
7281 }
7282
7283
7284 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7285   float jresult ;
7286   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7287   Dali::Vector3 *arg2 = 0 ;
7288   float result;
7289
7290   arg1 = (Dali::Vector4 *)jarg1;
7291   arg2 = (Dali::Vector3 *)jarg2;
7292   if (!arg2) {
7293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7294     return 0;
7295   }
7296   {
7297     try {
7298       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7299     } catch (std::out_of_range& e) {
7300       {
7301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7302       };
7303     } catch (std::exception& e) {
7304       {
7305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7306       };
7307     } catch (...) {
7308       {
7309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7310       };
7311     }
7312   }
7313   jresult = result;
7314   return jresult;
7315 }
7316
7317
7318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7319   float jresult ;
7320   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7321   Dali::Vector4 *arg2 = 0 ;
7322   float result;
7323
7324   arg1 = (Dali::Vector4 *)jarg1;
7325   arg2 = (Dali::Vector4 *)jarg2;
7326   if (!arg2) {
7327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7328     return 0;
7329   }
7330   {
7331     try {
7332       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7333     } catch (std::out_of_range& e) {
7334       {
7335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7336       };
7337     } catch (std::exception& e) {
7338       {
7339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7340       };
7341     } catch (...) {
7342       {
7343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7344       };
7345     }
7346   }
7347   jresult = result;
7348   return jresult;
7349 }
7350
7351
7352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7353   float jresult ;
7354   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7355   Dali::Vector4 *arg2 = 0 ;
7356   float result;
7357
7358   arg1 = (Dali::Vector4 *)jarg1;
7359   arg2 = (Dali::Vector4 *)jarg2;
7360   if (!arg2) {
7361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7362     return 0;
7363   }
7364   {
7365     try {
7366       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7367     } catch (std::out_of_range& e) {
7368       {
7369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7370       };
7371     } catch (std::exception& e) {
7372       {
7373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7374       };
7375     } catch (...) {
7376       {
7377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7378       };
7379     }
7380   }
7381   jresult = result;
7382   return jresult;
7383 }
7384
7385
7386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7387   void * jresult ;
7388   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7389   Dali::Vector4 *arg2 = 0 ;
7390   Dali::Vector4 result;
7391
7392   arg1 = (Dali::Vector4 *)jarg1;
7393   arg2 = (Dali::Vector4 *)jarg2;
7394   if (!arg2) {
7395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7396     return 0;
7397   }
7398   {
7399     try {
7400       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7401     } catch (std::out_of_range& e) {
7402       {
7403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7404       };
7405     } catch (std::exception& e) {
7406       {
7407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7408       };
7409     } catch (...) {
7410       {
7411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7412       };
7413     }
7414   }
7415   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7416   return jresult;
7417 }
7418
7419
7420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7421   float jresult ;
7422   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7423   float result;
7424
7425   arg1 = (Dali::Vector4 *)jarg1;
7426   {
7427     try {
7428       result = (float)((Dali::Vector4 const *)arg1)->Length();
7429     } catch (std::out_of_range& e) {
7430       {
7431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7432       };
7433     } catch (std::exception& e) {
7434       {
7435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7436       };
7437     } catch (...) {
7438       {
7439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7440       };
7441     }
7442   }
7443   jresult = result;
7444   return jresult;
7445 }
7446
7447
7448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7449   float jresult ;
7450   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7451   float result;
7452
7453   arg1 = (Dali::Vector4 *)jarg1;
7454   {
7455     try {
7456       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7457     } catch (std::out_of_range& e) {
7458       {
7459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7460       };
7461     } catch (std::exception& e) {
7462       {
7463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7464       };
7465     } catch (...) {
7466       {
7467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7468       };
7469     }
7470   }
7471   jresult = result;
7472   return jresult;
7473 }
7474
7475
7476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7477   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7478
7479   arg1 = (Dali::Vector4 *)jarg1;
7480   {
7481     try {
7482       (arg1)->Normalize();
7483     } catch (std::out_of_range& e) {
7484       {
7485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7486       };
7487     } catch (std::exception& e) {
7488       {
7489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7490       };
7491     } catch (...) {
7492       {
7493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7494       };
7495     }
7496   }
7497 }
7498
7499
7500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7501   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7502   Dali::Vector4 *arg2 = 0 ;
7503   Dali::Vector4 *arg3 = 0 ;
7504
7505   arg1 = (Dali::Vector4 *)jarg1;
7506   arg2 = (Dali::Vector4 *)jarg2;
7507   if (!arg2) {
7508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7509     return ;
7510   }
7511   arg3 = (Dali::Vector4 *)jarg3;
7512   if (!arg3) {
7513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7514     return ;
7515   }
7516   {
7517     try {
7518       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7519     } catch (std::out_of_range& e) {
7520       {
7521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7522       };
7523     } catch (std::exception& e) {
7524       {
7525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7526       };
7527     } catch (...) {
7528       {
7529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7530       };
7531     }
7532   }
7533 }
7534
7535
7536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7537   void * jresult ;
7538   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7539   float *result = 0 ;
7540
7541   arg1 = (Dali::Vector4 *)jarg1;
7542   {
7543     try {
7544       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7545     } catch (std::out_of_range& e) {
7546       {
7547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7548       };
7549     } catch (std::exception& e) {
7550       {
7551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7552       };
7553     } catch (...) {
7554       {
7555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7556       };
7557     }
7558   }
7559   jresult = (void *)result;
7560   return jresult;
7561 }
7562
7563
7564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7565   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7566   float arg2 ;
7567
7568   arg1 = (Dali::Vector4 *)jarg1;
7569   arg2 = (float)jarg2;
7570   if (arg1) (arg1)->x = arg2;
7571 }
7572
7573
7574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7575   float jresult ;
7576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7577   float result;
7578
7579   arg1 = (Dali::Vector4 *)jarg1;
7580   result = (float) ((arg1)->x);
7581   jresult = result;
7582   return jresult;
7583 }
7584
7585
7586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7587   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7588   float arg2 ;
7589
7590   arg1 = (Dali::Vector4 *)jarg1;
7591   arg2 = (float)jarg2;
7592   if (arg1) (arg1)->r = arg2;
7593 }
7594
7595
7596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7597   float jresult ;
7598   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7599   float result;
7600
7601   arg1 = (Dali::Vector4 *)jarg1;
7602   result = (float) ((arg1)->r);
7603   jresult = result;
7604   return jresult;
7605 }
7606
7607
7608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7609   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7610   float arg2 ;
7611
7612   arg1 = (Dali::Vector4 *)jarg1;
7613   arg2 = (float)jarg2;
7614   if (arg1) (arg1)->s = arg2;
7615 }
7616
7617
7618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7619   float jresult ;
7620   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7621   float result;
7622
7623   arg1 = (Dali::Vector4 *)jarg1;
7624   result = (float) ((arg1)->s);
7625   jresult = result;
7626   return jresult;
7627 }
7628
7629
7630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7631   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7632   float arg2 ;
7633
7634   arg1 = (Dali::Vector4 *)jarg1;
7635   arg2 = (float)jarg2;
7636   if (arg1) (arg1)->y = arg2;
7637 }
7638
7639
7640 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7641   float jresult ;
7642   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7643   float result;
7644
7645   arg1 = (Dali::Vector4 *)jarg1;
7646   result = (float) ((arg1)->y);
7647   jresult = result;
7648   return jresult;
7649 }
7650
7651
7652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7654   float arg2 ;
7655
7656   arg1 = (Dali::Vector4 *)jarg1;
7657   arg2 = (float)jarg2;
7658   if (arg1) (arg1)->g = arg2;
7659 }
7660
7661
7662 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7663   float jresult ;
7664   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7665   float result;
7666
7667   arg1 = (Dali::Vector4 *)jarg1;
7668   result = (float) ((arg1)->g);
7669   jresult = result;
7670   return jresult;
7671 }
7672
7673
7674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7675   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7676   float arg2 ;
7677
7678   arg1 = (Dali::Vector4 *)jarg1;
7679   arg2 = (float)jarg2;
7680   if (arg1) (arg1)->t = arg2;
7681 }
7682
7683
7684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7685   float jresult ;
7686   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7687   float result;
7688
7689   arg1 = (Dali::Vector4 *)jarg1;
7690   result = (float) ((arg1)->t);
7691   jresult = result;
7692   return jresult;
7693 }
7694
7695
7696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7697   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7698   float arg2 ;
7699
7700   arg1 = (Dali::Vector4 *)jarg1;
7701   arg2 = (float)jarg2;
7702   if (arg1) (arg1)->z = arg2;
7703 }
7704
7705
7706 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7707   float jresult ;
7708   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7709   float result;
7710
7711   arg1 = (Dali::Vector4 *)jarg1;
7712   result = (float) ((arg1)->z);
7713   jresult = result;
7714   return jresult;
7715 }
7716
7717
7718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7720   float arg2 ;
7721
7722   arg1 = (Dali::Vector4 *)jarg1;
7723   arg2 = (float)jarg2;
7724   if (arg1) (arg1)->b = arg2;
7725 }
7726
7727
7728 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7729   float jresult ;
7730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7731   float result;
7732
7733   arg1 = (Dali::Vector4 *)jarg1;
7734   result = (float) ((arg1)->b);
7735   jresult = result;
7736   return jresult;
7737 }
7738
7739
7740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7741   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7742   float arg2 ;
7743
7744   arg1 = (Dali::Vector4 *)jarg1;
7745   arg2 = (float)jarg2;
7746   if (arg1) (arg1)->p = arg2;
7747 }
7748
7749
7750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7751   float jresult ;
7752   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7753   float result;
7754
7755   arg1 = (Dali::Vector4 *)jarg1;
7756   result = (float) ((arg1)->p);
7757   jresult = result;
7758   return jresult;
7759 }
7760
7761
7762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7764   float arg2 ;
7765
7766   arg1 = (Dali::Vector4 *)jarg1;
7767   arg2 = (float)jarg2;
7768   if (arg1) (arg1)->w = arg2;
7769 }
7770
7771
7772 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7773   float jresult ;
7774   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7775   float result;
7776
7777   arg1 = (Dali::Vector4 *)jarg1;
7778   result = (float) ((arg1)->w);
7779   jresult = result;
7780   return jresult;
7781 }
7782
7783
7784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7785   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7786   float arg2 ;
7787
7788   arg1 = (Dali::Vector4 *)jarg1;
7789   arg2 = (float)jarg2;
7790   if (arg1) (arg1)->a = arg2;
7791 }
7792
7793
7794 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7795   float jresult ;
7796   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7797   float result;
7798
7799   arg1 = (Dali::Vector4 *)jarg1;
7800   result = (float) ((arg1)->a);
7801   jresult = result;
7802   return jresult;
7803 }
7804
7805
7806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7807   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7808   float arg2 ;
7809
7810   arg1 = (Dali::Vector4 *)jarg1;
7811   arg2 = (float)jarg2;
7812   if (arg1) (arg1)->q = arg2;
7813 }
7814
7815
7816 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7817   float jresult ;
7818   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7819   float result;
7820
7821   arg1 = (Dali::Vector4 *)jarg1;
7822   result = (float) ((arg1)->q);
7823   jresult = result;
7824   return jresult;
7825 }
7826
7827
7828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7829   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7830
7831   arg1 = (Dali::Vector4 *)jarg1;
7832   {
7833     try {
7834       delete arg1;
7835     } catch (std::out_of_range& e) {
7836       {
7837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7838       };
7839     } catch (std::exception& e) {
7840       {
7841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7842       };
7843     } catch (...) {
7844       {
7845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7846       };
7847     }
7848   }
7849 }
7850
7851
7852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7853   void * jresult ;
7854   Dali::Vector4 *arg1 = 0 ;
7855   Dali::Vector4 *arg2 = 0 ;
7856   Dali::Vector4 result;
7857
7858   arg1 = (Dali::Vector4 *)jarg1;
7859   if (!arg1) {
7860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7861     return 0;
7862   }
7863   arg2 = (Dali::Vector4 *)jarg2;
7864   if (!arg2) {
7865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7866     return 0;
7867   }
7868   {
7869     try {
7870       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7871     } catch (std::out_of_range& e) {
7872       {
7873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7874       };
7875     } catch (std::exception& e) {
7876       {
7877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7878       };
7879     } catch (...) {
7880       {
7881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7882       };
7883     }
7884   }
7885   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7886   return jresult;
7887 }
7888
7889
7890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7891   void * jresult ;
7892   Dali::Vector4 *arg1 = 0 ;
7893   Dali::Vector4 *arg2 = 0 ;
7894   Dali::Vector4 result;
7895
7896   arg1 = (Dali::Vector4 *)jarg1;
7897   if (!arg1) {
7898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7899     return 0;
7900   }
7901   arg2 = (Dali::Vector4 *)jarg2;
7902   if (!arg2) {
7903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7904     return 0;
7905   }
7906   {
7907     try {
7908       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7909     } catch (std::out_of_range& e) {
7910       {
7911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7912       };
7913     } catch (std::exception& e) {
7914       {
7915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7916       };
7917     } catch (...) {
7918       {
7919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7920       };
7921     }
7922   }
7923   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7924   return jresult;
7925 }
7926
7927
7928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
7929   void * jresult ;
7930   Dali::Vector4 *arg1 = 0 ;
7931   float *arg2 = 0 ;
7932   float *arg3 = 0 ;
7933   float temp2 ;
7934   float temp3 ;
7935   Dali::Vector4 result;
7936
7937   arg1 = (Dali::Vector4 *)jarg1;
7938   if (!arg1) {
7939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7940     return 0;
7941   }
7942   temp2 = (float)jarg2;
7943   arg2 = &temp2;
7944   temp3 = (float)jarg3;
7945   arg3 = &temp3;
7946   {
7947     try {
7948       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7949     } catch (std::out_of_range& e) {
7950       {
7951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7952       };
7953     } catch (std::exception& e) {
7954       {
7955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7956       };
7957     } catch (...) {
7958       {
7959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7960       };
7961     }
7962   }
7963   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7964   return jresult;
7965 }
7966
7967
7968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
7969   void * jresult ;
7970   Dali::Uint16Pair *result = 0 ;
7971
7972   {
7973     try {
7974       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
7975     } catch (std::out_of_range& e) {
7976       {
7977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7978       };
7979     } catch (std::exception& e) {
7980       {
7981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7982       };
7983     } catch (...) {
7984       {
7985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7986       };
7987     }
7988   }
7989   jresult = (void *)result;
7990   return jresult;
7991 }
7992
7993
7994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
7995   void * jresult ;
7996   uint32_t arg1 ;
7997   uint32_t arg2 ;
7998   Dali::Uint16Pair *result = 0 ;
7999
8000   arg1 = (uint32_t)jarg1;
8001   arg2 = (uint32_t)jarg2;
8002   {
8003     try {
8004       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8005     } catch (std::out_of_range& e) {
8006       {
8007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8008       };
8009     } catch (std::exception& e) {
8010       {
8011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8012       };
8013     } catch (...) {
8014       {
8015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8016       };
8017     }
8018   }
8019   jresult = (void *)result;
8020   return jresult;
8021 }
8022
8023
8024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8025   void * jresult ;
8026   Dali::Uint16Pair *arg1 = 0 ;
8027   Dali::Uint16Pair *result = 0 ;
8028
8029   arg1 = (Dali::Uint16Pair *)jarg1;
8030   if (!arg1) {
8031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8032     return 0;
8033   }
8034   {
8035     try {
8036       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8037     } catch (std::out_of_range& e) {
8038       {
8039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8040       };
8041     } catch (std::exception& e) {
8042       {
8043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (...) {
8046       {
8047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8048       };
8049     }
8050   }
8051   jresult = (void *)result;
8052   return jresult;
8053 }
8054
8055
8056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8057   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8058   uint16_t arg2 ;
8059
8060   arg1 = (Dali::Uint16Pair *)jarg1;
8061   arg2 = (uint16_t)jarg2;
8062   {
8063     try {
8064       (arg1)->SetWidth(arg2);
8065     } catch (std::out_of_range& e) {
8066       {
8067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8068       };
8069     } catch (std::exception& e) {
8070       {
8071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8072       };
8073     } catch (...) {
8074       {
8075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8076       };
8077     }
8078   }
8079 }
8080
8081
8082 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8083   unsigned short jresult ;
8084   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8085   uint16_t result;
8086
8087   arg1 = (Dali::Uint16Pair *)jarg1;
8088   {
8089     try {
8090       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8091     } catch (std::out_of_range& e) {
8092       {
8093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8094       };
8095     } catch (std::exception& e) {
8096       {
8097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8098       };
8099     } catch (...) {
8100       {
8101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8102       };
8103     }
8104   }
8105   jresult = result;
8106   return jresult;
8107 }
8108
8109
8110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8111   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8112   uint16_t arg2 ;
8113
8114   arg1 = (Dali::Uint16Pair *)jarg1;
8115   arg2 = (uint16_t)jarg2;
8116   {
8117     try {
8118       (arg1)->SetHeight(arg2);
8119     } catch (std::out_of_range& e) {
8120       {
8121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8122       };
8123     } catch (std::exception& e) {
8124       {
8125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8126       };
8127     } catch (...) {
8128       {
8129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8130       };
8131     }
8132   }
8133 }
8134
8135
8136 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8137   unsigned short jresult ;
8138   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8139   uint16_t result;
8140
8141   arg1 = (Dali::Uint16Pair *)jarg1;
8142   {
8143     try {
8144       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8145     } catch (std::out_of_range& e) {
8146       {
8147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8148       };
8149     } catch (std::exception& e) {
8150       {
8151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8152       };
8153     } catch (...) {
8154       {
8155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8156       };
8157     }
8158   }
8159   jresult = result;
8160   return jresult;
8161 }
8162
8163
8164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8165   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8166   uint16_t arg2 ;
8167
8168   arg1 = (Dali::Uint16Pair *)jarg1;
8169   arg2 = (uint16_t)jarg2;
8170   {
8171     try {
8172       (arg1)->SetX(arg2);
8173     } catch (std::out_of_range& e) {
8174       {
8175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8176       };
8177     } catch (std::exception& e) {
8178       {
8179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8180       };
8181     } catch (...) {
8182       {
8183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8184       };
8185     }
8186   }
8187 }
8188
8189
8190 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8191   unsigned short jresult ;
8192   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8193   uint16_t result;
8194
8195   arg1 = (Dali::Uint16Pair *)jarg1;
8196   {
8197     try {
8198       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8199     } catch (std::out_of_range& e) {
8200       {
8201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8202       };
8203     } catch (std::exception& e) {
8204       {
8205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8206       };
8207     } catch (...) {
8208       {
8209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8210       };
8211     }
8212   }
8213   jresult = result;
8214   return jresult;
8215 }
8216
8217
8218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8219   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8220   uint16_t arg2 ;
8221
8222   arg1 = (Dali::Uint16Pair *)jarg1;
8223   arg2 = (uint16_t)jarg2;
8224   {
8225     try {
8226       (arg1)->SetY(arg2);
8227     } catch (std::out_of_range& e) {
8228       {
8229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8230       };
8231     } catch (std::exception& e) {
8232       {
8233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8234       };
8235     } catch (...) {
8236       {
8237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8238       };
8239     }
8240   }
8241 }
8242
8243
8244 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8245   unsigned short jresult ;
8246   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8247   uint16_t result;
8248
8249   arg1 = (Dali::Uint16Pair *)jarg1;
8250   {
8251     try {
8252       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8253     } catch (std::out_of_range& e) {
8254       {
8255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8256       };
8257     } catch (std::exception& e) {
8258       {
8259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8260       };
8261     } catch (...) {
8262       {
8263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8264       };
8265     }
8266   }
8267   jresult = result;
8268   return jresult;
8269 }
8270
8271
8272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8273   void * jresult ;
8274   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8275   Dali::Uint16Pair *arg2 = 0 ;
8276   Dali::Uint16Pair *result = 0 ;
8277
8278   arg1 = (Dali::Uint16Pair *)jarg1;
8279   arg2 = (Dali::Uint16Pair *)jarg2;
8280   if (!arg2) {
8281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8282     return 0;
8283   }
8284   {
8285     try {
8286       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8287     } catch (std::out_of_range& e) {
8288       {
8289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8290       };
8291     } catch (std::exception& e) {
8292       {
8293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8294       };
8295     } catch (...) {
8296       {
8297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8298       };
8299     }
8300   }
8301   jresult = (void *)result;
8302   return jresult;
8303 }
8304
8305
8306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8307   unsigned int jresult ;
8308   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8309   Dali::Uint16Pair *arg2 = 0 ;
8310   bool result;
8311
8312   arg1 = (Dali::Uint16Pair *)jarg1;
8313   arg2 = (Dali::Uint16Pair *)jarg2;
8314   if (!arg2) {
8315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8316     return 0;
8317   }
8318   {
8319     try {
8320       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8321     } catch (std::out_of_range& e) {
8322       {
8323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8324       };
8325     } catch (std::exception& e) {
8326       {
8327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8328       };
8329     } catch (...) {
8330       {
8331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8332       };
8333     }
8334   }
8335   jresult = result;
8336   return jresult;
8337 }
8338
8339
8340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8341   unsigned int jresult ;
8342   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8343   Dali::Uint16Pair *arg2 = 0 ;
8344   bool result;
8345
8346   arg1 = (Dali::Uint16Pair *)jarg1;
8347   arg2 = (Dali::Uint16Pair *)jarg2;
8348   if (!arg2) {
8349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8350     return 0;
8351   }
8352   {
8353     try {
8354       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8355     } catch (std::out_of_range& e) {
8356       {
8357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8358       };
8359     } catch (std::exception& e) {
8360       {
8361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8362       };
8363     } catch (...) {
8364       {
8365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8366       };
8367     }
8368   }
8369   jresult = result;
8370   return jresult;
8371 }
8372
8373
8374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8375   unsigned int jresult ;
8376   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8377   Dali::Uint16Pair *arg2 = 0 ;
8378   bool result;
8379
8380   arg1 = (Dali::Uint16Pair *)jarg1;
8381   arg2 = (Dali::Uint16Pair *)jarg2;
8382   if (!arg2) {
8383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8384     return 0;
8385   }
8386   {
8387     try {
8388       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8389     } catch (std::out_of_range& e) {
8390       {
8391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8392       };
8393     } catch (std::exception& e) {
8394       {
8395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8396       };
8397     } catch (...) {
8398       {
8399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8400       };
8401     }
8402   }
8403   jresult = result;
8404   return jresult;
8405 }
8406
8407
8408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8409   unsigned int jresult ;
8410   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8411   Dali::Uint16Pair *arg2 = 0 ;
8412   bool result;
8413
8414   arg1 = (Dali::Uint16Pair *)jarg1;
8415   arg2 = (Dali::Uint16Pair *)jarg2;
8416   if (!arg2) {
8417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8418     return 0;
8419   }
8420   {
8421     try {
8422       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8423     } catch (std::out_of_range& e) {
8424       {
8425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8426       };
8427     } catch (std::exception& e) {
8428       {
8429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8430       };
8431     } catch (...) {
8432       {
8433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8434       };
8435     }
8436   }
8437   jresult = result;
8438   return jresult;
8439 }
8440
8441
8442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8443   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8444
8445   arg1 = (Dali::Uint16Pair *)jarg1;
8446   {
8447     try {
8448       delete arg1;
8449     } catch (std::out_of_range& e) {
8450       {
8451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8452       };
8453     } catch (std::exception& e) {
8454       {
8455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8456       };
8457     } catch (...) {
8458       {
8459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8460       };
8461     }
8462   }
8463 }
8464
8465
8466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8467   void * jresult ;
8468   Dali::Degree *result = 0 ;
8469
8470   {
8471     try {
8472       result = (Dali::Degree *)new Dali::Degree();
8473     } catch (std::out_of_range& e) {
8474       {
8475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8476       };
8477     } catch (std::exception& e) {
8478       {
8479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8480       };
8481     } catch (...) {
8482       {
8483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8484       };
8485     }
8486   }
8487   jresult = (void *)result;
8488   return jresult;
8489 }
8490
8491
8492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8493   void * jresult ;
8494   float arg1 ;
8495   Dali::Degree *result = 0 ;
8496
8497   arg1 = (float)jarg1;
8498   {
8499     try {
8500       result = (Dali::Degree *)new Dali::Degree(arg1);
8501     } catch (std::out_of_range& e) {
8502       {
8503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8504       };
8505     } catch (std::exception& e) {
8506       {
8507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8508       };
8509     } catch (...) {
8510       {
8511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8512       };
8513     }
8514   }
8515   jresult = (void *)result;
8516   return jresult;
8517 }
8518
8519
8520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8521   void * jresult ;
8522   Dali::Radian arg1 ;
8523   Dali::Radian *argp1 ;
8524   Dali::Degree *result = 0 ;
8525
8526   argp1 = (Dali::Radian *)jarg1;
8527   if (!argp1) {
8528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8529     return 0;
8530   }
8531   arg1 = *argp1;
8532   {
8533     try {
8534       result = (Dali::Degree *)new Dali::Degree(arg1);
8535     } catch (std::out_of_range& e) {
8536       {
8537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8538       };
8539     } catch (std::exception& e) {
8540       {
8541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8542       };
8543     } catch (...) {
8544       {
8545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8546       };
8547     }
8548   }
8549   jresult = (void *)result;
8550   return jresult;
8551 }
8552
8553
8554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8555   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8556   float arg2 ;
8557
8558   arg1 = (Dali::Degree *)jarg1;
8559   arg2 = (float)jarg2;
8560   if (arg1) (arg1)->degree = arg2;
8561 }
8562
8563
8564 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8565   float jresult ;
8566   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8567   float result;
8568
8569   arg1 = (Dali::Degree *)jarg1;
8570   result = (float) ((arg1)->degree);
8571   jresult = result;
8572   return jresult;
8573 }
8574
8575
8576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8577   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8578
8579   arg1 = (Dali::Degree *)jarg1;
8580   {
8581     try {
8582       delete arg1;
8583     } catch (std::out_of_range& e) {
8584       {
8585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8586       };
8587     } catch (std::exception& e) {
8588       {
8589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8590       };
8591     } catch (...) {
8592       {
8593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8594       };
8595     }
8596   }
8597 }
8598
8599
8600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8601   void * jresult ;
8602   Dali::Radian *result = 0 ;
8603
8604   result = (Dali::Radian *)&Dali::ANGLE_360;
8605   jresult = (void *)result;
8606   return jresult;
8607 }
8608
8609
8610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8611   void * jresult ;
8612   Dali::Radian *result = 0 ;
8613
8614   result = (Dali::Radian *)&Dali::ANGLE_315;
8615   jresult = (void *)result;
8616   return jresult;
8617 }
8618
8619
8620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8621   void * jresult ;
8622   Dali::Radian *result = 0 ;
8623
8624   result = (Dali::Radian *)&Dali::ANGLE_270;
8625   jresult = (void *)result;
8626   return jresult;
8627 }
8628
8629
8630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8631   void * jresult ;
8632   Dali::Radian *result = 0 ;
8633
8634   result = (Dali::Radian *)&Dali::ANGLE_225;
8635   jresult = (void *)result;
8636   return jresult;
8637 }
8638
8639
8640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8641   void * jresult ;
8642   Dali::Radian *result = 0 ;
8643
8644   result = (Dali::Radian *)&Dali::ANGLE_180;
8645   jresult = (void *)result;
8646   return jresult;
8647 }
8648
8649
8650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8651   void * jresult ;
8652   Dali::Radian *result = 0 ;
8653
8654   result = (Dali::Radian *)&Dali::ANGLE_135;
8655   jresult = (void *)result;
8656   return jresult;
8657 }
8658
8659
8660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8661   void * jresult ;
8662   Dali::Radian *result = 0 ;
8663
8664   result = (Dali::Radian *)&Dali::ANGLE_120;
8665   jresult = (void *)result;
8666   return jresult;
8667 }
8668
8669
8670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8671   void * jresult ;
8672   Dali::Radian *result = 0 ;
8673
8674   result = (Dali::Radian *)&Dali::ANGLE_90;
8675   jresult = (void *)result;
8676   return jresult;
8677 }
8678
8679
8680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8681   void * jresult ;
8682   Dali::Radian *result = 0 ;
8683
8684   result = (Dali::Radian *)&Dali::ANGLE_60;
8685   jresult = (void *)result;
8686   return jresult;
8687 }
8688
8689
8690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8691   void * jresult ;
8692   Dali::Radian *result = 0 ;
8693
8694   result = (Dali::Radian *)&Dali::ANGLE_45;
8695   jresult = (void *)result;
8696   return jresult;
8697 }
8698
8699
8700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8701   void * jresult ;
8702   Dali::Radian *result = 0 ;
8703
8704   result = (Dali::Radian *)&Dali::ANGLE_30;
8705   jresult = (void *)result;
8706   return jresult;
8707 }
8708
8709
8710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8711   void * jresult ;
8712   Dali::Radian *result = 0 ;
8713
8714   result = (Dali::Radian *)&Dali::ANGLE_0;
8715   jresult = (void *)result;
8716   return jresult;
8717 }
8718
8719
8720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8721   unsigned int jresult ;
8722   Dali::Degree *arg1 = 0 ;
8723   Dali::Degree *arg2 = 0 ;
8724   bool result;
8725
8726   arg1 = (Dali::Degree *)jarg1;
8727   if (!arg1) {
8728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8729     return 0;
8730   }
8731   arg2 = (Dali::Degree *)jarg2;
8732   if (!arg2) {
8733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8734     return 0;
8735   }
8736   {
8737     try {
8738       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8739     } catch (std::out_of_range& e) {
8740       {
8741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8742       };
8743     } catch (std::exception& e) {
8744       {
8745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8746       };
8747     } catch (...) {
8748       {
8749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8750       };
8751     }
8752   }
8753   jresult = result;
8754   return jresult;
8755 }
8756
8757
8758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8759   unsigned int jresult ;
8760   Dali::Degree *arg1 = 0 ;
8761   Dali::Degree *arg2 = 0 ;
8762   bool result;
8763
8764   arg1 = (Dali::Degree *)jarg1;
8765   if (!arg1) {
8766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8767     return 0;
8768   }
8769   arg2 = (Dali::Degree *)jarg2;
8770   if (!arg2) {
8771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8772     return 0;
8773   }
8774   {
8775     try {
8776       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8777     } catch (std::out_of_range& e) {
8778       {
8779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8780       };
8781     } catch (std::exception& e) {
8782       {
8783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8784       };
8785     } catch (...) {
8786       {
8787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8788       };
8789     }
8790   }
8791   jresult = result;
8792   return jresult;
8793 }
8794
8795
8796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8797   void * jresult ;
8798   Dali::Degree arg1 ;
8799   float arg2 ;
8800   float arg3 ;
8801   Dali::Degree *argp1 ;
8802   Dali::Degree result;
8803
8804   argp1 = (Dali::Degree *)jarg1;
8805   if (!argp1) {
8806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8807     return 0;
8808   }
8809   arg1 = *argp1;
8810   arg2 = (float)jarg2;
8811   arg3 = (float)jarg3;
8812   {
8813     try {
8814       result = Dali::Clamp(arg1,arg2,arg3);
8815     } catch (std::out_of_range& e) {
8816       {
8817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8818       };
8819     } catch (std::exception& e) {
8820       {
8821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8822       };
8823     } catch (...) {
8824       {
8825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8826       };
8827     }
8828   }
8829   jresult = new Dali::Degree((const Dali::Degree &)result);
8830   return jresult;
8831 }
8832
8833
8834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8835   void * jresult ;
8836   Dali::Radian *result = 0 ;
8837
8838   {
8839     try {
8840       result = (Dali::Radian *)new Dali::Radian();
8841     } catch (std::out_of_range& e) {
8842       {
8843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8844       };
8845     } catch (std::exception& e) {
8846       {
8847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8848       };
8849     } catch (...) {
8850       {
8851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8852       };
8853     }
8854   }
8855   jresult = (void *)result;
8856   return jresult;
8857 }
8858
8859
8860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8861   void * jresult ;
8862   float arg1 ;
8863   Dali::Radian *result = 0 ;
8864
8865   arg1 = (float)jarg1;
8866   {
8867     try {
8868       result = (Dali::Radian *)new Dali::Radian(arg1);
8869     } catch (std::out_of_range& e) {
8870       {
8871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8872       };
8873     } catch (std::exception& e) {
8874       {
8875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8876       };
8877     } catch (...) {
8878       {
8879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8880       };
8881     }
8882   }
8883   jresult = (void *)result;
8884   return jresult;
8885 }
8886
8887
8888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8889   void * jresult ;
8890   Dali::Degree arg1 ;
8891   Dali::Degree *argp1 ;
8892   Dali::Radian *result = 0 ;
8893
8894   argp1 = (Dali::Degree *)jarg1;
8895   if (!argp1) {
8896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8897     return 0;
8898   }
8899   arg1 = *argp1;
8900   {
8901     try {
8902       result = (Dali::Radian *)new Dali::Radian(arg1);
8903     } catch (std::out_of_range& e) {
8904       {
8905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8906       };
8907     } catch (std::exception& e) {
8908       {
8909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8910       };
8911     } catch (...) {
8912       {
8913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8914       };
8915     }
8916   }
8917   jresult = (void *)result;
8918   return jresult;
8919 }
8920
8921
8922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
8923   void * jresult ;
8924   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8925   float arg2 ;
8926   Dali::Radian *result = 0 ;
8927
8928   arg1 = (Dali::Radian *)jarg1;
8929   arg2 = (float)jarg2;
8930   {
8931     try {
8932       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8933     } catch (std::out_of_range& e) {
8934       {
8935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8936       };
8937     } catch (std::exception& e) {
8938       {
8939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8940       };
8941     } catch (...) {
8942       {
8943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8944       };
8945     }
8946   }
8947   jresult = (void *)result;
8948   return jresult;
8949 }
8950
8951
8952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
8953   void * jresult ;
8954   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8955   Dali::Degree arg2 ;
8956   Dali::Degree *argp2 ;
8957   Dali::Radian *result = 0 ;
8958
8959   arg1 = (Dali::Radian *)jarg1;
8960   argp2 = (Dali::Degree *)jarg2;
8961   if (!argp2) {
8962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8963     return 0;
8964   }
8965   arg2 = *argp2;
8966   {
8967     try {
8968       result = (Dali::Radian *) &(arg1)->operator =(arg2);
8969     } catch (std::out_of_range& e) {
8970       {
8971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8972       };
8973     } catch (std::exception& e) {
8974       {
8975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8976       };
8977     } catch (...) {
8978       {
8979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8980       };
8981     }
8982   }
8983   jresult = (void *)result;
8984   return jresult;
8985 }
8986
8987
8988 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
8989   float jresult ;
8990   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
8991   float result;
8992
8993   arg1 = (Dali::Radian *)jarg1;
8994   {
8995     try {
8996       result = (float)((Dali::Radian const *)arg1)->operator float();
8997     } catch (std::out_of_range& e) {
8998       {
8999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9000       };
9001     } catch (std::exception& e) {
9002       {
9003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9004       };
9005     } catch (...) {
9006       {
9007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9008       };
9009     }
9010   }
9011   jresult = result;
9012   return jresult;
9013 }
9014
9015
9016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9017   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9018   float arg2 ;
9019
9020   arg1 = (Dali::Radian *)jarg1;
9021   arg2 = (float)jarg2;
9022   if (arg1) (arg1)->radian = arg2;
9023 }
9024
9025
9026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9027   float jresult ;
9028   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9029   float result;
9030
9031   arg1 = (Dali::Radian *)jarg1;
9032   result = (float) ((arg1)->radian);
9033   jresult = result;
9034   return jresult;
9035 }
9036
9037
9038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9039   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9040
9041   arg1 = (Dali::Radian *)jarg1;
9042   {
9043     try {
9044       delete arg1;
9045     } catch (std::out_of_range& e) {
9046       {
9047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9048       };
9049     } catch (std::exception& e) {
9050       {
9051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9052       };
9053     } catch (...) {
9054       {
9055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9056       };
9057     }
9058   }
9059 }
9060
9061
9062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9063   unsigned int jresult ;
9064   Dali::Radian arg1 ;
9065   Dali::Radian arg2 ;
9066   Dali::Radian *argp1 ;
9067   Dali::Radian *argp2 ;
9068   bool result;
9069
9070   argp1 = (Dali::Radian *)jarg1;
9071   if (!argp1) {
9072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9073     return 0;
9074   }
9075   arg1 = *argp1;
9076   argp2 = (Dali::Radian *)jarg2;
9077   if (!argp2) {
9078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9079     return 0;
9080   }
9081   arg2 = *argp2;
9082   {
9083     try {
9084       result = (bool)Dali::operator ==(arg1,arg2);
9085     } catch (std::out_of_range& e) {
9086       {
9087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9088       };
9089     } catch (std::exception& e) {
9090       {
9091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9092       };
9093     } catch (...) {
9094       {
9095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9096       };
9097     }
9098   }
9099   jresult = result;
9100   return jresult;
9101 }
9102
9103
9104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9105   unsigned int jresult ;
9106   Dali::Radian arg1 ;
9107   Dali::Radian arg2 ;
9108   Dali::Radian *argp1 ;
9109   Dali::Radian *argp2 ;
9110   bool result;
9111
9112   argp1 = (Dali::Radian *)jarg1;
9113   if (!argp1) {
9114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9115     return 0;
9116   }
9117   arg1 = *argp1;
9118   argp2 = (Dali::Radian *)jarg2;
9119   if (!argp2) {
9120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9121     return 0;
9122   }
9123   arg2 = *argp2;
9124   {
9125     try {
9126       result = (bool)Dali::operator !=(arg1,arg2);
9127     } catch (std::out_of_range& e) {
9128       {
9129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9130       };
9131     } catch (std::exception& e) {
9132       {
9133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9134       };
9135     } catch (...) {
9136       {
9137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9138       };
9139     }
9140   }
9141   jresult = result;
9142   return jresult;
9143 }
9144
9145
9146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9147   unsigned int jresult ;
9148   Dali::Radian arg1 ;
9149   Dali::Degree arg2 ;
9150   Dali::Radian *argp1 ;
9151   Dali::Degree *argp2 ;
9152   bool result;
9153
9154   argp1 = (Dali::Radian *)jarg1;
9155   if (!argp1) {
9156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9157     return 0;
9158   }
9159   arg1 = *argp1;
9160   argp2 = (Dali::Degree *)jarg2;
9161   if (!argp2) {
9162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9163     return 0;
9164   }
9165   arg2 = *argp2;
9166   {
9167     try {
9168       result = (bool)Dali::operator ==(arg1,arg2);
9169     } catch (std::out_of_range& e) {
9170       {
9171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9172       };
9173     } catch (std::exception& e) {
9174       {
9175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9176       };
9177     } catch (...) {
9178       {
9179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9180       };
9181     }
9182   }
9183   jresult = result;
9184   return jresult;
9185 }
9186
9187
9188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9189   unsigned int jresult ;
9190   Dali::Radian arg1 ;
9191   Dali::Degree arg2 ;
9192   Dali::Radian *argp1 ;
9193   Dali::Degree *argp2 ;
9194   bool result;
9195
9196   argp1 = (Dali::Radian *)jarg1;
9197   if (!argp1) {
9198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9199     return 0;
9200   }
9201   arg1 = *argp1;
9202   argp2 = (Dali::Degree *)jarg2;
9203   if (!argp2) {
9204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9205     return 0;
9206   }
9207   arg2 = *argp2;
9208   {
9209     try {
9210       result = (bool)Dali::operator !=(arg1,arg2);
9211     } catch (std::out_of_range& e) {
9212       {
9213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9214       };
9215     } catch (std::exception& e) {
9216       {
9217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9218       };
9219     } catch (...) {
9220       {
9221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9222       };
9223     }
9224   }
9225   jresult = result;
9226   return jresult;
9227 }
9228
9229
9230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9231   unsigned int jresult ;
9232   Dali::Degree arg1 ;
9233   Dali::Radian arg2 ;
9234   Dali::Degree *argp1 ;
9235   Dali::Radian *argp2 ;
9236   bool result;
9237
9238   argp1 = (Dali::Degree *)jarg1;
9239   if (!argp1) {
9240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9241     return 0;
9242   }
9243   arg1 = *argp1;
9244   argp2 = (Dali::Radian *)jarg2;
9245   if (!argp2) {
9246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9247     return 0;
9248   }
9249   arg2 = *argp2;
9250   {
9251     try {
9252       result = (bool)Dali::operator ==(arg1,arg2);
9253     } catch (std::out_of_range& e) {
9254       {
9255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9256       };
9257     } catch (std::exception& e) {
9258       {
9259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9260       };
9261     } catch (...) {
9262       {
9263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9264       };
9265     }
9266   }
9267   jresult = result;
9268   return jresult;
9269 }
9270
9271
9272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9273   unsigned int jresult ;
9274   Dali::Degree arg1 ;
9275   Dali::Radian arg2 ;
9276   Dali::Degree *argp1 ;
9277   Dali::Radian *argp2 ;
9278   bool result;
9279
9280   argp1 = (Dali::Degree *)jarg1;
9281   if (!argp1) {
9282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9283     return 0;
9284   }
9285   arg1 = *argp1;
9286   argp2 = (Dali::Radian *)jarg2;
9287   if (!argp2) {
9288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9289     return 0;
9290   }
9291   arg2 = *argp2;
9292   {
9293     try {
9294       result = (bool)Dali::operator !=(arg1,arg2);
9295     } catch (std::out_of_range& e) {
9296       {
9297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9298       };
9299     } catch (std::exception& e) {
9300       {
9301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9302       };
9303     } catch (...) {
9304       {
9305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9306       };
9307     }
9308   }
9309   jresult = result;
9310   return jresult;
9311 }
9312
9313
9314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9315   unsigned int jresult ;
9316   Dali::Radian arg1 ;
9317   Dali::Radian arg2 ;
9318   Dali::Radian *argp1 ;
9319   Dali::Radian *argp2 ;
9320   bool result;
9321
9322   argp1 = (Dali::Radian *)jarg1;
9323   if (!argp1) {
9324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9325     return 0;
9326   }
9327   arg1 = *argp1;
9328   argp2 = (Dali::Radian *)jarg2;
9329   if (!argp2) {
9330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9331     return 0;
9332   }
9333   arg2 = *argp2;
9334   {
9335     try {
9336       result = (bool)Dali::operator >(arg1,arg2);
9337     } catch (std::out_of_range& e) {
9338       {
9339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9340       };
9341     } catch (std::exception& e) {
9342       {
9343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9344       };
9345     } catch (...) {
9346       {
9347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9348       };
9349     }
9350   }
9351   jresult = result;
9352   return jresult;
9353 }
9354
9355
9356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9357   unsigned int jresult ;
9358   Dali::Radian arg1 ;
9359   Dali::Degree arg2 ;
9360   Dali::Radian *argp1 ;
9361   Dali::Degree *argp2 ;
9362   bool result;
9363
9364   argp1 = (Dali::Radian *)jarg1;
9365   if (!argp1) {
9366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9367     return 0;
9368   }
9369   arg1 = *argp1;
9370   argp2 = (Dali::Degree *)jarg2;
9371   if (!argp2) {
9372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9373     return 0;
9374   }
9375   arg2 = *argp2;
9376   {
9377     try {
9378       result = (bool)Dali::operator >(arg1,arg2);
9379     } catch (std::out_of_range& e) {
9380       {
9381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9382       };
9383     } catch (std::exception& e) {
9384       {
9385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9386       };
9387     } catch (...) {
9388       {
9389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9390       };
9391     }
9392   }
9393   jresult = result;
9394   return jresult;
9395 }
9396
9397
9398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9399   unsigned int jresult ;
9400   Dali::Degree arg1 ;
9401   Dali::Radian arg2 ;
9402   Dali::Degree *argp1 ;
9403   Dali::Radian *argp2 ;
9404   bool result;
9405
9406   argp1 = (Dali::Degree *)jarg1;
9407   if (!argp1) {
9408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9409     return 0;
9410   }
9411   arg1 = *argp1;
9412   argp2 = (Dali::Radian *)jarg2;
9413   if (!argp2) {
9414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9415     return 0;
9416   }
9417   arg2 = *argp2;
9418   {
9419     try {
9420       result = (bool)Dali::operator >(arg1,arg2);
9421     } catch (std::out_of_range& e) {
9422       {
9423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9424       };
9425     } catch (std::exception& e) {
9426       {
9427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9428       };
9429     } catch (...) {
9430       {
9431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9432       };
9433     }
9434   }
9435   jresult = result;
9436   return jresult;
9437 }
9438
9439
9440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9441   unsigned int jresult ;
9442   Dali::Radian arg1 ;
9443   Dali::Radian arg2 ;
9444   Dali::Radian *argp1 ;
9445   Dali::Radian *argp2 ;
9446   bool result;
9447
9448   argp1 = (Dali::Radian *)jarg1;
9449   if (!argp1) {
9450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9451     return 0;
9452   }
9453   arg1 = *argp1;
9454   argp2 = (Dali::Radian *)jarg2;
9455   if (!argp2) {
9456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9457     return 0;
9458   }
9459   arg2 = *argp2;
9460   {
9461     try {
9462       result = (bool)Dali::operator <(arg1,arg2);
9463     } catch (std::out_of_range& e) {
9464       {
9465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9466       };
9467     } catch (std::exception& e) {
9468       {
9469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9470       };
9471     } catch (...) {
9472       {
9473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9474       };
9475     }
9476   }
9477   jresult = result;
9478   return jresult;
9479 }
9480
9481
9482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9483   unsigned int jresult ;
9484   Dali::Radian arg1 ;
9485   Dali::Degree arg2 ;
9486   Dali::Radian *argp1 ;
9487   Dali::Degree *argp2 ;
9488   bool result;
9489
9490   argp1 = (Dali::Radian *)jarg1;
9491   if (!argp1) {
9492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9493     return 0;
9494   }
9495   arg1 = *argp1;
9496   argp2 = (Dali::Degree *)jarg2;
9497   if (!argp2) {
9498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9499     return 0;
9500   }
9501   arg2 = *argp2;
9502   {
9503     try {
9504       result = (bool)Dali::operator <(arg1,arg2);
9505     } catch (std::out_of_range& e) {
9506       {
9507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9508       };
9509     } catch (std::exception& e) {
9510       {
9511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9512       };
9513     } catch (...) {
9514       {
9515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9516       };
9517     }
9518   }
9519   jresult = result;
9520   return jresult;
9521 }
9522
9523
9524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9525   unsigned int jresult ;
9526   Dali::Degree arg1 ;
9527   Dali::Radian arg2 ;
9528   Dali::Degree *argp1 ;
9529   Dali::Radian *argp2 ;
9530   bool result;
9531
9532   argp1 = (Dali::Degree *)jarg1;
9533   if (!argp1) {
9534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9535     return 0;
9536   }
9537   arg1 = *argp1;
9538   argp2 = (Dali::Radian *)jarg2;
9539   if (!argp2) {
9540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9541     return 0;
9542   }
9543   arg2 = *argp2;
9544   {
9545     try {
9546       result = (bool)Dali::operator <(arg1,arg2);
9547     } catch (std::out_of_range& e) {
9548       {
9549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9550       };
9551     } catch (std::exception& e) {
9552       {
9553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9554       };
9555     } catch (...) {
9556       {
9557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9558       };
9559     }
9560   }
9561   jresult = result;
9562   return jresult;
9563 }
9564
9565
9566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9567   void * jresult ;
9568   Dali::Radian arg1 ;
9569   float arg2 ;
9570   Dali::Radian *argp1 ;
9571   Dali::Radian result;
9572
9573   argp1 = (Dali::Radian *)jarg1;
9574   if (!argp1) {
9575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9576     return 0;
9577   }
9578   arg1 = *argp1;
9579   arg2 = (float)jarg2;
9580   {
9581     try {
9582       result = Dali::operator *(arg1,arg2);
9583     } catch (std::out_of_range& e) {
9584       {
9585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9586       };
9587     } catch (std::exception& e) {
9588       {
9589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9590       };
9591     } catch (...) {
9592       {
9593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9594       };
9595     }
9596   }
9597   jresult = new Dali::Radian((const Dali::Radian &)result);
9598   return jresult;
9599 }
9600
9601
9602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9603   void * jresult ;
9604   Dali::Radian arg1 ;
9605   Dali::Radian *argp1 ;
9606   Dali::Radian result;
9607
9608   argp1 = (Dali::Radian *)jarg1;
9609   if (!argp1) {
9610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9611     return 0;
9612   }
9613   arg1 = *argp1;
9614   {
9615     try {
9616       result = Dali::operator -(arg1);
9617     } catch (std::out_of_range& e) {
9618       {
9619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9620       };
9621     } catch (std::exception& e) {
9622       {
9623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9624       };
9625     } catch (...) {
9626       {
9627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9628       };
9629     }
9630   }
9631   jresult = new Dali::Radian((const Dali::Radian &)result);
9632   return jresult;
9633 }
9634
9635
9636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9637   void * jresult ;
9638   Dali::Radian arg1 ;
9639   float arg2 ;
9640   float arg3 ;
9641   Dali::Radian *argp1 ;
9642   Dali::Radian result;
9643
9644   argp1 = (Dali::Radian *)jarg1;
9645   if (!argp1) {
9646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9647     return 0;
9648   }
9649   arg1 = *argp1;
9650   arg2 = (float)jarg2;
9651   arg3 = (float)jarg3;
9652   {
9653     try {
9654       result = Dali::Clamp(arg1,arg2,arg3);
9655     } catch (std::out_of_range& e) {
9656       {
9657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9658       };
9659     } catch (std::exception& e) {
9660       {
9661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9662       };
9663     } catch (...) {
9664       {
9665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9666       };
9667     }
9668   }
9669   jresult = new Dali::Radian((const Dali::Radian &)result);
9670   return jresult;
9671 }
9672
9673
9674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_0() {
9675   void * jresult ;
9676   Dali::Quaternion *result = 0 ;
9677
9678   {
9679     try {
9680       result = (Dali::Quaternion *)new Dali::Quaternion();
9681     } catch (std::out_of_range& e) {
9682       {
9683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9684       };
9685     } catch (std::exception& e) {
9686       {
9687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9688       };
9689     } catch (...) {
9690       {
9691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9692       };
9693     }
9694   }
9695   jresult = (void *)result;
9696   return jresult;
9697 }
9698
9699
9700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
9701   void * jresult ;
9702   float arg1 ;
9703   float arg2 ;
9704   float arg3 ;
9705   float arg4 ;
9706   Dali::Quaternion *result = 0 ;
9707
9708   arg1 = (float)jarg1;
9709   arg2 = (float)jarg2;
9710   arg3 = (float)jarg3;
9711   arg4 = (float)jarg4;
9712   {
9713     try {
9714       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,arg2,arg3,arg4);
9715     } catch (std::out_of_range& e) {
9716       {
9717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9718       };
9719     } catch (std::exception& e) {
9720       {
9721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9722       };
9723     } catch (...) {
9724       {
9725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9726       };
9727     }
9728   }
9729   jresult = (void *)result;
9730   return jresult;
9731 }
9732
9733
9734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_2(void * jarg1) {
9735   void * jresult ;
9736   Dali::Vector4 *arg1 = 0 ;
9737   Dali::Quaternion *result = 0 ;
9738
9739   arg1 = (Dali::Vector4 *)jarg1;
9740   if (!arg1) {
9741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
9742     return 0;
9743   }
9744   {
9745     try {
9746       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Vector4 const &)*arg1);
9747     } catch (std::out_of_range& e) {
9748       {
9749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9750       };
9751     } catch (std::exception& e) {
9752       {
9753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9754       };
9755     } catch (...) {
9756       {
9757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9758       };
9759     }
9760   }
9761   jresult = (void *)result;
9762   return jresult;
9763 }
9764
9765
9766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_3(void * jarg1, void * jarg2) {
9767   void * jresult ;
9768   Dali::Radian arg1 ;
9769   Dali::Vector3 *arg2 = 0 ;
9770   Dali::Radian *argp1 ;
9771   Dali::Quaternion *result = 0 ;
9772
9773   argp1 = (Dali::Radian *)jarg1;
9774   if (!argp1) {
9775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9776     return 0;
9777   }
9778   arg1 = *argp1;
9779   arg2 = (Dali::Vector3 *)jarg2;
9780   if (!arg2) {
9781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9782     return 0;
9783   }
9784   {
9785     try {
9786       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9787     } catch (std::out_of_range& e) {
9788       {
9789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9790       };
9791     } catch (std::exception& e) {
9792       {
9793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9794       };
9795     } catch (...) {
9796       {
9797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9798       };
9799     }
9800   }
9801   jresult = (void *)result;
9802   return jresult;
9803 }
9804
9805
9806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
9807   void * jresult ;
9808   Dali::Radian arg1 ;
9809   Dali::Radian arg2 ;
9810   Dali::Radian arg3 ;
9811   Dali::Radian *argp1 ;
9812   Dali::Radian *argp2 ;
9813   Dali::Radian *argp3 ;
9814   Dali::Quaternion *result = 0 ;
9815
9816   argp1 = (Dali::Radian *)jarg1;
9817   if (!argp1) {
9818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9819     return 0;
9820   }
9821   arg1 = *argp1;
9822   argp2 = (Dali::Radian *)jarg2;
9823   if (!argp2) {
9824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9825     return 0;
9826   }
9827   arg2 = *argp2;
9828   argp3 = (Dali::Radian *)jarg3;
9829   if (!argp3) {
9830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9831     return 0;
9832   }
9833   arg3 = *argp3;
9834   {
9835     try {
9836       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,arg2,arg3);
9837     } catch (std::out_of_range& e) {
9838       {
9839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9840       };
9841     } catch (std::exception& e) {
9842       {
9843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9844       };
9845     } catch (...) {
9846       {
9847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9848       };
9849     }
9850   }
9851   jresult = (void *)result;
9852   return jresult;
9853 }
9854
9855
9856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_5(void * jarg1) {
9857   void * jresult ;
9858   Dali::Matrix *arg1 = 0 ;
9859   Dali::Quaternion *result = 0 ;
9860
9861   arg1 = (Dali::Matrix *)jarg1;
9862   if (!arg1) {
9863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
9864     return 0;
9865   }
9866   {
9867     try {
9868       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Matrix const &)*arg1);
9869     } catch (std::out_of_range& e) {
9870       {
9871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9872       };
9873     } catch (std::exception& e) {
9874       {
9875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9876       };
9877     } catch (...) {
9878       {
9879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9880       };
9881     }
9882   }
9883   jresult = (void *)result;
9884   return jresult;
9885 }
9886
9887
9888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_6(void * jarg1, void * jarg2, void * jarg3) {
9889   void * jresult ;
9890   Dali::Vector3 *arg1 = 0 ;
9891   Dali::Vector3 *arg2 = 0 ;
9892   Dali::Vector3 *arg3 = 0 ;
9893   Dali::Quaternion *result = 0 ;
9894
9895   arg1 = (Dali::Vector3 *)jarg1;
9896   if (!arg1) {
9897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9898     return 0;
9899   }
9900   arg2 = (Dali::Vector3 *)jarg2;
9901   if (!arg2) {
9902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9903     return 0;
9904   }
9905   arg3 = (Dali::Vector3 *)jarg3;
9906   if (!arg3) {
9907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9908     return 0;
9909   }
9910   {
9911     try {
9912       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
9913     } catch (std::out_of_range& e) {
9914       {
9915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9916       };
9917     } catch (std::exception& e) {
9918       {
9919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9920       };
9921     } catch (...) {
9922       {
9923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9924       };
9925     }
9926   }
9927   jresult = (void *)result;
9928   return jresult;
9929 }
9930
9931
9932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Quaternion__SWIG_7(void * jarg1, void * jarg2) {
9933   void * jresult ;
9934   Dali::Vector3 *arg1 = 0 ;
9935   Dali::Vector3 *arg2 = 0 ;
9936   Dali::Quaternion *result = 0 ;
9937
9938   arg1 = (Dali::Vector3 *)jarg1;
9939   if (!arg1) {
9940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9941     return 0;
9942   }
9943   arg2 = (Dali::Vector3 *)jarg2;
9944   if (!arg2) {
9945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9946     return 0;
9947   }
9948   {
9949     try {
9950       result = (Dali::Quaternion *)new Dali::Quaternion((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
9951     } catch (std::out_of_range& e) {
9952       {
9953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9954       };
9955     } catch (std::exception& e) {
9956       {
9957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9958       };
9959     } catch (...) {
9960       {
9961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9962       };
9963     }
9964   }
9965   jresult = (void *)result;
9966   return jresult;
9967 }
9968
9969
9970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Quaternion(void * jarg1) {
9971   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9972
9973   arg1 = (Dali::Quaternion *)jarg1;
9974   {
9975     try {
9976       delete arg1;
9977     } catch (std::out_of_range& e) {
9978       {
9979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9980       };
9981     } catch (std::exception& e) {
9982       {
9983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9984       };
9985     } catch (...) {
9986       {
9987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9988       };
9989     }
9990   }
9991 }
9992
9993
9994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_IDENTITY_get() {
9995   void * jresult ;
9996   Dali::Quaternion *result = 0 ;
9997
9998   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9999   jresult = (void *)result;
10000   return jresult;
10001 }
10002
10003
10004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Quaternion_IsIdentity(void * jarg1) {
10005   unsigned int jresult ;
10006   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10007   bool result;
10008
10009   arg1 = (Dali::Quaternion *)jarg1;
10010   {
10011     try {
10012       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10013     } catch (std::out_of_range& e) {
10014       {
10015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10016       };
10017     } catch (std::exception& e) {
10018       {
10019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10020       };
10021     } catch (...) {
10022       {
10023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10024       };
10025     }
10026   }
10027   jresult = result;
10028   return jresult;
10029 }
10030
10031
10032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Quaternion_ToAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
10033   unsigned int jresult ;
10034   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10035   Dali::Vector3 *arg2 = 0 ;
10036   Dali::Radian *arg3 = 0 ;
10037   bool result;
10038
10039   arg1 = (Dali::Quaternion *)jarg1;
10040   arg2 = (Dali::Vector3 *)jarg2;
10041   if (!arg2) {
10042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
10043     return 0;
10044   }
10045   arg3 = (Dali::Radian *)jarg3;
10046   if (!arg3) {
10047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
10048     return 0;
10049   }
10050   {
10051     try {
10052       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
10053     } catch (std::out_of_range& e) {
10054       {
10055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10056       };
10057     } catch (std::exception& e) {
10058       {
10059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10060       };
10061     } catch (...) {
10062       {
10063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10064       };
10065     }
10066   }
10067   jresult = result;
10068   return jresult;
10069 }
10070
10071
10072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_AsVector(void * jarg1) {
10073   void * jresult ;
10074   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10075   Dali::Vector4 *result = 0 ;
10076
10077   arg1 = (Dali::Quaternion *)jarg1;
10078   {
10079     try {
10080       result = (Dali::Vector4 *) &((Dali::Quaternion const *)arg1)->AsVector();
10081     } catch (std::out_of_range& e) {
10082       {
10083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10084       };
10085     } catch (std::exception& e) {
10086       {
10087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10088       };
10089     } catch (...) {
10090       {
10091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10092       };
10093     }
10094   }
10095   jresult = (void *)result;
10096   return jresult;
10097 }
10098
10099
10100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Quaternion_SetEuler(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
10101   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10102   Dali::Radian arg2 ;
10103   Dali::Radian arg3 ;
10104   Dali::Radian arg4 ;
10105   Dali::Radian *argp2 ;
10106   Dali::Radian *argp3 ;
10107   Dali::Radian *argp4 ;
10108
10109   arg1 = (Dali::Quaternion *)jarg1;
10110   argp2 = (Dali::Radian *)jarg2;
10111   if (!argp2) {
10112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10113     return ;
10114   }
10115   arg2 = *argp2;
10116   argp3 = (Dali::Radian *)jarg3;
10117   if (!argp3) {
10118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10119     return ;
10120   }
10121   arg3 = *argp3;
10122   argp4 = (Dali::Radian *)jarg4;
10123   if (!argp4) {
10124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10125     return ;
10126   }
10127   arg4 = *argp4;
10128   {
10129     try {
10130       (arg1)->SetEuler(arg2,arg3,arg4);
10131     } catch (std::out_of_range& e) {
10132       {
10133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10134       };
10135     } catch (std::exception& e) {
10136       {
10137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10138       };
10139     } catch (...) {
10140       {
10141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10142       };
10143     }
10144   }
10145 }
10146
10147
10148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_EulerAngles(void * jarg1) {
10149   void * jresult ;
10150   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10151   Dali::Vector4 result;
10152
10153   arg1 = (Dali::Quaternion *)jarg1;
10154   {
10155     try {
10156       result = ((Dali::Quaternion const *)arg1)->EulerAngles();
10157     } catch (std::out_of_range& e) {
10158       {
10159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10160       };
10161     } catch (std::exception& e) {
10162       {
10163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10164       };
10165     } catch (...) {
10166       {
10167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10168       };
10169     }
10170   }
10171   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
10172   return jresult;
10173 }
10174
10175
10176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Add(void * jarg1, void * jarg2) {
10177   void * jresult ;
10178   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10179   Dali::Quaternion *arg2 = 0 ;
10180   Dali::Quaternion result;
10181
10182   arg1 = (Dali::Quaternion *)jarg1;
10183   arg2 = (Dali::Quaternion *)jarg2;
10184   if (!arg2) {
10185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10186     return 0;
10187   }
10188   {
10189     try {
10190       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
10191     } catch (std::out_of_range& e) {
10192       {
10193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10194       };
10195     } catch (std::exception& e) {
10196       {
10197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10198       };
10199     } catch (...) {
10200       {
10201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10202       };
10203     }
10204   }
10205   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10206   return jresult;
10207 }
10208
10209
10210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Subtract__SWIG_0(void * jarg1, void * jarg2) {
10211   void * jresult ;
10212   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10213   Dali::Quaternion *arg2 = 0 ;
10214   Dali::Quaternion result;
10215
10216   arg1 = (Dali::Quaternion *)jarg1;
10217   arg2 = (Dali::Quaternion *)jarg2;
10218   if (!arg2) {
10219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10220     return 0;
10221   }
10222   {
10223     try {
10224       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
10225     } catch (std::out_of_range& e) {
10226       {
10227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10228       };
10229     } catch (std::exception& e) {
10230       {
10231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10232       };
10233     } catch (...) {
10234       {
10235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10236       };
10237     }
10238   }
10239   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10240   return jresult;
10241 }
10242
10243
10244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10245   void * jresult ;
10246   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10247   Dali::Quaternion *arg2 = 0 ;
10248   Dali::Quaternion result;
10249
10250   arg1 = (Dali::Quaternion *)jarg1;
10251   arg2 = (Dali::Quaternion *)jarg2;
10252   if (!arg2) {
10253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10254     return 0;
10255   }
10256   {
10257     try {
10258       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10259     } catch (std::out_of_range& e) {
10260       {
10261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10262       };
10263     } catch (std::exception& e) {
10264       {
10265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10266       };
10267     } catch (...) {
10268       {
10269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10270       };
10271     }
10272   }
10273   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10274   return jresult;
10275 }
10276
10277
10278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10279   void * jresult ;
10280   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10281   Dali::Vector3 *arg2 = 0 ;
10282   Dali::Vector3 result;
10283
10284   arg1 = (Dali::Quaternion *)jarg1;
10285   arg2 = (Dali::Vector3 *)jarg2;
10286   if (!arg2) {
10287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10288     return 0;
10289   }
10290   {
10291     try {
10292       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10293     } catch (std::out_of_range& e) {
10294       {
10295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10296       };
10297     } catch (std::exception& e) {
10298       {
10299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10300       };
10301     } catch (...) {
10302       {
10303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10304       };
10305     }
10306   }
10307   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10308   return jresult;
10309 }
10310
10311
10312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Divide__SWIG_0(void * jarg1, void * jarg2) {
10313   void * jresult ;
10314   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10315   Dali::Quaternion *arg2 = 0 ;
10316   Dali::Quaternion result;
10317
10318   arg1 = (Dali::Quaternion *)jarg1;
10319   arg2 = (Dali::Quaternion *)jarg2;
10320   if (!arg2) {
10321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10322     return 0;
10323   }
10324   {
10325     try {
10326       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10327     } catch (std::out_of_range& e) {
10328       {
10329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10330       };
10331     } catch (std::exception& e) {
10332       {
10333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10334       };
10335     } catch (...) {
10336       {
10337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10338       };
10339     }
10340   }
10341   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10342   return jresult;
10343 }
10344
10345
10346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Multiply__SWIG_2(void * jarg1, float jarg2) {
10347   void * jresult ;
10348   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10349   float arg2 ;
10350   Dali::Quaternion result;
10351
10352   arg1 = (Dali::Quaternion *)jarg1;
10353   arg2 = (float)jarg2;
10354   {
10355     try {
10356       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10357     } catch (std::out_of_range& e) {
10358       {
10359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10360       };
10361     } catch (std::exception& e) {
10362       {
10363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10364       };
10365     } catch (...) {
10366       {
10367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10368       };
10369     }
10370   }
10371   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10372   return jresult;
10373 }
10374
10375
10376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Divide__SWIG_1(void * jarg1, float jarg2) {
10377   void * jresult ;
10378   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10379   float arg2 ;
10380   Dali::Quaternion result;
10381
10382   arg1 = (Dali::Quaternion *)jarg1;
10383   arg2 = (float)jarg2;
10384   {
10385     try {
10386       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10387     } catch (std::out_of_range& e) {
10388       {
10389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10390       };
10391     } catch (std::exception& e) {
10392       {
10393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10394       };
10395     } catch (...) {
10396       {
10397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10398       };
10399     }
10400   }
10401   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10402   return jresult;
10403 }
10404
10405
10406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Subtract__SWIG_1(void * jarg1) {
10407   void * jresult ;
10408   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10409   Dali::Quaternion result;
10410
10411   arg1 = (Dali::Quaternion *)jarg1;
10412   {
10413     try {
10414       result = ((Dali::Quaternion const *)arg1)->operator -();
10415     } catch (std::out_of_range& e) {
10416       {
10417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10418       };
10419     } catch (std::exception& e) {
10420       {
10421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10422       };
10423     } catch (...) {
10424       {
10425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10426       };
10427     }
10428   }
10429   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10430   return jresult;
10431 }
10432
10433
10434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_AddAssign(void * jarg1, void * jarg2) {
10435   void * jresult ;
10436   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10437   Dali::Quaternion *arg2 = 0 ;
10438   Dali::Quaternion *result = 0 ;
10439
10440   arg1 = (Dali::Quaternion *)jarg1;
10441   arg2 = (Dali::Quaternion *)jarg2;
10442   if (!arg2) {
10443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10444     return 0;
10445   }
10446   {
10447     try {
10448       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10449     } catch (std::out_of_range& e) {
10450       {
10451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10452       };
10453     } catch (std::exception& e) {
10454       {
10455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10456       };
10457     } catch (...) {
10458       {
10459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10460       };
10461     }
10462   }
10463   jresult = (void *)result;
10464   return jresult;
10465 }
10466
10467
10468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_SubtractAssign(void * jarg1, void * jarg2) {
10469   void * jresult ;
10470   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10471   Dali::Quaternion *arg2 = 0 ;
10472   Dali::Quaternion *result = 0 ;
10473
10474   arg1 = (Dali::Quaternion *)jarg1;
10475   arg2 = (Dali::Quaternion *)jarg2;
10476   if (!arg2) {
10477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10478     return 0;
10479   }
10480   {
10481     try {
10482       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10483     } catch (std::out_of_range& e) {
10484       {
10485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10486       };
10487     } catch (std::exception& e) {
10488       {
10489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10490       };
10491     } catch (...) {
10492       {
10493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10494       };
10495     }
10496   }
10497   jresult = (void *)result;
10498   return jresult;
10499 }
10500
10501
10502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10503   void * jresult ;
10504   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10505   Dali::Quaternion *arg2 = 0 ;
10506   Dali::Quaternion *result = 0 ;
10507
10508   arg1 = (Dali::Quaternion *)jarg1;
10509   arg2 = (Dali::Quaternion *)jarg2;
10510   if (!arg2) {
10511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10512     return 0;
10513   }
10514   {
10515     try {
10516       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10517     } catch (std::out_of_range& e) {
10518       {
10519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10520       };
10521     } catch (std::exception& e) {
10522       {
10523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10524       };
10525     } catch (...) {
10526       {
10527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10528       };
10529     }
10530   }
10531   jresult = (void *)result;
10532   return jresult;
10533 }
10534
10535
10536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10537   void * jresult ;
10538   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10539   float arg2 ;
10540   Dali::Quaternion *result = 0 ;
10541
10542   arg1 = (Dali::Quaternion *)jarg1;
10543   arg2 = (float)jarg2;
10544   {
10545     try {
10546       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10547     } catch (std::out_of_range& e) {
10548       {
10549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10550       };
10551     } catch (std::exception& e) {
10552       {
10553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10554       };
10555     } catch (...) {
10556       {
10557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10558       };
10559     }
10560   }
10561   jresult = (void *)result;
10562   return jresult;
10563 }
10564
10565
10566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_DivideAssign(void * jarg1, float jarg2) {
10567   void * jresult ;
10568   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10569   float arg2 ;
10570   Dali::Quaternion *result = 0 ;
10571
10572   arg1 = (Dali::Quaternion *)jarg1;
10573   arg2 = (float)jarg2;
10574   {
10575     try {
10576       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10577     } catch (std::out_of_range& e) {
10578       {
10579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10580       };
10581     } catch (std::exception& e) {
10582       {
10583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10584       };
10585     } catch (...) {
10586       {
10587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10588       };
10589     }
10590   }
10591   jresult = (void *)result;
10592   return jresult;
10593 }
10594
10595
10596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Quaternion_EqualTo(void * jarg1, void * jarg2) {
10597   unsigned int jresult ;
10598   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10599   Dali::Quaternion *arg2 = 0 ;
10600   bool result;
10601
10602   arg1 = (Dali::Quaternion *)jarg1;
10603   arg2 = (Dali::Quaternion *)jarg2;
10604   if (!arg2) {
10605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10606     return 0;
10607   }
10608   {
10609     try {
10610       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10611     } catch (std::out_of_range& e) {
10612       {
10613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10614       };
10615     } catch (std::exception& e) {
10616       {
10617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10618       };
10619     } catch (...) {
10620       {
10621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10622       };
10623     }
10624   }
10625   jresult = result;
10626   return jresult;
10627 }
10628
10629
10630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Quaternion_NotEqualTo(void * jarg1, void * jarg2) {
10631   unsigned int jresult ;
10632   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10633   Dali::Quaternion *arg2 = 0 ;
10634   bool result;
10635
10636   arg1 = (Dali::Quaternion *)jarg1;
10637   arg2 = (Dali::Quaternion *)jarg2;
10638   if (!arg2) {
10639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10640     return 0;
10641   }
10642   {
10643     try {
10644       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10645     } catch (std::out_of_range& e) {
10646       {
10647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10648       };
10649     } catch (std::exception& e) {
10650       {
10651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10652       };
10653     } catch (...) {
10654       {
10655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10656       };
10657     }
10658   }
10659   jresult = result;
10660   return jresult;
10661 }
10662
10663
10664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Quaternion_Length(void * jarg1) {
10665   float jresult ;
10666   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10667   float result;
10668
10669   arg1 = (Dali::Quaternion *)jarg1;
10670   {
10671     try {
10672       result = (float)((Dali::Quaternion const *)arg1)->Length();
10673     } catch (std::out_of_range& e) {
10674       {
10675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10676       };
10677     } catch (std::exception& e) {
10678       {
10679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10680       };
10681     } catch (...) {
10682       {
10683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10684       };
10685     }
10686   }
10687   jresult = result;
10688   return jresult;
10689 }
10690
10691
10692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Quaternion_LengthSquared(void * jarg1) {
10693   float jresult ;
10694   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10695   float result;
10696
10697   arg1 = (Dali::Quaternion *)jarg1;
10698   {
10699     try {
10700       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10701     } catch (std::out_of_range& e) {
10702       {
10703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10704       };
10705     } catch (std::exception& e) {
10706       {
10707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10708       };
10709     } catch (...) {
10710       {
10711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10712       };
10713     }
10714   }
10715   jresult = result;
10716   return jresult;
10717 }
10718
10719
10720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Quaternion_Normalize(void * jarg1) {
10721   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10722
10723   arg1 = (Dali::Quaternion *)jarg1;
10724   {
10725     try {
10726       (arg1)->Normalize();
10727     } catch (std::out_of_range& e) {
10728       {
10729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10730       };
10731     } catch (std::exception& e) {
10732       {
10733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10734       };
10735     } catch (...) {
10736       {
10737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10738       };
10739     }
10740   }
10741 }
10742
10743
10744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Normalized(void * jarg1) {
10745   void * jresult ;
10746   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10747   Dali::Quaternion result;
10748
10749   arg1 = (Dali::Quaternion *)jarg1;
10750   {
10751     try {
10752       result = ((Dali::Quaternion const *)arg1)->Normalized();
10753     } catch (std::out_of_range& e) {
10754       {
10755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10756       };
10757     } catch (std::exception& e) {
10758       {
10759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10760       };
10761     } catch (...) {
10762       {
10763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10764       };
10765     }
10766   }
10767   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10768   return jresult;
10769 }
10770
10771
10772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Quaternion_Conjugate(void * jarg1) {
10773   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10774
10775   arg1 = (Dali::Quaternion *)jarg1;
10776   {
10777     try {
10778       (arg1)->Conjugate();
10779     } catch (std::out_of_range& e) {
10780       {
10781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10782       };
10783     } catch (std::exception& e) {
10784       {
10785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10786       };
10787     } catch (...) {
10788       {
10789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10790       };
10791     }
10792   }
10793 }
10794
10795
10796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Quaternion_Invert(void * jarg1) {
10797   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10798
10799   arg1 = (Dali::Quaternion *)jarg1;
10800   {
10801     try {
10802       (arg1)->Invert();
10803     } catch (std::out_of_range& e) {
10804       {
10805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10806       };
10807     } catch (std::exception& e) {
10808       {
10809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10810       };
10811     } catch (...) {
10812       {
10813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10814       };
10815     }
10816   }
10817 }
10818
10819
10820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Log(void * jarg1) {
10821   void * jresult ;
10822   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10823   Dali::Quaternion result;
10824
10825   arg1 = (Dali::Quaternion *)jarg1;
10826   {
10827     try {
10828       result = ((Dali::Quaternion const *)arg1)->Log();
10829     } catch (std::out_of_range& e) {
10830       {
10831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (std::exception& e) {
10834       {
10835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10836       };
10837     } catch (...) {
10838       {
10839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10840       };
10841     }
10842   }
10843   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10844   return jresult;
10845 }
10846
10847
10848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Exp(void * jarg1) {
10849   void * jresult ;
10850   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10851   Dali::Quaternion result;
10852
10853   arg1 = (Dali::Quaternion *)jarg1;
10854   {
10855     try {
10856       result = ((Dali::Quaternion const *)arg1)->Exp();
10857     } catch (std::out_of_range& e) {
10858       {
10859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10860       };
10861     } catch (std::exception& e) {
10862       {
10863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10864       };
10865     } catch (...) {
10866       {
10867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10868       };
10869     }
10870   }
10871   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10872   return jresult;
10873 }
10874
10875
10876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Quaternion_Dot(void * jarg1, void * jarg2) {
10877   float jresult ;
10878   Dali::Quaternion *arg1 = 0 ;
10879   Dali::Quaternion *arg2 = 0 ;
10880   float result;
10881
10882   arg1 = (Dali::Quaternion *)jarg1;
10883   if (!arg1) {
10884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10885     return 0;
10886   }
10887   arg2 = (Dali::Quaternion *)jarg2;
10888   if (!arg2) {
10889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10890     return 0;
10891   }
10892   {
10893     try {
10894       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10895     } catch (std::out_of_range& e) {
10896       {
10897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10898       };
10899     } catch (std::exception& e) {
10900       {
10901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10902       };
10903     } catch (...) {
10904       {
10905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10906       };
10907     }
10908   }
10909   jresult = result;
10910   return jresult;
10911 }
10912
10913
10914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Lerp(void * jarg1, void * jarg2, float jarg3) {
10915   void * jresult ;
10916   Dali::Quaternion *arg1 = 0 ;
10917   Dali::Quaternion *arg2 = 0 ;
10918   float arg3 ;
10919   Dali::Quaternion result;
10920
10921   arg1 = (Dali::Quaternion *)jarg1;
10922   if (!arg1) {
10923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10924     return 0;
10925   }
10926   arg2 = (Dali::Quaternion *)jarg2;
10927   if (!arg2) {
10928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10929     return 0;
10930   }
10931   arg3 = (float)jarg3;
10932   {
10933     try {
10934       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10935     } catch (std::out_of_range& e) {
10936       {
10937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10938       };
10939     } catch (std::exception& e) {
10940       {
10941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10942       };
10943     } catch (...) {
10944       {
10945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10946       };
10947     }
10948   }
10949   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10950   return jresult;
10951 }
10952
10953
10954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Slerp(void * jarg1, void * jarg2, float jarg3) {
10955   void * jresult ;
10956   Dali::Quaternion *arg1 = 0 ;
10957   Dali::Quaternion *arg2 = 0 ;
10958   float arg3 ;
10959   Dali::Quaternion result;
10960
10961   arg1 = (Dali::Quaternion *)jarg1;
10962   if (!arg1) {
10963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10964     return 0;
10965   }
10966   arg2 = (Dali::Quaternion *)jarg2;
10967   if (!arg2) {
10968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10969     return 0;
10970   }
10971   arg3 = (float)jarg3;
10972   {
10973     try {
10974       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10975     } catch (std::out_of_range& e) {
10976       {
10977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10978       };
10979     } catch (std::exception& e) {
10980       {
10981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10982       };
10983     } catch (...) {
10984       {
10985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10986       };
10987     }
10988   }
10989   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10990   return jresult;
10991 }
10992
10993
10994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10995   void * jresult ;
10996   Dali::Quaternion *arg1 = 0 ;
10997   Dali::Quaternion *arg2 = 0 ;
10998   float arg3 ;
10999   Dali::Quaternion result;
11000
11001   arg1 = (Dali::Quaternion *)jarg1;
11002   if (!arg1) {
11003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11004     return 0;
11005   }
11006   arg2 = (Dali::Quaternion *)jarg2;
11007   if (!arg2) {
11008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11009     return 0;
11010   }
11011   arg3 = (float)jarg3;
11012   {
11013     try {
11014       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11015     } catch (std::out_of_range& e) {
11016       {
11017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11018       };
11019     } catch (std::exception& e) {
11020       {
11021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11022       };
11023     } catch (...) {
11024       {
11025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11026       };
11027     }
11028   }
11029   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11030   return jresult;
11031 }
11032
11033
11034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
11035   void * jresult ;
11036   Dali::Quaternion *arg1 = 0 ;
11037   Dali::Quaternion *arg2 = 0 ;
11038   Dali::Quaternion *arg3 = 0 ;
11039   Dali::Quaternion *arg4 = 0 ;
11040   float arg5 ;
11041   Dali::Quaternion result;
11042
11043   arg1 = (Dali::Quaternion *)jarg1;
11044   if (!arg1) {
11045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11046     return 0;
11047   }
11048   arg2 = (Dali::Quaternion *)jarg2;
11049   if (!arg2) {
11050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11051     return 0;
11052   }
11053   arg3 = (Dali::Quaternion *)jarg3;
11054   if (!arg3) {
11055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11056     return 0;
11057   }
11058   arg4 = (Dali::Quaternion *)jarg4;
11059   if (!arg4) {
11060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11061     return 0;
11062   }
11063   arg5 = (float)jarg5;
11064   {
11065     try {
11066       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
11067     } catch (std::out_of_range& e) {
11068       {
11069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11070       };
11071     } catch (std::exception& e) {
11072       {
11073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11074       };
11075     } catch (...) {
11076       {
11077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11078       };
11079     }
11080   }
11081   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11082   return jresult;
11083 }
11084
11085
11086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Quaternion_AngleBetween(void * jarg1, void * jarg2) {
11087   float jresult ;
11088   Dali::Quaternion *arg1 = 0 ;
11089   Dali::Quaternion *arg2 = 0 ;
11090   float result;
11091
11092   arg1 = (Dali::Quaternion *)jarg1;
11093   if (!arg1) {
11094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11095     return 0;
11096   }
11097   arg2 = (Dali::Quaternion *)jarg2;
11098   if (!arg2) {
11099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11100     return 0;
11101   }
11102   {
11103     try {
11104       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11105     } catch (std::out_of_range& e) {
11106       {
11107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11108       };
11109     } catch (std::exception& e) {
11110       {
11111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11112       };
11113     } catch (...) {
11114       {
11115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11116       };
11117     }
11118   }
11119   jresult = result;
11120   return jresult;
11121 }
11122
11123
11124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Rotate__SWIG_0(void * jarg1, void * jarg2) {
11125   void * jresult ;
11126   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11127   Dali::Vector4 *arg2 = 0 ;
11128   Dali::Vector4 result;
11129
11130   arg1 = (Dali::Quaternion *)jarg1;
11131   arg2 = (Dali::Vector4 *)jarg2;
11132   if (!arg2) {
11133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11134     return 0;
11135   }
11136   {
11137     try {
11138       result = ((Dali::Quaternion const *)arg1)->Rotate((Dali::Vector4 const &)*arg2);
11139     } catch (std::out_of_range& e) {
11140       {
11141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11142       };
11143     } catch (std::exception& e) {
11144       {
11145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11146       };
11147     } catch (...) {
11148       {
11149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11150       };
11151     }
11152   }
11153   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11154   return jresult;
11155 }
11156
11157
11158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_Rotate__SWIG_1(void * jarg1, void * jarg2) {
11159   void * jresult ;
11160   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11161   Dali::Vector3 *arg2 = 0 ;
11162   Dali::Vector3 result;
11163
11164   arg1 = (Dali::Quaternion *)jarg1;
11165   arg2 = (Dali::Vector3 *)jarg2;
11166   if (!arg2) {
11167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11168     return 0;
11169   }
11170   {
11171     try {
11172       result = ((Dali::Quaternion const *)arg1)->Rotate((Dali::Vector3 const &)*arg2);
11173     } catch (std::out_of_range& e) {
11174       {
11175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11176       };
11177     } catch (std::exception& e) {
11178       {
11179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11180       };
11181     } catch (...) {
11182       {
11183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11184       };
11185     }
11186   }
11187   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11188   return jresult;
11189 }
11190
11191
11192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Quaternion_mVector_set(void * jarg1, void * jarg2) {
11193   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11194   Dali::Vector4 *arg2 = (Dali::Vector4 *) 0 ;
11195
11196   arg1 = (Dali::Quaternion *)jarg1;
11197   arg2 = (Dali::Vector4 *)jarg2;
11198   if (arg1) (arg1)->mVector = *arg2;
11199 }
11200
11201
11202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Quaternion_mVector_get(void * jarg1) {
11203   void * jresult ;
11204   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11205   Dali::Vector4 *result = 0 ;
11206
11207   arg1 = (Dali::Quaternion *)jarg1;
11208   result = (Dali::Vector4 *)& ((arg1)->mVector);
11209   jresult = (void *)result;
11210   return jresult;
11211 }
11212
11213
11214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
11215   void * jresult ;
11216   Dali::Matrix *result = 0 ;
11217
11218   {
11219     try {
11220       result = (Dali::Matrix *)new Dali::Matrix();
11221     } catch (std::out_of_range& e) {
11222       {
11223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11224       };
11225     } catch (std::exception& e) {
11226       {
11227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11228       };
11229     } catch (...) {
11230       {
11231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11232       };
11233     }
11234   }
11235   jresult = (void *)result;
11236   return jresult;
11237 }
11238
11239
11240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
11241   void * jresult ;
11242   bool arg1 ;
11243   Dali::Matrix *result = 0 ;
11244
11245   arg1 = jarg1 ? true : false;
11246   {
11247     try {
11248       result = (Dali::Matrix *)new Dali::Matrix(arg1);
11249     } catch (std::out_of_range& e) {
11250       {
11251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11252       };
11253     } catch (std::exception& e) {
11254       {
11255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11256       };
11257     } catch (...) {
11258       {
11259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11260       };
11261     }
11262   }
11263   jresult = (void *)result;
11264   return jresult;
11265 }
11266
11267
11268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
11269   void * jresult ;
11270   float *arg1 = (float *) 0 ;
11271   Dali::Matrix *result = 0 ;
11272
11273   arg1 = jarg1;
11274   {
11275     try {
11276       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
11277     } catch (std::out_of_range& e) {
11278       {
11279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11280       };
11281     } catch (std::exception& e) {
11282       {
11283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11284       };
11285     } catch (...) {
11286       {
11287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11288       };
11289     }
11290   }
11291   jresult = (void *)result;
11292
11293
11294   return jresult;
11295 }
11296
11297
11298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
11299   void * jresult ;
11300   Dali::Quaternion *arg1 = 0 ;
11301   Dali::Matrix *result = 0 ;
11302
11303   arg1 = (Dali::Quaternion *)jarg1;
11304   if (!arg1) {
11305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11306     return 0;
11307   }
11308   {
11309     try {
11310       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
11311     } catch (std::out_of_range& e) {
11312       {
11313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11314       };
11315     } catch (std::exception& e) {
11316       {
11317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11318       };
11319     } catch (...) {
11320       {
11321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11322       };
11323     }
11324   }
11325   jresult = (void *)result;
11326   return jresult;
11327 }
11328
11329
11330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
11331   void * jresult ;
11332   Dali::Matrix *arg1 = 0 ;
11333   Dali::Matrix *result = 0 ;
11334
11335   arg1 = (Dali::Matrix *)jarg1;
11336   if (!arg1) {
11337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11338     return 0;
11339   }
11340   {
11341     try {
11342       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11343     } catch (std::out_of_range& e) {
11344       {
11345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11346       };
11347     } catch (std::exception& e) {
11348       {
11349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11350       };
11351     } catch (...) {
11352       {
11353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11354       };
11355     }
11356   }
11357   jresult = (void *)result;
11358   return jresult;
11359 }
11360
11361
11362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
11363   void * jresult ;
11364   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11365   Dali::Matrix *arg2 = 0 ;
11366   Dali::Matrix *result = 0 ;
11367
11368   arg1 = (Dali::Matrix *)jarg1;
11369   arg2 = (Dali::Matrix *)jarg2;
11370   if (!arg2) {
11371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11372     return 0;
11373   }
11374   {
11375     try {
11376       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11377     } catch (std::out_of_range& e) {
11378       {
11379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11380       };
11381     } catch (std::exception& e) {
11382       {
11383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11384       };
11385     } catch (...) {
11386       {
11387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11388       };
11389     }
11390   }
11391   jresult = (void *)result;
11392   return jresult;
11393 }
11394
11395
11396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11397   void * jresult ;
11398   Dali::Matrix *result = 0 ;
11399
11400   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11401   jresult = (void *)result;
11402   return jresult;
11403 }
11404
11405
11406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11407   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11408
11409   arg1 = (Dali::Matrix *)jarg1;
11410   {
11411     try {
11412       (arg1)->SetIdentity();
11413     } catch (std::out_of_range& e) {
11414       {
11415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11416       };
11417     } catch (std::exception& e) {
11418       {
11419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11420       };
11421     } catch (...) {
11422       {
11423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11424       };
11425     }
11426   }
11427 }
11428
11429
11430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11431   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11432   Dali::Vector3 *arg2 = 0 ;
11433
11434   arg1 = (Dali::Matrix *)jarg1;
11435   arg2 = (Dali::Vector3 *)jarg2;
11436   if (!arg2) {
11437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11438     return ;
11439   }
11440   {
11441     try {
11442       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11443     } catch (std::out_of_range& e) {
11444       {
11445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11446       };
11447     } catch (std::exception& e) {
11448       {
11449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11450       };
11451     } catch (...) {
11452       {
11453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11454       };
11455     }
11456   }
11457 }
11458
11459
11460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11461   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11462   Dali::Matrix *arg2 = 0 ;
11463
11464   arg1 = (Dali::Matrix *)jarg1;
11465   arg2 = (Dali::Matrix *)jarg2;
11466   if (!arg2) {
11467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11468     return ;
11469   }
11470   {
11471     try {
11472       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11473     } catch (std::out_of_range& e) {
11474       {
11475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11476       };
11477     } catch (std::exception& e) {
11478       {
11479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11480       };
11481     } catch (...) {
11482       {
11483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11484       };
11485     }
11486   }
11487 }
11488
11489
11490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11491   unsigned int jresult ;
11492   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11493   bool result;
11494
11495   arg1 = (Dali::Matrix *)jarg1;
11496   {
11497     try {
11498       result = (bool)(arg1)->Invert();
11499     } catch (std::out_of_range& e) {
11500       {
11501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11502       };
11503     } catch (std::exception& e) {
11504       {
11505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11506       };
11507     } catch (...) {
11508       {
11509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11510       };
11511     }
11512   }
11513   jresult = result;
11514   return jresult;
11515 }
11516
11517
11518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11519   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11520
11521   arg1 = (Dali::Matrix *)jarg1;
11522   {
11523     try {
11524       (arg1)->Transpose();
11525     } catch (std::out_of_range& e) {
11526       {
11527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11528       };
11529     } catch (std::exception& e) {
11530       {
11531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11532       };
11533     } catch (...) {
11534       {
11535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11536       };
11537     }
11538   }
11539 }
11540
11541
11542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11543   void * jresult ;
11544   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11545   Dali::Vector3 result;
11546
11547   arg1 = (Dali::Matrix *)jarg1;
11548   {
11549     try {
11550       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11551     } catch (std::out_of_range& e) {
11552       {
11553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11554       };
11555     } catch (std::exception& e) {
11556       {
11557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11558       };
11559     } catch (...) {
11560       {
11561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11562       };
11563     }
11564   }
11565   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11566   return jresult;
11567 }
11568
11569
11570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11571   void * jresult ;
11572   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11573   Dali::Vector3 result;
11574
11575   arg1 = (Dali::Matrix *)jarg1;
11576   {
11577     try {
11578       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11579     } catch (std::out_of_range& e) {
11580       {
11581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11582       };
11583     } catch (std::exception& e) {
11584       {
11585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11586       };
11587     } catch (...) {
11588       {
11589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11590       };
11591     }
11592   }
11593   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11594   return jresult;
11595 }
11596
11597
11598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11599   void * jresult ;
11600   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11601   Dali::Vector3 result;
11602
11603   arg1 = (Dali::Matrix *)jarg1;
11604   {
11605     try {
11606       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11607     } catch (std::out_of_range& e) {
11608       {
11609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11610       };
11611     } catch (std::exception& e) {
11612       {
11613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11614       };
11615     } catch (...) {
11616       {
11617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11618       };
11619     }
11620   }
11621   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11622   return jresult;
11623 }
11624
11625
11626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11627   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11628   Dali::Vector3 *arg2 = 0 ;
11629
11630   arg1 = (Dali::Matrix *)jarg1;
11631   arg2 = (Dali::Vector3 *)jarg2;
11632   if (!arg2) {
11633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11634     return ;
11635   }
11636   {
11637     try {
11638       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11639     } catch (std::out_of_range& e) {
11640       {
11641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11642       };
11643     } catch (std::exception& e) {
11644       {
11645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11646       };
11647     } catch (...) {
11648       {
11649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11650       };
11651     }
11652   }
11653 }
11654
11655
11656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11657   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11658   Dali::Vector3 *arg2 = 0 ;
11659
11660   arg1 = (Dali::Matrix *)jarg1;
11661   arg2 = (Dali::Vector3 *)jarg2;
11662   if (!arg2) {
11663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11664     return ;
11665   }
11666   {
11667     try {
11668       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11669     } catch (std::out_of_range& e) {
11670       {
11671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11672       };
11673     } catch (std::exception& e) {
11674       {
11675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11676       };
11677     } catch (...) {
11678       {
11679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11680       };
11681     }
11682   }
11683 }
11684
11685
11686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11687   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11688   Dali::Vector3 *arg2 = 0 ;
11689
11690   arg1 = (Dali::Matrix *)jarg1;
11691   arg2 = (Dali::Vector3 *)jarg2;
11692   if (!arg2) {
11693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11694     return ;
11695   }
11696   {
11697     try {
11698       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11699     } catch (std::out_of_range& e) {
11700       {
11701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11702       };
11703     } catch (std::exception& e) {
11704       {
11705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11706       };
11707     } catch (...) {
11708       {
11709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11710       };
11711     }
11712   }
11713 }
11714
11715
11716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11717   void * jresult ;
11718   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11719   Dali::Vector4 *result = 0 ;
11720
11721   arg1 = (Dali::Matrix *)jarg1;
11722   {
11723     try {
11724       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11725     } catch (std::out_of_range& e) {
11726       {
11727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11728       };
11729     } catch (std::exception& e) {
11730       {
11731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11732       };
11733     } catch (...) {
11734       {
11735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11736       };
11737     }
11738   }
11739   jresult = (void *)result;
11740   return jresult;
11741 }
11742
11743
11744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11745   void * jresult ;
11746   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11747   Dali::Vector3 *result = 0 ;
11748
11749   arg1 = (Dali::Matrix *)jarg1;
11750   {
11751     try {
11752       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11753     } catch (std::out_of_range& e) {
11754       {
11755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11756       };
11757     } catch (std::exception& e) {
11758       {
11759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11760       };
11761     } catch (...) {
11762       {
11763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11764       };
11765     }
11766   }
11767   jresult = (void *)result;
11768   return jresult;
11769 }
11770
11771
11772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11773   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11774   Dali::Vector4 *arg2 = 0 ;
11775
11776   arg1 = (Dali::Matrix *)jarg1;
11777   arg2 = (Dali::Vector4 *)jarg2;
11778   if (!arg2) {
11779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11780     return ;
11781   }
11782   {
11783     try {
11784       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11785     } catch (std::out_of_range& e) {
11786       {
11787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11788       };
11789     } catch (std::exception& e) {
11790       {
11791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11792       };
11793     } catch (...) {
11794       {
11795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11796       };
11797     }
11798   }
11799 }
11800
11801
11802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11803   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11804   Dali::Vector3 *arg2 = 0 ;
11805
11806   arg1 = (Dali::Matrix *)jarg1;
11807   arg2 = (Dali::Vector3 *)jarg2;
11808   if (!arg2) {
11809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11810     return ;
11811   }
11812   {
11813     try {
11814       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11815     } catch (std::out_of_range& e) {
11816       {
11817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11818       };
11819     } catch (std::exception& e) {
11820       {
11821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11822       };
11823     } catch (...) {
11824       {
11825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11826       };
11827     }
11828   }
11829 }
11830
11831
11832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11833   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11834
11835   arg1 = (Dali::Matrix *)jarg1;
11836   {
11837     try {
11838       (arg1)->OrthoNormalize();
11839     } catch (std::out_of_range& e) {
11840       {
11841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11842       };
11843     } catch (std::exception& e) {
11844       {
11845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11846       };
11847     } catch (...) {
11848       {
11849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11850       };
11851     }
11852   }
11853 }
11854
11855
11856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11857   void * jresult ;
11858   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11859   float *result = 0 ;
11860
11861   arg1 = (Dali::Matrix *)jarg1;
11862   {
11863     try {
11864       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11865     } catch (std::out_of_range& e) {
11866       {
11867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11868       };
11869     } catch (std::exception& e) {
11870       {
11871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11872       };
11873     } catch (...) {
11874       {
11875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11876       };
11877     }
11878   }
11879   jresult = (void *)result;
11880   return jresult;
11881 }
11882
11883
11884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11885   Dali::Matrix *arg1 = 0 ;
11886   Dali::Matrix *arg2 = 0 ;
11887   Dali::Matrix *arg3 = 0 ;
11888
11889   arg1 = (Dali::Matrix *)jarg1;
11890   if (!arg1) {
11891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11892     return ;
11893   }
11894   arg2 = (Dali::Matrix *)jarg2;
11895   if (!arg2) {
11896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11897     return ;
11898   }
11899   arg3 = (Dali::Matrix *)jarg3;
11900   if (!arg3) {
11901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11902     return ;
11903   }
11904   {
11905     try {
11906       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11907     } catch (std::out_of_range& e) {
11908       {
11909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11910       };
11911     } catch (std::exception& e) {
11912       {
11913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11914       };
11915     } catch (...) {
11916       {
11917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11918       };
11919     }
11920   }
11921 }
11922
11923
11924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11925   Dali::Matrix *arg1 = 0 ;
11926   Dali::Matrix *arg2 = 0 ;
11927   Dali::Quaternion *arg3 = 0 ;
11928
11929   arg1 = (Dali::Matrix *)jarg1;
11930   if (!arg1) {
11931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11932     return ;
11933   }
11934   arg2 = (Dali::Matrix *)jarg2;
11935   if (!arg2) {
11936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11937     return ;
11938   }
11939   arg3 = (Dali::Quaternion *)jarg3;
11940   if (!arg3) {
11941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11942     return ;
11943   }
11944   {
11945     try {
11946       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11947     } catch (std::out_of_range& e) {
11948       {
11949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11950       };
11951     } catch (std::exception& e) {
11952       {
11953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11954       };
11955     } catch (...) {
11956       {
11957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11958       };
11959     }
11960   }
11961 }
11962
11963
11964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11965   void * jresult ;
11966   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11967   Dali::Vector4 *arg2 = 0 ;
11968   Dali::Vector4 result;
11969
11970   arg1 = (Dali::Matrix *)jarg1;
11971   arg2 = (Dali::Vector4 *)jarg2;
11972   if (!arg2) {
11973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11974     return 0;
11975   }
11976   {
11977     try {
11978       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11979     } catch (std::out_of_range& e) {
11980       {
11981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11982       };
11983     } catch (std::exception& e) {
11984       {
11985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11986       };
11987     } catch (...) {
11988       {
11989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11990       };
11991     }
11992   }
11993   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11994   return jresult;
11995 }
11996
11997
11998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11999   unsigned int jresult ;
12000   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12001   Dali::Matrix *arg2 = 0 ;
12002   bool result;
12003
12004   arg1 = (Dali::Matrix *)jarg1;
12005   arg2 = (Dali::Matrix *)jarg2;
12006   if (!arg2) {
12007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12008     return 0;
12009   }
12010   {
12011     try {
12012       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
12013     } catch (std::out_of_range& e) {
12014       {
12015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12016       };
12017     } catch (std::exception& e) {
12018       {
12019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12020       };
12021     } catch (...) {
12022       {
12023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12024       };
12025     }
12026   }
12027   jresult = result;
12028   return jresult;
12029 }
12030
12031
12032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
12033   unsigned int jresult ;
12034   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12035   Dali::Matrix *arg2 = 0 ;
12036   bool result;
12037
12038   arg1 = (Dali::Matrix *)jarg1;
12039   arg2 = (Dali::Matrix *)jarg2;
12040   if (!arg2) {
12041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12042     return 0;
12043   }
12044   {
12045     try {
12046       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
12047     } catch (std::out_of_range& e) {
12048       {
12049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12050       };
12051     } catch (std::exception& e) {
12052       {
12053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12054       };
12055     } catch (...) {
12056       {
12057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12058       };
12059     }
12060   }
12061   jresult = result;
12062   return jresult;
12063 }
12064
12065
12066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
12067   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12068   Dali::Vector3 *arg2 = 0 ;
12069   Dali::Quaternion *arg3 = 0 ;
12070   Dali::Vector3 *arg4 = 0 ;
12071
12072   arg1 = (Dali::Matrix *)jarg1;
12073   arg2 = (Dali::Vector3 *)jarg2;
12074   if (!arg2) {
12075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12076     return ;
12077   }
12078   arg3 = (Dali::Quaternion *)jarg3;
12079   if (!arg3) {
12080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12081     return ;
12082   }
12083   arg4 = (Dali::Vector3 *)jarg4;
12084   if (!arg4) {
12085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12086     return ;
12087   }
12088   {
12089     try {
12090       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
12091     } catch (std::out_of_range& e) {
12092       {
12093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12094       };
12095     } catch (std::exception& e) {
12096       {
12097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12098       };
12099     } catch (...) {
12100       {
12101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12102       };
12103     }
12104   }
12105 }
12106
12107
12108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
12109   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12110   Dali::Vector3 *arg2 = 0 ;
12111   Dali::Quaternion *arg3 = 0 ;
12112   Dali::Vector3 *arg4 = 0 ;
12113
12114   arg1 = (Dali::Matrix *)jarg1;
12115   arg2 = (Dali::Vector3 *)jarg2;
12116   if (!arg2) {
12117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12118     return ;
12119   }
12120   arg3 = (Dali::Quaternion *)jarg3;
12121   if (!arg3) {
12122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12123     return ;
12124   }
12125   arg4 = (Dali::Vector3 *)jarg4;
12126   if (!arg4) {
12127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12128     return ;
12129   }
12130   {
12131     try {
12132       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
12133     } catch (std::out_of_range& e) {
12134       {
12135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12136       };
12137     } catch (std::exception& e) {
12138       {
12139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12140       };
12141     } catch (...) {
12142       {
12143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12144       };
12145     }
12146   }
12147 }
12148
12149
12150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
12151   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12152   Dali::Vector3 *arg2 = 0 ;
12153   Dali::Vector3 *arg3 = 0 ;
12154   Dali::Vector3 *arg4 = 0 ;
12155   Dali::Vector3 *arg5 = 0 ;
12156
12157   arg1 = (Dali::Matrix *)jarg1;
12158   arg2 = (Dali::Vector3 *)jarg2;
12159   if (!arg2) {
12160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12161     return ;
12162   }
12163   arg3 = (Dali::Vector3 *)jarg3;
12164   if (!arg3) {
12165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12166     return ;
12167   }
12168   arg4 = (Dali::Vector3 *)jarg4;
12169   if (!arg4) {
12170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12171     return ;
12172   }
12173   arg5 = (Dali::Vector3 *)jarg5;
12174   if (!arg5) {
12175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12176     return ;
12177   }
12178   {
12179     try {
12180       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
12181     } catch (std::out_of_range& e) {
12182       {
12183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12184       };
12185     } catch (std::exception& e) {
12186       {
12187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12188       };
12189     } catch (...) {
12190       {
12191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12192       };
12193     }
12194   }
12195 }
12196
12197
12198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
12199   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12200   Dali::Vector3 *arg2 = 0 ;
12201   Dali::Quaternion *arg3 = 0 ;
12202   Dali::Vector3 *arg4 = 0 ;
12203
12204   arg1 = (Dali::Matrix *)jarg1;
12205   arg2 = (Dali::Vector3 *)jarg2;
12206   if (!arg2) {
12207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
12208     return ;
12209   }
12210   arg3 = (Dali::Quaternion *)jarg3;
12211   if (!arg3) {
12212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
12213     return ;
12214   }
12215   arg4 = (Dali::Vector3 *)jarg4;
12216   if (!arg4) {
12217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
12218     return ;
12219   }
12220   {
12221     try {
12222       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
12223     } catch (std::out_of_range& e) {
12224       {
12225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12226       };
12227     } catch (std::exception& e) {
12228       {
12229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12230       };
12231     } catch (...) {
12232       {
12233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12234       };
12235     }
12236   }
12237 }
12238
12239
12240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
12241   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12242
12243   arg1 = (Dali::Matrix *)jarg1;
12244   {
12245     try {
12246       delete arg1;
12247     } catch (std::out_of_range& e) {
12248       {
12249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12250       };
12251     } catch (std::exception& e) {
12252       {
12253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12254       };
12255     } catch (...) {
12256       {
12257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12258       };
12259     }
12260   }
12261 }
12262
12263
12264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
12265   void * jresult ;
12266   Dali::Matrix3 *result = 0 ;
12267
12268   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
12269   jresult = (void *)result;
12270   return jresult;
12271 }
12272
12273
12274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
12275   void * jresult ;
12276   Dali::Matrix3 *result = 0 ;
12277
12278   {
12279     try {
12280       result = (Dali::Matrix3 *)new Dali::Matrix3();
12281     } catch (std::out_of_range& e) {
12282       {
12283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12284       };
12285     } catch (std::exception& e) {
12286       {
12287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12288       };
12289     } catch (...) {
12290       {
12291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12292       };
12293     }
12294   }
12295   jresult = (void *)result;
12296   return jresult;
12297 }
12298
12299
12300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
12301   void * jresult ;
12302   Dali::Matrix3 *arg1 = 0 ;
12303   Dali::Matrix3 *result = 0 ;
12304
12305   arg1 = (Dali::Matrix3 *)jarg1;
12306   if (!arg1) {
12307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12308     return 0;
12309   }
12310   {
12311     try {
12312       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
12313     } catch (std::out_of_range& e) {
12314       {
12315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12316       };
12317     } catch (std::exception& e) {
12318       {
12319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12320       };
12321     } catch (...) {
12322       {
12323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12324       };
12325     }
12326   }
12327   jresult = (void *)result;
12328   return jresult;
12329 }
12330
12331
12332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
12333   void * jresult ;
12334   Dali::Matrix *arg1 = 0 ;
12335   Dali::Matrix3 *result = 0 ;
12336
12337   arg1 = (Dali::Matrix *)jarg1;
12338   if (!arg1) {
12339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12340     return 0;
12341   }
12342   {
12343     try {
12344       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12345     } catch (std::out_of_range& e) {
12346       {
12347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12348       };
12349     } catch (std::exception& e) {
12350       {
12351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12352       };
12353     } catch (...) {
12354       {
12355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12356       };
12357     }
12358   }
12359   jresult = (void *)result;
12360   return jresult;
12361 }
12362
12363
12364 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) {
12365   void * jresult ;
12366   float arg1 ;
12367   float arg2 ;
12368   float arg3 ;
12369   float arg4 ;
12370   float arg5 ;
12371   float arg6 ;
12372   float arg7 ;
12373   float arg8 ;
12374   float arg9 ;
12375   Dali::Matrix3 *result = 0 ;
12376
12377   arg1 = (float)jarg1;
12378   arg2 = (float)jarg2;
12379   arg3 = (float)jarg3;
12380   arg4 = (float)jarg4;
12381   arg5 = (float)jarg5;
12382   arg6 = (float)jarg6;
12383   arg7 = (float)jarg7;
12384   arg8 = (float)jarg8;
12385   arg9 = (float)jarg9;
12386   {
12387     try {
12388       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12389     } catch (std::out_of_range& e) {
12390       {
12391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12392       };
12393     } catch (std::exception& e) {
12394       {
12395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12396       };
12397     } catch (...) {
12398       {
12399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12400       };
12401     }
12402   }
12403   jresult = (void *)result;
12404   return jresult;
12405 }
12406
12407
12408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12409   void * jresult ;
12410   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12411   Dali::Matrix3 *arg2 = 0 ;
12412   Dali::Matrix3 *result = 0 ;
12413
12414   arg1 = (Dali::Matrix3 *)jarg1;
12415   arg2 = (Dali::Matrix3 *)jarg2;
12416   if (!arg2) {
12417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12418     return 0;
12419   }
12420   {
12421     try {
12422       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12423     } catch (std::out_of_range& e) {
12424       {
12425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12426       };
12427     } catch (std::exception& e) {
12428       {
12429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12430       };
12431     } catch (...) {
12432       {
12433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12434       };
12435     }
12436   }
12437   jresult = (void *)result;
12438   return jresult;
12439 }
12440
12441
12442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12443   void * jresult ;
12444   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12445   Dali::Matrix *arg2 = 0 ;
12446   Dali::Matrix3 *result = 0 ;
12447
12448   arg1 = (Dali::Matrix3 *)jarg1;
12449   arg2 = (Dali::Matrix *)jarg2;
12450   if (!arg2) {
12451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12452     return 0;
12453   }
12454   {
12455     try {
12456       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12457     } catch (std::out_of_range& e) {
12458       {
12459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12460       };
12461     } catch (std::exception& e) {
12462       {
12463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12464       };
12465     } catch (...) {
12466       {
12467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12468       };
12469     }
12470   }
12471   jresult = (void *)result;
12472   return jresult;
12473 }
12474
12475
12476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12477   unsigned int jresult ;
12478   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12479   Dali::Matrix3 *arg2 = 0 ;
12480   bool result;
12481
12482   arg1 = (Dali::Matrix3 *)jarg1;
12483   arg2 = (Dali::Matrix3 *)jarg2;
12484   if (!arg2) {
12485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12486     return 0;
12487   }
12488   {
12489     try {
12490       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12491     } catch (std::out_of_range& e) {
12492       {
12493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12494       };
12495     } catch (std::exception& e) {
12496       {
12497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12498       };
12499     } catch (...) {
12500       {
12501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12502       };
12503     }
12504   }
12505   jresult = result;
12506   return jresult;
12507 }
12508
12509
12510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12511   unsigned int jresult ;
12512   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12513   Dali::Matrix3 *arg2 = 0 ;
12514   bool result;
12515
12516   arg1 = (Dali::Matrix3 *)jarg1;
12517   arg2 = (Dali::Matrix3 *)jarg2;
12518   if (!arg2) {
12519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12520     return 0;
12521   }
12522   {
12523     try {
12524       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12525     } catch (std::out_of_range& e) {
12526       {
12527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12528       };
12529     } catch (std::exception& e) {
12530       {
12531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12532       };
12533     } catch (...) {
12534       {
12535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12536       };
12537     }
12538   }
12539   jresult = result;
12540   return jresult;
12541 }
12542
12543
12544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12545   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12546
12547   arg1 = (Dali::Matrix3 *)jarg1;
12548   {
12549     try {
12550       delete arg1;
12551     } catch (std::out_of_range& e) {
12552       {
12553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12554       };
12555     } catch (std::exception& e) {
12556       {
12557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12558       };
12559     } catch (...) {
12560       {
12561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12562       };
12563     }
12564   }
12565 }
12566
12567
12568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12569   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12570
12571   arg1 = (Dali::Matrix3 *)jarg1;
12572   {
12573     try {
12574       (arg1)->SetIdentity();
12575     } catch (std::out_of_range& e) {
12576       {
12577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12578       };
12579     } catch (std::exception& e) {
12580       {
12581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12582       };
12583     } catch (...) {
12584       {
12585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12586       };
12587     }
12588   }
12589 }
12590
12591
12592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12593   void * jresult ;
12594   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12595   float *result = 0 ;
12596
12597   arg1 = (Dali::Matrix3 *)jarg1;
12598   {
12599     try {
12600       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12601     } catch (std::out_of_range& e) {
12602       {
12603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12604       };
12605     } catch (std::exception& e) {
12606       {
12607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12608       };
12609     } catch (...) {
12610       {
12611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12612       };
12613     }
12614   }
12615   jresult = (void *)result;
12616   return jresult;
12617 }
12618
12619
12620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12621   unsigned int jresult ;
12622   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12623   bool result;
12624
12625   arg1 = (Dali::Matrix3 *)jarg1;
12626   {
12627     try {
12628       result = (bool)(arg1)->Invert();
12629     } catch (std::out_of_range& e) {
12630       {
12631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12632       };
12633     } catch (std::exception& e) {
12634       {
12635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12636       };
12637     } catch (...) {
12638       {
12639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12640       };
12641     }
12642   }
12643   jresult = result;
12644   return jresult;
12645 }
12646
12647
12648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12649   unsigned int jresult ;
12650   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12651   bool result;
12652
12653   arg1 = (Dali::Matrix3 *)jarg1;
12654   {
12655     try {
12656       result = (bool)(arg1)->Transpose();
12657     } catch (std::out_of_range& e) {
12658       {
12659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12660       };
12661     } catch (std::exception& e) {
12662       {
12663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12664       };
12665     } catch (...) {
12666       {
12667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12668       };
12669     }
12670   }
12671   jresult = result;
12672   return jresult;
12673 }
12674
12675
12676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12677   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12678   float arg2 ;
12679
12680   arg1 = (Dali::Matrix3 *)jarg1;
12681   arg2 = (float)jarg2;
12682   {
12683     try {
12684       (arg1)->Scale(arg2);
12685     } catch (std::out_of_range& e) {
12686       {
12687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12688       };
12689     } catch (std::exception& e) {
12690       {
12691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12692       };
12693     } catch (...) {
12694       {
12695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12696       };
12697     }
12698   }
12699 }
12700
12701
12702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12703   float jresult ;
12704   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12705   float result;
12706
12707   arg1 = (Dali::Matrix3 *)jarg1;
12708   {
12709     try {
12710       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12711     } catch (std::out_of_range& e) {
12712       {
12713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12714       };
12715     } catch (std::exception& e) {
12716       {
12717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12718       };
12719     } catch (...) {
12720       {
12721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12722       };
12723     }
12724   }
12725   jresult = result;
12726   return jresult;
12727 }
12728
12729
12730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12731   unsigned int jresult ;
12732   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12733   bool result;
12734
12735   arg1 = (Dali::Matrix3 *)jarg1;
12736   {
12737     try {
12738       result = (bool)(arg1)->ScaledInverseTranspose();
12739     } catch (std::out_of_range& e) {
12740       {
12741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12742       };
12743     } catch (std::exception& e) {
12744       {
12745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12746       };
12747     } catch (...) {
12748       {
12749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12750       };
12751     }
12752   }
12753   jresult = result;
12754   return jresult;
12755 }
12756
12757
12758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12759   Dali::Matrix3 *arg1 = 0 ;
12760   Dali::Matrix3 *arg2 = 0 ;
12761   Dali::Matrix3 *arg3 = 0 ;
12762
12763   arg1 = (Dali::Matrix3 *)jarg1;
12764   if (!arg1) {
12765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12766     return ;
12767   }
12768   arg2 = (Dali::Matrix3 *)jarg2;
12769   if (!arg2) {
12770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12771     return ;
12772   }
12773   arg3 = (Dali::Matrix3 *)jarg3;
12774   if (!arg3) {
12775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12776     return ;
12777   }
12778   {
12779     try {
12780       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12781     } catch (std::out_of_range& e) {
12782       {
12783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12784       };
12785     } catch (std::exception& e) {
12786       {
12787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12788       };
12789     } catch (...) {
12790       {
12791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12792       };
12793     }
12794   }
12795 }
12796
12797
12798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12799   float jresult ;
12800   float arg1 ;
12801   float arg2 ;
12802   float result;
12803
12804   arg1 = (float)jarg1;
12805   arg2 = (float)jarg2;
12806   {
12807     try {
12808       result = (float)Dali::Random::Range(arg1,arg2);
12809     } catch (std::out_of_range& e) {
12810       {
12811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12812       };
12813     } catch (std::exception& e) {
12814       {
12815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12816       };
12817     } catch (...) {
12818       {
12819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12820       };
12821     }
12822   }
12823   jresult = result;
12824   return jresult;
12825 }
12826
12827
12828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12829   void * jresult ;
12830   Dali::Vector4 result;
12831
12832   {
12833     try {
12834       result = Dali::Random::Axis();
12835     } catch (std::out_of_range& e) {
12836       {
12837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12838       };
12839     } catch (std::exception& e) {
12840       {
12841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12842       };
12843     } catch (...) {
12844       {
12845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12846       };
12847     }
12848   }
12849   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12850   return jresult;
12851 }
12852
12853
12854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12855   void * jresult ;
12856   Dali::AngleAxis *result = 0 ;
12857
12858   {
12859     try {
12860       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12861     } catch (std::out_of_range& e) {
12862       {
12863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12864       };
12865     } catch (std::exception& e) {
12866       {
12867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12868       };
12869     } catch (...) {
12870       {
12871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12872       };
12873     }
12874   }
12875   jresult = (void *)result;
12876   return jresult;
12877 }
12878
12879
12880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12881   void * jresult ;
12882   Dali::Radian arg1 ;
12883   Dali::Vector3 *arg2 = 0 ;
12884   Dali::Radian *argp1 ;
12885   Dali::AngleAxis *result = 0 ;
12886
12887   argp1 = (Dali::Radian *)jarg1;
12888   if (!argp1) {
12889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12890     return 0;
12891   }
12892   arg1 = *argp1;
12893   arg2 = (Dali::Vector3 *)jarg2;
12894   if (!arg2) {
12895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12896     return 0;
12897   }
12898   {
12899     try {
12900       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12901     } catch (std::out_of_range& e) {
12902       {
12903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12904       };
12905     } catch (std::exception& e) {
12906       {
12907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12908       };
12909     } catch (...) {
12910       {
12911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12912       };
12913     }
12914   }
12915   jresult = (void *)result;
12916   return jresult;
12917 }
12918
12919
12920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12921   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12922   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12923
12924   arg1 = (Dali::AngleAxis *)jarg1;
12925   arg2 = (Dali::Radian *)jarg2;
12926   if (arg1) (arg1)->angle = *arg2;
12927 }
12928
12929
12930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12931   void * jresult ;
12932   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12933   Dali::Radian *result = 0 ;
12934
12935   arg1 = (Dali::AngleAxis *)jarg1;
12936   result = (Dali::Radian *)& ((arg1)->angle);
12937   jresult = (void *)result;
12938   return jresult;
12939 }
12940
12941
12942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12943   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12944   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12945
12946   arg1 = (Dali::AngleAxis *)jarg1;
12947   arg2 = (Dali::Vector3 *)jarg2;
12948   if (arg1) (arg1)->axis = *arg2;
12949 }
12950
12951
12952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12953   void * jresult ;
12954   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12955   Dali::Vector3 *result = 0 ;
12956
12957   arg1 = (Dali::AngleAxis *)jarg1;
12958   result = (Dali::Vector3 *)& ((arg1)->axis);
12959   jresult = (void *)result;
12960   return jresult;
12961 }
12962
12963
12964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12965   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12966
12967   arg1 = (Dali::AngleAxis *)jarg1;
12968   {
12969     try {
12970       delete arg1;
12971     } catch (std::out_of_range& e) {
12972       {
12973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12974       };
12975     } catch (std::exception& e) {
12976       {
12977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12978       };
12979     } catch (...) {
12980       {
12981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12982       };
12983     }
12984   }
12985 }
12986
12987
12988 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12989   unsigned int jresult ;
12990   Dali::AngleAxis *arg1 = 0 ;
12991   Dali::AngleAxis *arg2 = 0 ;
12992   bool result;
12993
12994   arg1 = (Dali::AngleAxis *)jarg1;
12995   if (!arg1) {
12996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12997     return 0;
12998   }
12999   arg2 = (Dali::AngleAxis *)jarg2;
13000   if (!arg2) {
13001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
13002     return 0;
13003   }
13004   {
13005     try {
13006       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
13007     } catch (std::out_of_range& e) {
13008       {
13009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13010       };
13011     } catch (std::exception& e) {
13012       {
13013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13014       };
13015     } catch (...) {
13016       {
13017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13018       };
13019     }
13020   }
13021   jresult = result;
13022   return jresult;
13023 }
13024
13025
13026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
13027   int jresult ;
13028   int result;
13029
13030   result = (int)(int)Dali::Property::INVALID_INDEX;
13031   jresult = result;
13032   return jresult;
13033 }
13034
13035
13036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
13037   int jresult ;
13038   int result;
13039
13040   result = (int)(int)Dali::Property::INVALID_KEY;
13041   jresult = result;
13042   return jresult;
13043 }
13044
13045
13046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
13047   int jresult ;
13048   int result;
13049
13050   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
13051   jresult = result;
13052   return jresult;
13053 }
13054
13055
13056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
13057   void * jresult ;
13058   Dali::Handle *arg1 = 0 ;
13059   Dali::Property::Index arg2 ;
13060   Dali::Property *result = 0 ;
13061
13062   arg1 = (Dali::Handle *)jarg1;
13063   if (!arg1) {
13064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13065     return 0;
13066   }
13067   arg2 = (Dali::Property::Index)jarg2;
13068   {
13069     try {
13070       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
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   return jresult;
13087 }
13088
13089
13090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13091   void * jresult ;
13092   Dali::Handle *arg1 = 0 ;
13093   Dali::Property::Index arg2 ;
13094   int arg3 ;
13095   Dali::Property *result = 0 ;
13096
13097   arg1 = (Dali::Handle *)jarg1;
13098   if (!arg1) {
13099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13100     return 0;
13101   }
13102   arg2 = (Dali::Property::Index)jarg2;
13103   arg3 = (int)jarg3;
13104   {
13105     try {
13106       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13107     } catch (std::out_of_range& e) {
13108       {
13109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13110       };
13111     } catch (std::exception& e) {
13112       {
13113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13114       };
13115     } catch (...) {
13116       {
13117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13118       };
13119     }
13120   }
13121   jresult = (void *)result;
13122   return jresult;
13123 }
13124
13125
13126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13127   void * jresult ;
13128   Dali::Handle *arg1 = 0 ;
13129   std::string *arg2 = 0 ;
13130   Dali::Property *result = 0 ;
13131
13132   arg1 = (Dali::Handle *)jarg1;
13133   if (!arg1) {
13134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13135     return 0;
13136   }
13137   if (!jarg2) {
13138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13139     return 0;
13140   }
13141   std::string arg2_str(jarg2);
13142   arg2 = &arg2_str;
13143   {
13144     try {
13145       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13146     } catch (std::out_of_range& e) {
13147       {
13148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13149       };
13150     } catch (std::exception& e) {
13151       {
13152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13153       };
13154     } catch (...) {
13155       {
13156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13157       };
13158     }
13159   }
13160   jresult = (void *)result;
13161
13162   //argout typemap for const std::string&
13163
13164   return jresult;
13165 }
13166
13167
13168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13169   void * jresult ;
13170   Dali::Handle *arg1 = 0 ;
13171   std::string *arg2 = 0 ;
13172   int arg3 ;
13173   Dali::Property *result = 0 ;
13174
13175   arg1 = (Dali::Handle *)jarg1;
13176   if (!arg1) {
13177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13178     return 0;
13179   }
13180   if (!jarg2) {
13181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13182     return 0;
13183   }
13184   std::string arg2_str(jarg2);
13185   arg2 = &arg2_str;
13186   arg3 = (int)jarg3;
13187   {
13188     try {
13189       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13190     } catch (std::out_of_range& e) {
13191       {
13192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13193       };
13194     } catch (std::exception& e) {
13195       {
13196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13197       };
13198     } catch (...) {
13199       {
13200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13201       };
13202     }
13203   }
13204   jresult = (void *)result;
13205
13206   //argout typemap for const std::string&
13207
13208   return jresult;
13209 }
13210
13211
13212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13213   Dali::Property *arg1 = (Dali::Property *) 0 ;
13214
13215   arg1 = (Dali::Property *)jarg1;
13216   {
13217     try {
13218       delete arg1;
13219     } catch (std::out_of_range& e) {
13220       {
13221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13222       };
13223     } catch (std::exception& e) {
13224       {
13225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13226       };
13227     } catch (...) {
13228       {
13229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13230       };
13231     }
13232   }
13233 }
13234
13235
13236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13237   Dali::Property *arg1 = (Dali::Property *) 0 ;
13238   Dali::Handle *arg2 = 0 ;
13239
13240   arg1 = (Dali::Property *)jarg1;
13241   arg2 = (Dali::Handle *)jarg2;
13242   if (!arg2) {
13243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13244     return ;
13245   }
13246   if (arg1) (arg1)->object = *arg2;
13247 }
13248
13249
13250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13251   void * jresult ;
13252   Dali::Property *arg1 = (Dali::Property *) 0 ;
13253   Dali::Handle *result = 0 ;
13254
13255   arg1 = (Dali::Property *)jarg1;
13256   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13257   jresult = (void *)result;
13258   return jresult;
13259 }
13260
13261
13262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13263   Dali::Property *arg1 = (Dali::Property *) 0 ;
13264   Dali::Property::Index arg2 ;
13265
13266   arg1 = (Dali::Property *)jarg1;
13267   arg2 = (Dali::Property::Index)jarg2;
13268   if (arg1) (arg1)->propertyIndex = arg2;
13269 }
13270
13271
13272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13273   int jresult ;
13274   Dali::Property *arg1 = (Dali::Property *) 0 ;
13275   Dali::Property::Index result;
13276
13277   arg1 = (Dali::Property *)jarg1;
13278   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13279   jresult = result;
13280   return jresult;
13281 }
13282
13283
13284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13285   Dali::Property *arg1 = (Dali::Property *) 0 ;
13286   int arg2 ;
13287
13288   arg1 = (Dali::Property *)jarg1;
13289   arg2 = (int)jarg2;
13290   if (arg1) (arg1)->componentIndex = arg2;
13291 }
13292
13293
13294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13295   int jresult ;
13296   Dali::Property *arg1 = (Dali::Property *) 0 ;
13297   int result;
13298
13299   arg1 = (Dali::Property *)jarg1;
13300   result = (int) ((arg1)->componentIndex);
13301   jresult = result;
13302   return jresult;
13303 }
13304
13305
13306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13307   void * jresult ;
13308   Dali::Property::Array *result = 0 ;
13309
13310   {
13311     try {
13312       result = (Dali::Property::Array *)new Dali::Property::Array();
13313     } catch (std::out_of_range& e) {
13314       {
13315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13316       };
13317     } catch (std::exception& e) {
13318       {
13319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13320       };
13321     } catch (...) {
13322       {
13323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13324       };
13325     }
13326   }
13327   jresult = (void *)result;
13328   return jresult;
13329 }
13330
13331
13332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13333   void * jresult ;
13334   Dali::Property::Array *arg1 = 0 ;
13335   Dali::Property::Array *result = 0 ;
13336
13337   arg1 = (Dali::Property::Array *)jarg1;
13338   if (!arg1) {
13339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13340     return 0;
13341   }
13342   {
13343     try {
13344       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13345     } catch (std::out_of_range& e) {
13346       {
13347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13348       };
13349     } catch (std::exception& e) {
13350       {
13351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13352       };
13353     } catch (...) {
13354       {
13355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13356       };
13357     }
13358   }
13359   jresult = (void *)result;
13360   return jresult;
13361 }
13362
13363
13364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13365   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13366
13367   arg1 = (Dali::Property::Array *)jarg1;
13368   {
13369     try {
13370       delete arg1;
13371     } catch (std::out_of_range& e) {
13372       {
13373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13374       };
13375     } catch (std::exception& e) {
13376       {
13377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13378       };
13379     } catch (...) {
13380       {
13381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13382       };
13383     }
13384   }
13385 }
13386
13387
13388 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13389   unsigned long jresult ;
13390   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13391   Dali::Property::Array::SizeType result;
13392
13393   arg1 = (Dali::Property::Array *)jarg1;
13394   {
13395     try {
13396       result = ((Dali::Property::Array const *)arg1)->Size();
13397     } catch (std::out_of_range& e) {
13398       {
13399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13400       };
13401     } catch (std::exception& e) {
13402       {
13403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13404       };
13405     } catch (...) {
13406       {
13407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13408       };
13409     }
13410   }
13411   jresult = (unsigned long)result;
13412   return jresult;
13413 }
13414
13415
13416 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13417   unsigned long jresult ;
13418   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13419   Dali::Property::Array::SizeType result;
13420
13421   arg1 = (Dali::Property::Array *)jarg1;
13422   {
13423     try {
13424       result = ((Dali::Property::Array const *)arg1)->Count();
13425     } catch (std::out_of_range& e) {
13426       {
13427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13428       };
13429     } catch (std::exception& e) {
13430       {
13431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13432       };
13433     } catch (...) {
13434       {
13435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13436       };
13437     }
13438   }
13439   jresult = (unsigned long)result;
13440   return jresult;
13441 }
13442
13443
13444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13445   unsigned int jresult ;
13446   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13447   bool result;
13448
13449   arg1 = (Dali::Property::Array *)jarg1;
13450   {
13451     try {
13452       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13453     } catch (std::out_of_range& e) {
13454       {
13455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13456       };
13457     } catch (std::exception& e) {
13458       {
13459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13460       };
13461     } catch (...) {
13462       {
13463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13464       };
13465     }
13466   }
13467   jresult = result;
13468   return jresult;
13469 }
13470
13471
13472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13473   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13474
13475   arg1 = (Dali::Property::Array *)jarg1;
13476   {
13477     try {
13478       (arg1)->Clear();
13479     } catch (std::out_of_range& e) {
13480       {
13481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13482       };
13483     } catch (std::exception& e) {
13484       {
13485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13486       };
13487     } catch (...) {
13488       {
13489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13490       };
13491     }
13492   }
13493 }
13494
13495
13496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13497   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13498   Dali::Property::Array::SizeType arg2 ;
13499
13500   arg1 = (Dali::Property::Array *)jarg1;
13501   arg2 = (Dali::Property::Array::SizeType)jarg2;
13502   {
13503     try {
13504       (arg1)->Reserve(arg2);
13505     } catch (std::out_of_range& e) {
13506       {
13507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13508       };
13509     } catch (std::exception& e) {
13510       {
13511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13512       };
13513     } catch (...) {
13514       {
13515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13516       };
13517     }
13518   }
13519 }
13520
13521
13522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13523   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13524   Dali::Property::Array::SizeType arg2 ;
13525
13526   arg1 = (Dali::Property::Array *)jarg1;
13527   arg2 = (Dali::Property::Array::SizeType)jarg2;
13528   {
13529     try {
13530       (arg1)->Resize(arg2);
13531     } catch (std::out_of_range& e) {
13532       {
13533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13534       };
13535     } catch (std::exception& e) {
13536       {
13537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13538       };
13539     } catch (...) {
13540       {
13541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13542       };
13543     }
13544   }
13545 }
13546
13547
13548 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13549   unsigned long jresult ;
13550   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13551   Dali::Property::Array::SizeType result;
13552
13553   arg1 = (Dali::Property::Array *)jarg1;
13554   {
13555     try {
13556       result = (arg1)->Capacity();
13557     } catch (std::out_of_range& e) {
13558       {
13559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13560       };
13561     } catch (std::exception& e) {
13562       {
13563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13564       };
13565     } catch (...) {
13566       {
13567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13568       };
13569     }
13570   }
13571   jresult = (unsigned long)result;
13572   return jresult;
13573 }
13574
13575
13576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13577   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13578   Dali::Property::Value *arg2 = 0 ;
13579
13580   arg1 = (Dali::Property::Array *)jarg1;
13581   arg2 = (Dali::Property::Value *)jarg2;
13582   if (!arg2) {
13583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13584     return ;
13585   }
13586   {
13587     try {
13588       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13589     } catch (std::out_of_range& e) {
13590       {
13591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13592       };
13593     } catch (std::exception& e) {
13594       {
13595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13596       };
13597     } catch (...) {
13598       {
13599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13600       };
13601     }
13602   }
13603 }
13604
13605
13606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13607   void * jresult ;
13608   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13609   Dali::Property::Value *arg2 = 0 ;
13610   Dali::Property::Array *result = 0 ;
13611
13612   arg1 = (Dali::Property::Array *)jarg1;
13613   arg2 = (Dali::Property::Value *)jarg2;
13614   if (!arg2) {
13615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13616     return 0;
13617   }
13618   {
13619     try {
13620       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13621     } catch (std::out_of_range& e) {
13622       {
13623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13624       };
13625     } catch (std::exception& e) {
13626       {
13627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13628       };
13629     } catch (...) {
13630       {
13631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13632       };
13633     }
13634   }
13635   jresult = (void *)result;
13636   return jresult;
13637 }
13638
13639
13640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13641   void * jresult ;
13642   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13643   Dali::Property::Array::SizeType arg2 ;
13644   Dali::Property::Value *result = 0 ;
13645
13646   arg1 = (Dali::Property::Array *)jarg1;
13647   arg2 = (Dali::Property::Array::SizeType)jarg2;
13648   {
13649     try {
13650       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13651     } catch (std::out_of_range& e) {
13652       {
13653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13654       };
13655     } catch (std::exception& e) {
13656       {
13657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13658       };
13659     } catch (...) {
13660       {
13661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13662       };
13663     }
13664   }
13665   jresult = (void *)result;
13666   return jresult;
13667 }
13668
13669
13670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13671   void * jresult ;
13672   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13673   Dali::Property::Array::SizeType arg2 ;
13674   Dali::Property::Value *result = 0 ;
13675
13676   arg1 = (Dali::Property::Array *)jarg1;
13677   arg2 = (Dali::Property::Array::SizeType)jarg2;
13678   {
13679     try {
13680       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13681     } catch (std::out_of_range& e) {
13682       {
13683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13684       };
13685     } catch (std::exception& e) {
13686       {
13687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13688       };
13689     } catch (...) {
13690       {
13691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13692       };
13693     }
13694   }
13695   jresult = (void *)result;
13696   return jresult;
13697 }
13698
13699
13700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13701   void * jresult ;
13702   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13703   Dali::Property::Array *arg2 = 0 ;
13704   Dali::Property::Array *result = 0 ;
13705
13706   arg1 = (Dali::Property::Array *)jarg1;
13707   arg2 = (Dali::Property::Array *)jarg2;
13708   if (!arg2) {
13709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13710     return 0;
13711   }
13712   {
13713     try {
13714       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13715     } catch (std::out_of_range& e) {
13716       {
13717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13718       };
13719     } catch (std::exception& e) {
13720       {
13721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13722       };
13723     } catch (...) {
13724       {
13725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13726       };
13727     }
13728   }
13729   jresult = (void *)result;
13730   return jresult;
13731 }
13732
13733
13734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13735   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13736   enum Dali::Property::Key::Type arg2 ;
13737
13738   arg1 = (Dali::Property::Key *)jarg1;
13739   arg2 = (enum Dali::Property::Key::Type)jarg2;
13740   if (arg1) (arg1)->type = arg2;
13741 }
13742
13743
13744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13745   int jresult ;
13746   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13747   enum Dali::Property::Key::Type result;
13748
13749   arg1 = (Dali::Property::Key *)jarg1;
13750   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13751   jresult = (int)result;
13752   return jresult;
13753 }
13754
13755
13756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13757   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13758   Dali::Property::Index arg2 ;
13759
13760   arg1 = (Dali::Property::Key *)jarg1;
13761   arg2 = (Dali::Property::Index)jarg2;
13762   if (arg1) (arg1)->indexKey = arg2;
13763 }
13764
13765
13766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13767   int jresult ;
13768   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13769   Dali::Property::Index result;
13770
13771   arg1 = (Dali::Property::Key *)jarg1;
13772   result = (Dali::Property::Index) ((arg1)->indexKey);
13773   jresult = result;
13774   return jresult;
13775 }
13776
13777
13778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13779   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13780   std::string *arg2 = 0 ;
13781
13782   arg1 = (Dali::Property::Key *)jarg1;
13783   if (!jarg2) {
13784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13785     return ;
13786   }
13787   std::string arg2_str(jarg2);
13788   arg2 = &arg2_str;
13789   if (arg1) (arg1)->stringKey = *arg2;
13790
13791   //argout typemap for const std::string&
13792
13793 }
13794
13795
13796 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13797   char * jresult ;
13798   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13799   std::string *result = 0 ;
13800
13801   arg1 = (Dali::Property::Key *)jarg1;
13802   result = (std::string *) & ((arg1)->stringKey);
13803   jresult = SWIG_csharp_string_callback(result->c_str());
13804   return jresult;
13805 }
13806
13807
13808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13809   void * jresult ;
13810   std::string *arg1 = 0 ;
13811   Dali::Property::Key *result = 0 ;
13812
13813   if (!jarg1) {
13814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13815     return 0;
13816   }
13817   std::string arg1_str(jarg1);
13818   arg1 = &arg1_str;
13819   {
13820     try {
13821       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13822     } catch (std::out_of_range& e) {
13823       {
13824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13825       };
13826     } catch (std::exception& e) {
13827       {
13828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13829       };
13830     } catch (...) {
13831       {
13832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13833       };
13834     }
13835   }
13836   jresult = (void *)result;
13837
13838   //argout typemap for const std::string&
13839
13840   return jresult;
13841 }
13842
13843
13844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13845   void * jresult ;
13846   Dali::Property::Index arg1 ;
13847   Dali::Property::Key *result = 0 ;
13848
13849   arg1 = (Dali::Property::Index)jarg1;
13850   {
13851     try {
13852       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13853     } catch (std::out_of_range& e) {
13854       {
13855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13856       };
13857     } catch (std::exception& e) {
13858       {
13859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13860       };
13861     } catch (...) {
13862       {
13863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13864       };
13865     }
13866   }
13867   jresult = (void *)result;
13868   return jresult;
13869 }
13870
13871
13872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13873   unsigned int jresult ;
13874   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13875   std::string *arg2 = 0 ;
13876   bool result;
13877
13878   arg1 = (Dali::Property::Key *)jarg1;
13879   if (!jarg2) {
13880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13881     return 0;
13882   }
13883   std::string arg2_str(jarg2);
13884   arg2 = &arg2_str;
13885   {
13886     try {
13887       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13888     } catch (std::out_of_range& e) {
13889       {
13890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13891       };
13892     } catch (std::exception& e) {
13893       {
13894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13895       };
13896     } catch (...) {
13897       {
13898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13899       };
13900     }
13901   }
13902   jresult = result;
13903
13904   //argout typemap for const std::string&
13905
13906   return jresult;
13907 }
13908
13909
13910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13911   unsigned int jresult ;
13912   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13913   Dali::Property::Index arg2 ;
13914   bool result;
13915
13916   arg1 = (Dali::Property::Key *)jarg1;
13917   arg2 = (Dali::Property::Index)jarg2;
13918   {
13919     try {
13920       result = (bool)(arg1)->operator ==(arg2);
13921     } catch (std::out_of_range& e) {
13922       {
13923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13924       };
13925     } catch (std::exception& e) {
13926       {
13927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13928       };
13929     } catch (...) {
13930       {
13931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13932       };
13933     }
13934   }
13935   jresult = result;
13936   return jresult;
13937 }
13938
13939
13940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13941   unsigned int jresult ;
13942   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13943   Dali::Property::Key *arg2 = 0 ;
13944   bool result;
13945
13946   arg1 = (Dali::Property::Key *)jarg1;
13947   arg2 = (Dali::Property::Key *)jarg2;
13948   if (!arg2) {
13949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13950     return 0;
13951   }
13952   {
13953     try {
13954       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13955     } catch (std::out_of_range& e) {
13956       {
13957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13958       };
13959     } catch (std::exception& e) {
13960       {
13961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13962       };
13963     } catch (...) {
13964       {
13965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13966       };
13967     }
13968   }
13969   jresult = result;
13970   return jresult;
13971 }
13972
13973
13974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13975   unsigned int jresult ;
13976   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13977   std::string *arg2 = 0 ;
13978   bool result;
13979
13980   arg1 = (Dali::Property::Key *)jarg1;
13981   if (!jarg2) {
13982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13983     return 0;
13984   }
13985   std::string arg2_str(jarg2);
13986   arg2 = &arg2_str;
13987   {
13988     try {
13989       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13990     } catch (std::out_of_range& e) {
13991       {
13992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13993       };
13994     } catch (std::exception& e) {
13995       {
13996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13997       };
13998     } catch (...) {
13999       {
14000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14001       };
14002     }
14003   }
14004   jresult = result;
14005
14006   //argout typemap for const std::string&
14007
14008   return jresult;
14009 }
14010
14011
14012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
14013   unsigned int jresult ;
14014   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14015   Dali::Property::Index arg2 ;
14016   bool result;
14017
14018   arg1 = (Dali::Property::Key *)jarg1;
14019   arg2 = (Dali::Property::Index)jarg2;
14020   {
14021     try {
14022       result = (bool)(arg1)->operator !=(arg2);
14023     } catch (std::out_of_range& e) {
14024       {
14025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14026       };
14027     } catch (std::exception& e) {
14028       {
14029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14030       };
14031     } catch (...) {
14032       {
14033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14034       };
14035     }
14036   }
14037   jresult = result;
14038   return jresult;
14039 }
14040
14041
14042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
14043   unsigned int jresult ;
14044   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14045   Dali::Property::Key *arg2 = 0 ;
14046   bool result;
14047
14048   arg1 = (Dali::Property::Key *)jarg1;
14049   arg2 = (Dali::Property::Key *)jarg2;
14050   if (!arg2) {
14051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
14052     return 0;
14053   }
14054   {
14055     try {
14056       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
14057     } catch (std::out_of_range& e) {
14058       {
14059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14060       };
14061     } catch (std::exception& e) {
14062       {
14063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14064       };
14065     } catch (...) {
14066       {
14067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14068       };
14069     }
14070   }
14071   jresult = result;
14072   return jresult;
14073 }
14074
14075
14076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
14077   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14078
14079   arg1 = (Dali::Property::Key *)jarg1;
14080   {
14081     try {
14082       delete arg1;
14083     } catch (std::out_of_range& e) {
14084       {
14085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14086       };
14087     } catch (std::exception& e) {
14088       {
14089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14090       };
14091     } catch (...) {
14092       {
14093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14094       };
14095     }
14096   }
14097 }
14098
14099
14100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
14101   void * jresult ;
14102   Dali::Property::Map *result = 0 ;
14103
14104   {
14105     try {
14106       result = (Dali::Property::Map *)new Dali::Property::Map();
14107     } catch (std::out_of_range& e) {
14108       {
14109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14110       };
14111     } catch (std::exception& e) {
14112       {
14113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14114       };
14115     } catch (...) {
14116       {
14117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14118       };
14119     }
14120   }
14121   jresult = (void *)result;
14122   return jresult;
14123 }
14124
14125
14126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14127   void * jresult ;
14128   Dali::Property::Map *arg1 = 0 ;
14129   Dali::Property::Map *result = 0 ;
14130
14131   arg1 = (Dali::Property::Map *)jarg1;
14132   if (!arg1) {
14133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14134     return 0;
14135   }
14136   {
14137     try {
14138       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14139     } catch (std::out_of_range& e) {
14140       {
14141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14142       };
14143     } catch (std::exception& e) {
14144       {
14145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14146       };
14147     } catch (...) {
14148       {
14149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14150       };
14151     }
14152   }
14153   jresult = (void *)result;
14154   return jresult;
14155 }
14156
14157
14158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14159   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14160
14161   arg1 = (Dali::Property::Map *)jarg1;
14162   {
14163     try {
14164       delete arg1;
14165     } catch (std::out_of_range& e) {
14166       {
14167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14168       };
14169     } catch (std::exception& e) {
14170       {
14171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14172       };
14173     } catch (...) {
14174       {
14175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14176       };
14177     }
14178   }
14179 }
14180
14181
14182 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14183   unsigned long jresult ;
14184   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14185   Dali::Property::Map::SizeType result;
14186
14187   arg1 = (Dali::Property::Map *)jarg1;
14188   {
14189     try {
14190       result = ((Dali::Property::Map const *)arg1)->Count();
14191     } catch (std::out_of_range& e) {
14192       {
14193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14194       };
14195     } catch (std::exception& e) {
14196       {
14197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14198       };
14199     } catch (...) {
14200       {
14201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14202       };
14203     }
14204   }
14205   jresult = (unsigned long)result;
14206   return jresult;
14207 }
14208
14209
14210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14211   unsigned int jresult ;
14212   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14213   bool result;
14214
14215   arg1 = (Dali::Property::Map *)jarg1;
14216   {
14217     try {
14218       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14219     } catch (std::out_of_range& e) {
14220       {
14221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14222       };
14223     } catch (std::exception& e) {
14224       {
14225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14226       };
14227     } catch (...) {
14228       {
14229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14230       };
14231     }
14232   }
14233   jresult = result;
14234   return jresult;
14235 }
14236
14237
14238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14239   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14240   char *arg2 = (char *) 0 ;
14241   Dali::Property::Value *arg3 = 0 ;
14242
14243   arg1 = (Dali::Property::Map *)jarg1;
14244   arg2 = (char *)jarg2;
14245   arg3 = (Dali::Property::Value *)jarg3;
14246   if (!arg3) {
14247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14248     return ;
14249   }
14250   {
14251     try {
14252       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14253     } catch (std::out_of_range& e) {
14254       {
14255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14256       };
14257     } catch (std::exception& e) {
14258       {
14259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14260       };
14261     } catch (...) {
14262       {
14263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14264       };
14265     }
14266   }
14267 }
14268
14269
14270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14271   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14272   Dali::Property::Index arg2 ;
14273   Dali::Property::Value *arg3 = 0 ;
14274
14275   arg1 = (Dali::Property::Map *)jarg1;
14276   arg2 = (Dali::Property::Index)jarg2;
14277   arg3 = (Dali::Property::Value *)jarg3;
14278   if (!arg3) {
14279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14280     return ;
14281   }
14282   {
14283     try {
14284       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14285     } catch (std::out_of_range& e) {
14286       {
14287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14288       };
14289     } catch (std::exception& e) {
14290       {
14291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14292       };
14293     } catch (...) {
14294       {
14295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14296       };
14297     }
14298   }
14299 }
14300
14301
14302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14303   void * jresult ;
14304   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14305   char *arg2 = (char *) 0 ;
14306   Dali::Property::Value *arg3 = 0 ;
14307   Dali::Property::Map *result = 0 ;
14308
14309   arg1 = (Dali::Property::Map *)jarg1;
14310   arg2 = (char *)jarg2;
14311   arg3 = (Dali::Property::Value *)jarg3;
14312   if (!arg3) {
14313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14314     return 0;
14315   }
14316   {
14317     try {
14318       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14319     } catch (std::out_of_range& e) {
14320       {
14321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14322       };
14323     } catch (std::exception& e) {
14324       {
14325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14326       };
14327     } catch (...) {
14328       {
14329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14330       };
14331     }
14332   }
14333   jresult = (void *)result;
14334   return jresult;
14335 }
14336
14337
14338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14339   void * jresult ;
14340   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14341   Dali::Property::Index arg2 ;
14342   Dali::Property::Value *arg3 = 0 ;
14343   Dali::Property::Map *result = 0 ;
14344
14345   arg1 = (Dali::Property::Map *)jarg1;
14346   arg2 = (Dali::Property::Index)jarg2;
14347   arg3 = (Dali::Property::Value *)jarg3;
14348   if (!arg3) {
14349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14350     return 0;
14351   }
14352   {
14353     try {
14354       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14355     } catch (std::out_of_range& e) {
14356       {
14357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14358       };
14359     } catch (std::exception& e) {
14360       {
14361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14362       };
14363     } catch (...) {
14364       {
14365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14366       };
14367     }
14368   }
14369   jresult = (void *)result;
14370   return jresult;
14371 }
14372
14373
14374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14375   void * jresult ;
14376   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14377   Dali::Property::Map::SizeType arg2 ;
14378   Dali::Property::Value *result = 0 ;
14379
14380   arg1 = (Dali::Property::Map *)jarg1;
14381   arg2 = (Dali::Property::Map::SizeType)jarg2;
14382   {
14383     try {
14384       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14385     } catch (std::out_of_range& e) {
14386       {
14387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14388       };
14389     } catch (std::exception& e) {
14390       {
14391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14392       };
14393     } catch (...) {
14394       {
14395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14396       };
14397     }
14398   }
14399   jresult = (void *)result;
14400   return jresult;
14401 }
14402
14403
14404 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14405   char * jresult ;
14406   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14407   Dali::Property::Map::SizeType arg2 ;
14408   std::string *result = 0 ;
14409
14410   arg1 = (Dali::Property::Map *)jarg1;
14411   arg2 = (Dali::Property::Map::SizeType)jarg2;
14412   {
14413     try {
14414       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14415     } catch (std::out_of_range& e) {
14416       {
14417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14418       };
14419     } catch (std::exception& e) {
14420       {
14421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14422       };
14423     } catch (...) {
14424       {
14425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14426       };
14427     }
14428   }
14429   jresult = SWIG_csharp_string_callback(result->c_str());
14430   return jresult;
14431 }
14432
14433
14434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14435   void * jresult ;
14436   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14437   Dali::Property::Map::SizeType arg2 ;
14438   SwigValueWrapper< Dali::Property::Key > result;
14439
14440   arg1 = (Dali::Property::Map *)jarg1;
14441   arg2 = (Dali::Property::Map::SizeType)jarg2;
14442   {
14443     try {
14444       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14445     } catch (std::out_of_range& e) {
14446       {
14447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14448       };
14449     } catch (std::exception& e) {
14450       {
14451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14452       };
14453     } catch (...) {
14454       {
14455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14456       };
14457     }
14458   }
14459   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14460   return jresult;
14461 }
14462
14463
14464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14465   void * jresult ;
14466   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14467   Dali::Property::Map::SizeType arg2 ;
14468   StringValuePair *result = 0 ;
14469
14470   arg1 = (Dali::Property::Map *)jarg1;
14471   arg2 = (Dali::Property::Map::SizeType)jarg2;
14472   {
14473     try {
14474       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14475     } catch (std::out_of_range& e) {
14476       {
14477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14478       };
14479     } catch (std::exception& e) {
14480       {
14481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14482       };
14483     } catch (...) {
14484       {
14485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14486       };
14487     }
14488   }
14489   jresult = (void *)result;
14490   return jresult;
14491 }
14492
14493
14494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14495   void * jresult ;
14496   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14497   char *arg2 = (char *) 0 ;
14498   Dali::Property::Value *result = 0 ;
14499
14500   arg1 = (Dali::Property::Map *)jarg1;
14501   arg2 = (char *)jarg2;
14502   {
14503     try {
14504       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14505     } catch (std::out_of_range& e) {
14506       {
14507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14508       };
14509     } catch (std::exception& e) {
14510       {
14511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14512       };
14513     } catch (...) {
14514       {
14515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14516       };
14517     }
14518   }
14519   jresult = (void *)result;
14520   return jresult;
14521 }
14522
14523
14524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14525   void * jresult ;
14526   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14527   Dali::Property::Index arg2 ;
14528   Dali::Property::Value *result = 0 ;
14529
14530   arg1 = (Dali::Property::Map *)jarg1;
14531   arg2 = (Dali::Property::Index)jarg2;
14532   {
14533     try {
14534       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14535     } catch (std::out_of_range& e) {
14536       {
14537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14538       };
14539     } catch (std::exception& e) {
14540       {
14541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14542       };
14543     } catch (...) {
14544       {
14545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14546       };
14547     }
14548   }
14549   jresult = (void *)result;
14550   return jresult;
14551 }
14552
14553
14554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14555   void * jresult ;
14556   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14557   Dali::Property::Index arg2 ;
14558   std::string *arg3 = 0 ;
14559   Dali::Property::Value *result = 0 ;
14560
14561   arg1 = (Dali::Property::Map *)jarg1;
14562   arg2 = (Dali::Property::Index)jarg2;
14563   if (!jarg3) {
14564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14565     return 0;
14566   }
14567   std::string arg3_str(jarg3);
14568   arg3 = &arg3_str;
14569   {
14570     try {
14571       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14572     } catch (std::out_of_range& e) {
14573       {
14574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14575       };
14576     } catch (std::exception& e) {
14577       {
14578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14579       };
14580     } catch (...) {
14581       {
14582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14583       };
14584     }
14585   }
14586   jresult = (void *)result;
14587
14588   //argout typemap for const std::string&
14589
14590   return jresult;
14591 }
14592
14593
14594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14595   void * jresult ;
14596   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14597   std::string *arg2 = 0 ;
14598   Dali::Property::Type arg3 ;
14599   Dali::Property::Value *result = 0 ;
14600
14601   arg1 = (Dali::Property::Map *)jarg1;
14602   if (!jarg2) {
14603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14604     return 0;
14605   }
14606   std::string arg2_str(jarg2);
14607   arg2 = &arg2_str;
14608   arg3 = (Dali::Property::Type)jarg3;
14609   {
14610     try {
14611       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14612     } catch (std::out_of_range& e) {
14613       {
14614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14615       };
14616     } catch (std::exception& e) {
14617       {
14618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14619       };
14620     } catch (...) {
14621       {
14622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14623       };
14624     }
14625   }
14626   jresult = (void *)result;
14627
14628   //argout typemap for const std::string&
14629
14630   return jresult;
14631 }
14632
14633
14634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14635   void * jresult ;
14636   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14637   Dali::Property::Index arg2 ;
14638   Dali::Property::Type arg3 ;
14639   Dali::Property::Value *result = 0 ;
14640
14641   arg1 = (Dali::Property::Map *)jarg1;
14642   arg2 = (Dali::Property::Index)jarg2;
14643   arg3 = (Dali::Property::Type)jarg3;
14644   {
14645     try {
14646       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14647     } catch (std::out_of_range& e) {
14648       {
14649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14650       };
14651     } catch (std::exception& e) {
14652       {
14653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14654       };
14655     } catch (...) {
14656       {
14657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14658       };
14659     }
14660   }
14661   jresult = (void *)result;
14662   return jresult;
14663 }
14664
14665
14666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14667   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14668
14669   arg1 = (Dali::Property::Map *)jarg1;
14670   {
14671     try {
14672       (arg1)->Clear();
14673     } catch (std::out_of_range& e) {
14674       {
14675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14676       };
14677     } catch (std::exception& e) {
14678       {
14679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14680       };
14681     } catch (...) {
14682       {
14683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14684       };
14685     }
14686   }
14687 }
14688
14689
14690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14691   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14692   Dali::Property::Map *arg2 = 0 ;
14693
14694   arg1 = (Dali::Property::Map *)jarg1;
14695   arg2 = (Dali::Property::Map *)jarg2;
14696   if (!arg2) {
14697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14698     return ;
14699   }
14700   {
14701     try {
14702       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14703     } catch (std::out_of_range& e) {
14704       {
14705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14706       };
14707     } catch (std::exception& e) {
14708       {
14709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14710       };
14711     } catch (...) {
14712       {
14713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14714       };
14715     }
14716   }
14717 }
14718
14719
14720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14721   void * jresult ;
14722   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14723   std::string *arg2 = 0 ;
14724   Dali::Property::Value *result = 0 ;
14725
14726   arg1 = (Dali::Property::Map *)jarg1;
14727   if (!jarg2) {
14728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14729     return 0;
14730   }
14731   std::string arg2_str(jarg2);
14732   arg2 = &arg2_str;
14733   {
14734     try {
14735       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14736     } catch (std::out_of_range& e) {
14737       {
14738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14739       };
14740     } catch (std::exception& e) {
14741       {
14742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14743       };
14744     } catch (...) {
14745       {
14746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14747       };
14748     }
14749   }
14750   jresult = (void *)result;
14751
14752   //argout typemap for const std::string&
14753
14754   return jresult;
14755 }
14756
14757
14758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14759   void * jresult ;
14760   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14761   Dali::Property::Index arg2 ;
14762   Dali::Property::Value *result = 0 ;
14763
14764   arg1 = (Dali::Property::Map *)jarg1;
14765   arg2 = (Dali::Property::Index)jarg2;
14766   {
14767     try {
14768       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14769     } catch (std::out_of_range& e) {
14770       {
14771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14772       };
14773     } catch (std::exception& e) {
14774       {
14775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14776       };
14777     } catch (...) {
14778       {
14779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14780       };
14781     }
14782   }
14783   jresult = (void *)result;
14784   return jresult;
14785 }
14786
14787
14788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14789   void * jresult ;
14790   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14791   Dali::Property::Map *arg2 = 0 ;
14792   Dali::Property::Map *result = 0 ;
14793
14794   arg1 = (Dali::Property::Map *)jarg1;
14795   arg2 = (Dali::Property::Map *)jarg2;
14796   if (!arg2) {
14797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14798     return 0;
14799   }
14800   {
14801     try {
14802       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14803     } catch (std::out_of_range& e) {
14804       {
14805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14806       };
14807     } catch (std::exception& e) {
14808       {
14809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14810       };
14811     } catch (...) {
14812       {
14813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14814       };
14815     }
14816   }
14817   jresult = (void *)result;
14818   return jresult;
14819 }
14820
14821
14822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14823   void * jresult ;
14824   Dali::Property::Value *result = 0 ;
14825
14826   {
14827     try {
14828       result = (Dali::Property::Value *)new Dali::Property::Value();
14829     } catch (std::out_of_range& e) {
14830       {
14831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14832       };
14833     } catch (std::exception& e) {
14834       {
14835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14836       };
14837     } catch (...) {
14838       {
14839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14840       };
14841     }
14842   }
14843   jresult = (void *)result;
14844   return jresult;
14845 }
14846
14847
14848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14849   void * jresult ;
14850   bool arg1 ;
14851   Dali::Property::Value *result = 0 ;
14852
14853   arg1 = jarg1 ? true : false;
14854   {
14855     try {
14856       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14857     } catch (std::out_of_range& e) {
14858       {
14859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14860       };
14861     } catch (std::exception& e) {
14862       {
14863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14864       };
14865     } catch (...) {
14866       {
14867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14868       };
14869     }
14870   }
14871   jresult = (void *)result;
14872   return jresult;
14873 }
14874
14875
14876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14877   void * jresult ;
14878   int arg1 ;
14879   Dali::Property::Value *result = 0 ;
14880
14881   arg1 = (int)jarg1;
14882   {
14883     try {
14884       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14885     } catch (std::out_of_range& e) {
14886       {
14887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14888       };
14889     } catch (std::exception& e) {
14890       {
14891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14892       };
14893     } catch (...) {
14894       {
14895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14896       };
14897     }
14898   }
14899   jresult = (void *)result;
14900   return jresult;
14901 }
14902
14903
14904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14905   void * jresult ;
14906   float arg1 ;
14907   Dali::Property::Value *result = 0 ;
14908
14909   arg1 = (float)jarg1;
14910   {
14911     try {
14912       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14913     } catch (std::out_of_range& e) {
14914       {
14915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14916       };
14917     } catch (std::exception& e) {
14918       {
14919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14920       };
14921     } catch (...) {
14922       {
14923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14924       };
14925     }
14926   }
14927   jresult = (void *)result;
14928   return jresult;
14929 }
14930
14931
14932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14933   void * jresult ;
14934   Dali::Vector2 *arg1 = 0 ;
14935   Dali::Property::Value *result = 0 ;
14936
14937   arg1 = (Dali::Vector2 *)jarg1;
14938   if (!arg1) {
14939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14940     return 0;
14941   }
14942   {
14943     try {
14944       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14945     } catch (std::out_of_range& e) {
14946       {
14947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14948       };
14949     } catch (std::exception& e) {
14950       {
14951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14952       };
14953     } catch (...) {
14954       {
14955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14956       };
14957     }
14958   }
14959   jresult = (void *)result;
14960   return jresult;
14961 }
14962
14963
14964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14965   void * jresult ;
14966   Dali::Vector3 *arg1 = 0 ;
14967   Dali::Property::Value *result = 0 ;
14968
14969   arg1 = (Dali::Vector3 *)jarg1;
14970   if (!arg1) {
14971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14972     return 0;
14973   }
14974   {
14975     try {
14976       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14977     } catch (std::out_of_range& e) {
14978       {
14979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14980       };
14981     } catch (std::exception& e) {
14982       {
14983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14984       };
14985     } catch (...) {
14986       {
14987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14988       };
14989     }
14990   }
14991   jresult = (void *)result;
14992   return jresult;
14993 }
14994
14995
14996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14997   void * jresult ;
14998   Dali::Vector4 *arg1 = 0 ;
14999   Dali::Property::Value *result = 0 ;
15000
15001   arg1 = (Dali::Vector4 *)jarg1;
15002   if (!arg1) {
15003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
15004     return 0;
15005   }
15006   {
15007     try {
15008       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
15009     } catch (std::out_of_range& e) {
15010       {
15011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15012       };
15013     } catch (std::exception& e) {
15014       {
15015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15016       };
15017     } catch (...) {
15018       {
15019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15020       };
15021     }
15022   }
15023   jresult = (void *)result;
15024   return jresult;
15025 }
15026
15027
15028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
15029   void * jresult ;
15030   Dali::Matrix3 *arg1 = 0 ;
15031   Dali::Property::Value *result = 0 ;
15032
15033   arg1 = (Dali::Matrix3 *)jarg1;
15034   if (!arg1) {
15035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
15036     return 0;
15037   }
15038   {
15039     try {
15040       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
15041     } catch (std::out_of_range& e) {
15042       {
15043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15044       };
15045     } catch (std::exception& e) {
15046       {
15047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15048       };
15049     } catch (...) {
15050       {
15051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15052       };
15053     }
15054   }
15055   jresult = (void *)result;
15056   return jresult;
15057 }
15058
15059
15060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
15061   void * jresult ;
15062   Dali::Matrix *arg1 = 0 ;
15063   Dali::Property::Value *result = 0 ;
15064
15065   arg1 = (Dali::Matrix *)jarg1;
15066   if (!arg1) {
15067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15068     return 0;
15069   }
15070   {
15071     try {
15072       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15073     } catch (std::out_of_range& e) {
15074       {
15075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15076       };
15077     } catch (std::exception& e) {
15078       {
15079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15080       };
15081     } catch (...) {
15082       {
15083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15084       };
15085     }
15086   }
15087   jresult = (void *)result;
15088   return jresult;
15089 }
15090
15091
15092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
15093   void * jresult ;
15094   Dali::Rect< int > *arg1 = 0 ;
15095   Dali::Property::Value *result = 0 ;
15096
15097   arg1 = (Dali::Rect< int > *)jarg1;
15098   if (!arg1) {
15099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15100     return 0;
15101   }
15102   {
15103     try {
15104       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15105     } catch (std::out_of_range& e) {
15106       {
15107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15108       };
15109     } catch (std::exception& e) {
15110       {
15111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15112       };
15113     } catch (...) {
15114       {
15115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15116       };
15117     }
15118   }
15119   jresult = (void *)result;
15120   return jresult;
15121 }
15122
15123
15124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15125   void * jresult ;
15126   Dali::AngleAxis *arg1 = 0 ;
15127   Dali::Property::Value *result = 0 ;
15128
15129   arg1 = (Dali::AngleAxis *)jarg1;
15130   if (!arg1) {
15131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15132     return 0;
15133   }
15134   {
15135     try {
15136       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15137     } catch (std::out_of_range& e) {
15138       {
15139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15140       };
15141     } catch (std::exception& e) {
15142       {
15143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15144       };
15145     } catch (...) {
15146       {
15147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15148       };
15149     }
15150   }
15151   jresult = (void *)result;
15152   return jresult;
15153 }
15154
15155
15156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15157   void * jresult ;
15158   Dali::Quaternion *arg1 = 0 ;
15159   Dali::Property::Value *result = 0 ;
15160
15161   arg1 = (Dali::Quaternion *)jarg1;
15162   if (!arg1) {
15163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15164     return 0;
15165   }
15166   {
15167     try {
15168       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15169     } catch (std::out_of_range& e) {
15170       {
15171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15172       };
15173     } catch (std::exception& e) {
15174       {
15175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15176       };
15177     } catch (...) {
15178       {
15179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15180       };
15181     }
15182   }
15183   jresult = (void *)result;
15184   return jresult;
15185 }
15186
15187
15188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15189   void * jresult ;
15190   std::string *arg1 = 0 ;
15191   Dali::Property::Value *result = 0 ;
15192
15193   if (!jarg1) {
15194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15195     return 0;
15196   }
15197   std::string arg1_str(jarg1);
15198   arg1 = &arg1_str;
15199   {
15200     try {
15201       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15202     } catch (std::out_of_range& e) {
15203       {
15204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15205       };
15206     } catch (std::exception& e) {
15207       {
15208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15209       };
15210     } catch (...) {
15211       {
15212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15213       };
15214     }
15215   }
15216   jresult = (void *)result;
15217
15218   //argout typemap for const std::string&
15219
15220   return jresult;
15221 }
15222
15223
15224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15225   void * jresult ;
15226   Dali::Property::Array *arg1 = 0 ;
15227   Dali::Property::Value *result = 0 ;
15228
15229   arg1 = (Dali::Property::Array *)jarg1;
15230   if (!arg1) {
15231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15232     return 0;
15233   }
15234   {
15235     try {
15236       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15237     } catch (std::out_of_range& e) {
15238       {
15239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15240       };
15241     } catch (std::exception& e) {
15242       {
15243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15244       };
15245     } catch (...) {
15246       {
15247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15248       };
15249     }
15250   }
15251   jresult = (void *)result;
15252   return jresult;
15253 }
15254
15255
15256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15257   void * jresult ;
15258   Dali::Property::Map *arg1 = 0 ;
15259   Dali::Property::Value *result = 0 ;
15260
15261   arg1 = (Dali::Property::Map *)jarg1;
15262   if (!arg1) {
15263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15264     return 0;
15265   }
15266   {
15267     try {
15268       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15269     } catch (std::out_of_range& e) {
15270       {
15271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15272       };
15273     } catch (std::exception& e) {
15274       {
15275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15276       };
15277     } catch (...) {
15278       {
15279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15280       };
15281     }
15282   }
15283   jresult = (void *)result;
15284   return jresult;
15285 }
15286
15287
15288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15289   void * jresult ;
15290   Dali::Property::Type arg1 ;
15291   Dali::Property::Value *result = 0 ;
15292
15293   arg1 = (Dali::Property::Type)jarg1;
15294   {
15295     try {
15296       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15297     } catch (std::out_of_range& e) {
15298       {
15299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15300       };
15301     } catch (std::exception& e) {
15302       {
15303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15304       };
15305     } catch (...) {
15306       {
15307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15308       };
15309     }
15310   }
15311   jresult = (void *)result;
15312   return jresult;
15313 }
15314
15315
15316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15317   void * jresult ;
15318   Dali::Property::Value *arg1 = 0 ;
15319   Dali::Property::Value *result = 0 ;
15320
15321   arg1 = (Dali::Property::Value *)jarg1;
15322   if (!arg1) {
15323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15324     return 0;
15325   }
15326   {
15327     try {
15328       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15329     } catch (std::out_of_range& e) {
15330       {
15331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15332       };
15333     } catch (std::exception& e) {
15334       {
15335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15336       };
15337     } catch (...) {
15338       {
15339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15340       };
15341     }
15342   }
15343   jresult = (void *)result;
15344   return jresult;
15345 }
15346
15347
15348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15349   void * jresult ;
15350   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15351   Dali::Property::Value *arg2 = 0 ;
15352   Dali::Property::Value *result = 0 ;
15353
15354   arg1 = (Dali::Property::Value *)jarg1;
15355   arg2 = (Dali::Property::Value *)jarg2;
15356   if (!arg2) {
15357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15358     return 0;
15359   }
15360   {
15361     try {
15362       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15363     } catch (std::out_of_range& e) {
15364       {
15365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15366       };
15367     } catch (std::exception& e) {
15368       {
15369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15370       };
15371     } catch (...) {
15372       {
15373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15374       };
15375     }
15376   }
15377   jresult = (void *)result;
15378   return jresult;
15379 }
15380
15381
15382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15383   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15384
15385   arg1 = (Dali::Property::Value *)jarg1;
15386   {
15387     try {
15388       delete arg1;
15389     } catch (std::out_of_range& e) {
15390       {
15391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15392       };
15393     } catch (std::exception& e) {
15394       {
15395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15396       };
15397     } catch (...) {
15398       {
15399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15400       };
15401     }
15402   }
15403 }
15404
15405
15406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15407   int jresult ;
15408   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15409   Dali::Property::Type result;
15410
15411   arg1 = (Dali::Property::Value *)jarg1;
15412   {
15413     try {
15414       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15415     } catch (std::out_of_range& e) {
15416       {
15417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15418       };
15419     } catch (std::exception& e) {
15420       {
15421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15422       };
15423     } catch (...) {
15424       {
15425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15426       };
15427     }
15428   }
15429   jresult = (int)result;
15430   return jresult;
15431 }
15432
15433
15434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15435   unsigned int jresult ;
15436   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15437   bool *arg2 = 0 ;
15438   bool result;
15439
15440   arg1 = (Dali::Property::Value *)jarg1;
15441   arg2 = (bool *)jarg2;
15442   {
15443     try {
15444       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15445     } catch (std::out_of_range& e) {
15446       {
15447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15448       };
15449     } catch (std::exception& e) {
15450       {
15451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15452       };
15453     } catch (...) {
15454       {
15455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15456       };
15457     }
15458   }
15459   jresult = result;
15460   return jresult;
15461 }
15462
15463
15464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15465   unsigned int jresult ;
15466   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15467   float *arg2 = 0 ;
15468   bool result;
15469
15470   arg1 = (Dali::Property::Value *)jarg1;
15471   arg2 = (float *)jarg2;
15472   {
15473     try {
15474       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15475     } catch (std::out_of_range& e) {
15476       {
15477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15478       };
15479     } catch (std::exception& e) {
15480       {
15481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15482       };
15483     } catch (...) {
15484       {
15485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15486       };
15487     }
15488   }
15489   jresult = result;
15490   return jresult;
15491 }
15492
15493
15494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15495   unsigned int jresult ;
15496   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15497   int *arg2 = 0 ;
15498   bool result;
15499
15500   arg1 = (Dali::Property::Value *)jarg1;
15501   arg2 = (int *)jarg2;
15502   {
15503     try {
15504       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15505     } catch (std::out_of_range& e) {
15506       {
15507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15508       };
15509     } catch (std::exception& e) {
15510       {
15511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15512       };
15513     } catch (...) {
15514       {
15515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15516       };
15517     }
15518   }
15519   jresult = result;
15520   return jresult;
15521 }
15522
15523
15524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15525   unsigned int jresult ;
15526   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15527   Dali::Rect< int > *arg2 = 0 ;
15528   bool result;
15529
15530   arg1 = (Dali::Property::Value *)jarg1;
15531   arg2 = (Dali::Rect< int > *)jarg2;
15532   if (!arg2) {
15533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15534     return 0;
15535   }
15536   {
15537     try {
15538       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15539     } catch (std::out_of_range& e) {
15540       {
15541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15542       };
15543     } catch (std::exception& e) {
15544       {
15545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15546       };
15547     } catch (...) {
15548       {
15549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15550       };
15551     }
15552   }
15553   jresult = result;
15554   return jresult;
15555 }
15556
15557
15558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15559   unsigned int jresult ;
15560   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15561   Dali::Vector2 *arg2 = 0 ;
15562   bool result;
15563
15564   arg1 = (Dali::Property::Value *)jarg1;
15565   arg2 = (Dali::Vector2 *)jarg2;
15566   if (!arg2) {
15567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15568     return 0;
15569   }
15570   {
15571     try {
15572       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15573     } catch (std::out_of_range& e) {
15574       {
15575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15576       };
15577     } catch (std::exception& e) {
15578       {
15579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15580       };
15581     } catch (...) {
15582       {
15583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15584       };
15585     }
15586   }
15587   jresult = result;
15588   return jresult;
15589 }
15590
15591
15592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15593   unsigned int jresult ;
15594   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15595   Dali::Vector3 *arg2 = 0 ;
15596   bool result;
15597
15598   arg1 = (Dali::Property::Value *)jarg1;
15599   arg2 = (Dali::Vector3 *)jarg2;
15600   if (!arg2) {
15601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15602     return 0;
15603   }
15604   {
15605     try {
15606       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15607     } catch (std::out_of_range& e) {
15608       {
15609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15610       };
15611     } catch (std::exception& e) {
15612       {
15613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15614       };
15615     } catch (...) {
15616       {
15617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15618       };
15619     }
15620   }
15621   jresult = result;
15622   return jresult;
15623 }
15624
15625
15626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15627   unsigned int jresult ;
15628   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15629   Dali::Vector4 *arg2 = 0 ;
15630   bool result;
15631
15632   arg1 = (Dali::Property::Value *)jarg1;
15633   arg2 = (Dali::Vector4 *)jarg2;
15634   if (!arg2) {
15635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15636     return 0;
15637   }
15638   {
15639     try {
15640       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15641     } catch (std::out_of_range& e) {
15642       {
15643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15644       };
15645     } catch (std::exception& e) {
15646       {
15647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15648       };
15649     } catch (...) {
15650       {
15651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15652       };
15653     }
15654   }
15655   jresult = result;
15656   return jresult;
15657 }
15658
15659
15660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15661   unsigned int jresult ;
15662   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15663   Dali::Matrix3 *arg2 = 0 ;
15664   bool result;
15665
15666   arg1 = (Dali::Property::Value *)jarg1;
15667   arg2 = (Dali::Matrix3 *)jarg2;
15668   if (!arg2) {
15669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15670     return 0;
15671   }
15672   {
15673     try {
15674       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15675     } catch (std::out_of_range& e) {
15676       {
15677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15678       };
15679     } catch (std::exception& e) {
15680       {
15681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15682       };
15683     } catch (...) {
15684       {
15685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15686       };
15687     }
15688   }
15689   jresult = result;
15690   return jresult;
15691 }
15692
15693
15694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15695   unsigned int jresult ;
15696   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15697   Dali::Matrix *arg2 = 0 ;
15698   bool result;
15699
15700   arg1 = (Dali::Property::Value *)jarg1;
15701   arg2 = (Dali::Matrix *)jarg2;
15702   if (!arg2) {
15703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15704     return 0;
15705   }
15706   {
15707     try {
15708       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15709     } catch (std::out_of_range& e) {
15710       {
15711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15712       };
15713     } catch (std::exception& e) {
15714       {
15715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15716       };
15717     } catch (...) {
15718       {
15719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15720       };
15721     }
15722   }
15723   jresult = result;
15724   return jresult;
15725 }
15726
15727
15728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15729   unsigned int jresult ;
15730   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15731   Dali::AngleAxis *arg2 = 0 ;
15732   bool result;
15733
15734   arg1 = (Dali::Property::Value *)jarg1;
15735   arg2 = (Dali::AngleAxis *)jarg2;
15736   if (!arg2) {
15737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15738     return 0;
15739   }
15740   {
15741     try {
15742       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15743     } catch (std::out_of_range& e) {
15744       {
15745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15746       };
15747     } catch (std::exception& e) {
15748       {
15749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15750       };
15751     } catch (...) {
15752       {
15753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15754       };
15755     }
15756   }
15757   jresult = result;
15758   return jresult;
15759 }
15760
15761
15762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15763   unsigned int jresult ;
15764   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15765   Dali::Quaternion *arg2 = 0 ;
15766   bool result;
15767
15768   arg1 = (Dali::Property::Value *)jarg1;
15769   arg2 = (Dali::Quaternion *)jarg2;
15770   if (!arg2) {
15771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15772     return 0;
15773   }
15774   {
15775     try {
15776       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15777     } catch (std::out_of_range& e) {
15778       {
15779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15780       };
15781     } catch (std::exception& e) {
15782       {
15783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15784       };
15785     } catch (...) {
15786       {
15787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15788       };
15789     }
15790   }
15791   jresult = result;
15792   return jresult;
15793 }
15794
15795
15796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15797   unsigned int jresult ;
15798   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15799   std::string *arg2 = 0 ;
15800   bool result;
15801
15802   arg1 = (Dali::Property::Value *)jarg1;
15803
15804   //typemap in
15805   std::string temp;
15806   arg2 = &temp;
15807
15808   {
15809     try {
15810       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15811     } catch (std::out_of_range& e) {
15812       {
15813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15814       };
15815     } catch (std::exception& e) {
15816       {
15817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15818       };
15819     } catch (...) {
15820       {
15821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15822       };
15823     }
15824   }
15825   jresult = result;
15826
15827   //Typemap argout in c++ file.
15828   //This will convert c++ string to c# string
15829   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15830
15831   return jresult;
15832 }
15833
15834
15835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15836   unsigned int jresult ;
15837   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15838   Dali::Property::Array *arg2 = 0 ;
15839   bool result;
15840
15841   arg1 = (Dali::Property::Value *)jarg1;
15842   arg2 = (Dali::Property::Array *)jarg2;
15843   if (!arg2) {
15844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15845     return 0;
15846   }
15847   {
15848     try {
15849       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15850     } catch (std::out_of_range& e) {
15851       {
15852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15853       };
15854     } catch (std::exception& e) {
15855       {
15856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15857       };
15858     } catch (...) {
15859       {
15860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15861       };
15862     }
15863   }
15864   jresult = result;
15865   return jresult;
15866 }
15867
15868
15869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15870   unsigned int jresult ;
15871   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15872   Dali::Property::Map *arg2 = 0 ;
15873   bool result;
15874
15875   arg1 = (Dali::Property::Value *)jarg1;
15876   arg2 = (Dali::Property::Map *)jarg2;
15877   if (!arg2) {
15878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15879     return 0;
15880   }
15881   {
15882     try {
15883       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15884     } catch (std::out_of_range& e) {
15885       {
15886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15887       };
15888     } catch (std::exception& e) {
15889       {
15890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15891       };
15892     } catch (...) {
15893       {
15894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15895       };
15896     }
15897   }
15898   jresult = result;
15899   return jresult;
15900 }
15901
15902
15903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15904   void * jresult ;
15905   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15906   Dali::Property::Array *result = 0 ;
15907
15908   arg1 = (Dali::Property::Value *)jarg1;
15909   {
15910     try {
15911       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15912     } catch (std::out_of_range& e) {
15913       {
15914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15915       };
15916     } catch (std::exception& e) {
15917       {
15918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15919       };
15920     } catch (...) {
15921       {
15922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15923       };
15924     }
15925   }
15926   jresult = (void *)result;
15927   return jresult;
15928 }
15929
15930
15931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15932   void * jresult ;
15933   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15934   Dali::Property::Map *result = 0 ;
15935
15936   arg1 = (Dali::Property::Value *)jarg1;
15937   {
15938     try {
15939       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15940     } catch (std::out_of_range& e) {
15941       {
15942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15943       };
15944     } catch (std::exception& e) {
15945       {
15946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15947       };
15948     } catch (...) {
15949       {
15950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15951       };
15952     }
15953   }
15954   jresult = (void *)result;
15955   return jresult;
15956 }
15957
15958
15959 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15960   char * jresult ;
15961   Dali::Property::Type arg1 ;
15962   char *result = 0 ;
15963
15964   arg1 = (Dali::Property::Type)jarg1;
15965   {
15966     try {
15967       result = (char *)Dali::PropertyTypes::GetName(arg1);
15968     } catch (std::out_of_range& e) {
15969       {
15970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15971       };
15972     } catch (std::exception& e) {
15973       {
15974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15975       };
15976     } catch (...) {
15977       {
15978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15979       };
15980     }
15981   }
15982   jresult = SWIG_csharp_string_callback((const char *)result);
15983   return jresult;
15984 }
15985
15986
15987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15988   unsigned int jresult ;
15989   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15990   std::string *arg2 = 0 ;
15991   Dali::Property::Map *arg3 = 0 ;
15992   bool result;
15993
15994   arg1 = (Dali::BaseObject *)jarg1;
15995   if (!jarg2) {
15996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15997     return 0;
15998   }
15999   std::string arg2_str(jarg2);
16000   arg2 = &arg2_str;
16001   arg3 = (Dali::Property::Map *)jarg3;
16002   if (!arg3) {
16003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16004     return 0;
16005   }
16006   {
16007     try {
16008       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16009     } catch (std::out_of_range& e) {
16010       {
16011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16012       };
16013     } catch (std::exception& e) {
16014       {
16015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16016       };
16017     } catch (...) {
16018       {
16019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16020       };
16021     }
16022   }
16023   jresult = result;
16024
16025   //argout typemap for const std::string&
16026
16027   return jresult;
16028 }
16029
16030
16031 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
16032   char * jresult ;
16033   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16034   std::string *result = 0 ;
16035
16036   arg1 = (Dali::BaseObject *)jarg1;
16037   {
16038     try {
16039       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
16040     } catch (std::out_of_range& e) {
16041       {
16042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16043       };
16044     } catch (std::exception& e) {
16045       {
16046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16047       };
16048     } catch (...) {
16049       {
16050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16051       };
16052     }
16053   }
16054   jresult = SWIG_csharp_string_callback(result->c_str());
16055   return jresult;
16056 }
16057
16058
16059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
16060   unsigned int jresult ;
16061   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16062   Dali::TypeInfo *arg2 = 0 ;
16063   bool result;
16064
16065   arg1 = (Dali::BaseObject *)jarg1;
16066   arg2 = (Dali::TypeInfo *)jarg2;
16067   if (!arg2) {
16068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16069     return 0;
16070   }
16071   {
16072     try {
16073       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
16074     } catch (std::out_of_range& e) {
16075       {
16076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16077       };
16078     } catch (std::exception& e) {
16079       {
16080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16081       };
16082     } catch (...) {
16083       {
16084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16085       };
16086     }
16087   }
16088   jresult = result;
16089   return jresult;
16090 }
16091
16092
16093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16094   unsigned int jresult ;
16095   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16096   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16097   std::string *arg3 = 0 ;
16098   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16099   bool result;
16100
16101   arg1 = (Dali::BaseObject *)jarg1;
16102   arg2 = (ConnectionTrackerInterface *)jarg2;
16103   if (!jarg3) {
16104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16105     return 0;
16106   }
16107   std::string arg3_str(jarg3);
16108   arg3 = &arg3_str;
16109   arg4 = (FunctorDelegate *)jarg4;
16110   {
16111     try {
16112       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16113     } catch (std::out_of_range& e) {
16114       {
16115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16116       };
16117     } catch (std::exception& e) {
16118       {
16119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16120       };
16121     } catch (...) {
16122       {
16123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16124       };
16125     }
16126   }
16127   jresult = result;
16128
16129   //argout typemap for const std::string&
16130
16131   return jresult;
16132 }
16133
16134
16135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16136   void * jresult ;
16137   Dali::BaseHandle *arg1 = 0 ;
16138   Dali::BaseObject *result = 0 ;
16139
16140   arg1 = (Dali::BaseHandle *)jarg1;
16141   if (!arg1) {
16142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16143     return 0;
16144   }
16145   {
16146     try {
16147       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16148     } catch (std::out_of_range& e) {
16149       {
16150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16151       };
16152     } catch (std::exception& e) {
16153       {
16154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16155       };
16156     } catch (...) {
16157       {
16158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16159       };
16160     }
16161   }
16162   jresult = (void *)result;
16163   return jresult;
16164 }
16165
16166
16167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16168   void * jresult ;
16169   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16170   Dali::BaseHandle *result = 0 ;
16171
16172   arg1 = (Dali::BaseObject *)jarg1;
16173   {
16174     try {
16175       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16176     } catch (std::out_of_range& e) {
16177       {
16178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16179       };
16180     } catch (std::exception& e) {
16181       {
16182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16183       };
16184     } catch (...) {
16185       {
16186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16187       };
16188     }
16189   }
16190   jresult = (void *)result;
16191   return jresult;
16192 }
16193
16194
16195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16196   void * jresult ;
16197   Dali::BaseHandle *result = 0 ;
16198
16199   {
16200     try {
16201       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16202     } catch (std::out_of_range& e) {
16203       {
16204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16205       };
16206     } catch (std::exception& e) {
16207       {
16208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16209       };
16210     } catch (...) {
16211       {
16212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16213       };
16214     }
16215   }
16216   jresult = (void *)result;
16217   return jresult;
16218 }
16219
16220
16221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16222   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16223
16224   arg1 = (Dali::BaseHandle *)jarg1;
16225   {
16226     try {
16227       delete arg1;
16228     } catch (std::out_of_range& e) {
16229       {
16230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16231       };
16232     } catch (std::exception& e) {
16233       {
16234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16235       };
16236     } catch (...) {
16237       {
16238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16239       };
16240     }
16241   }
16242 }
16243
16244
16245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16246   void * jresult ;
16247   Dali::BaseHandle *arg1 = 0 ;
16248   Dali::BaseHandle *result = 0 ;
16249
16250   arg1 = (Dali::BaseHandle *)jarg1;
16251   if (!arg1) {
16252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16253     return 0;
16254   }
16255   {
16256     try {
16257       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16258     } catch (std::out_of_range& e) {
16259       {
16260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16261       };
16262     } catch (std::exception& e) {
16263       {
16264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16265       };
16266     } catch (...) {
16267       {
16268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16269       };
16270     }
16271   }
16272   jresult = (void *)result;
16273   return jresult;
16274 }
16275
16276
16277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16278   void * jresult ;
16279   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16280   Dali::BaseHandle *arg2 = 0 ;
16281   Dali::BaseHandle *result = 0 ;
16282
16283   arg1 = (Dali::BaseHandle *)jarg1;
16284   arg2 = (Dali::BaseHandle *)jarg2;
16285   if (!arg2) {
16286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16287     return 0;
16288   }
16289   {
16290     try {
16291       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16292     } catch (std::out_of_range& e) {
16293       {
16294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16295       };
16296     } catch (std::exception& e) {
16297       {
16298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16299       };
16300     } catch (...) {
16301       {
16302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16303       };
16304     }
16305   }
16306   jresult = (void *)result;
16307   return jresult;
16308 }
16309
16310
16311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16312   unsigned int jresult ;
16313   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16314   std::string *arg2 = 0 ;
16315   Dali::Property::Map *arg3 = 0 ;
16316   bool result;
16317
16318   arg1 = (Dali::BaseHandle *)jarg1;
16319   if (!jarg2) {
16320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16321     return 0;
16322   }
16323   std::string arg2_str(jarg2);
16324   arg2 = &arg2_str;
16325   arg3 = (Dali::Property::Map *)jarg3;
16326   if (!arg3) {
16327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16328     return 0;
16329   }
16330   {
16331     try {
16332       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16333     } catch (std::out_of_range& e) {
16334       {
16335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16336       };
16337     } catch (std::exception& e) {
16338       {
16339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16340       };
16341     } catch (...) {
16342       {
16343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16344       };
16345     }
16346   }
16347   jresult = result;
16348
16349   //argout typemap for const std::string&
16350
16351   return jresult;
16352 }
16353
16354
16355 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16356   char * jresult ;
16357   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16358   std::string *result = 0 ;
16359
16360   arg1 = (Dali::BaseHandle *)jarg1;
16361   {
16362     try {
16363       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16364     } catch (std::out_of_range& e) {
16365       {
16366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16367       };
16368     } catch (std::exception& e) {
16369       {
16370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16371       };
16372     } catch (...) {
16373       {
16374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16375       };
16376     }
16377   }
16378   jresult = SWIG_csharp_string_callback(result->c_str());
16379   return jresult;
16380 }
16381
16382
16383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16384   unsigned int jresult ;
16385   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16386   Dali::TypeInfo *arg2 = 0 ;
16387   bool result;
16388
16389   arg1 = (Dali::BaseHandle *)jarg1;
16390   arg2 = (Dali::TypeInfo *)jarg2;
16391   if (!arg2) {
16392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16393     return 0;
16394   }
16395   {
16396     try {
16397       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16398     } catch (std::out_of_range& e) {
16399       {
16400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16401       };
16402     } catch (std::exception& e) {
16403       {
16404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16405       };
16406     } catch (...) {
16407       {
16408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16409       };
16410     }
16411   }
16412   jresult = result;
16413   return jresult;
16414 }
16415
16416
16417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16418   void * jresult ;
16419   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16420   Dali::BaseObject *result = 0 ;
16421
16422   arg1 = (Dali::BaseHandle *)jarg1;
16423   {
16424     try {
16425       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16426     } catch (std::out_of_range& e) {
16427       {
16428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16429       };
16430     } catch (std::exception& e) {
16431       {
16432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16433       };
16434     } catch (...) {
16435       {
16436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16437       };
16438     }
16439   }
16440   jresult = (void *)result;
16441   return jresult;
16442 }
16443
16444
16445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16446   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16447
16448   arg1 = (Dali::BaseHandle *)jarg1;
16449   {
16450     try {
16451       (arg1)->Reset();
16452     } catch (std::out_of_range& e) {
16453       {
16454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16455       };
16456     } catch (std::exception& e) {
16457       {
16458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16459       };
16460     } catch (...) {
16461       {
16462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16463       };
16464     }
16465   }
16466 }
16467
16468
16469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16470   unsigned int jresult ;
16471   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16472   Dali::BaseHandle *arg2 = 0 ;
16473   bool result;
16474
16475   arg1 = (Dali::BaseHandle *)jarg1;
16476   arg2 = (Dali::BaseHandle *)jarg2;
16477   if (!arg2) {
16478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16479     return 0;
16480   }
16481   {
16482     try {
16483       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16484     } catch (std::out_of_range& e) {
16485       {
16486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16487       };
16488     } catch (std::exception& e) {
16489       {
16490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16491       };
16492     } catch (...) {
16493       {
16494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16495       };
16496     }
16497   }
16498   jresult = result;
16499   return jresult;
16500 }
16501
16502
16503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16504   unsigned int jresult ;
16505   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16506   Dali::BaseHandle *arg2 = 0 ;
16507   bool result;
16508
16509   arg1 = (Dali::BaseHandle *)jarg1;
16510   arg2 = (Dali::BaseHandle *)jarg2;
16511   if (!arg2) {
16512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16513     return 0;
16514   }
16515   {
16516     try {
16517       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16518     } catch (std::out_of_range& e) {
16519       {
16520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16521       };
16522     } catch (std::exception& e) {
16523       {
16524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16525       };
16526     } catch (...) {
16527       {
16528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16529       };
16530     }
16531   }
16532   jresult = result;
16533   return jresult;
16534 }
16535
16536
16537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16538   void * jresult ;
16539   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16540   Dali::RefObject *result = 0 ;
16541
16542   arg1 = (Dali::BaseHandle *)jarg1;
16543   {
16544     try {
16545       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16546     } catch (std::out_of_range& e) {
16547       {
16548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16549       };
16550     } catch (std::exception& e) {
16551       {
16552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16553       };
16554     } catch (...) {
16555       {
16556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16557       };
16558     }
16559   }
16560   jresult = (void *)result;
16561   return jresult;
16562 }
16563
16564
16565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16566   unsigned int jresult ;
16567   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16568   bool result;
16569
16570   arg1 = (Dali::BaseHandle *)jarg1;
16571   {
16572     try {
16573       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16574     } catch (std::out_of_range& e) {
16575       {
16576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16577       };
16578     } catch (std::exception& e) {
16579       {
16580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16581       };
16582     } catch (...) {
16583       {
16584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16585       };
16586     }
16587   }
16588   jresult = result;
16589   return jresult;
16590 }
16591
16592
16593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16594   unsigned int jresult ;
16595   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16596   Dali::BaseHandle *arg2 = 0 ;
16597   bool result;
16598
16599   arg1 = (Dali::BaseHandle *)jarg1;
16600   arg2 = (Dali::BaseHandle *)jarg2;
16601   if (!arg2) {
16602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16603     return 0;
16604   }
16605   {
16606     try {
16607       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16608     } catch (std::out_of_range& e) {
16609       {
16610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16611       };
16612     } catch (std::exception& e) {
16613       {
16614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16615       };
16616     } catch (...) {
16617       {
16618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16619       };
16620     }
16621   }
16622   jresult = result;
16623   return jresult;
16624 }
16625
16626
16627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16628   unsigned int jresult ;
16629   Dali::BaseHandle *arg1 = 0 ;
16630   Dali::BaseHandle *arg2 = 0 ;
16631   bool result;
16632
16633   arg1 = (Dali::BaseHandle *)jarg1;
16634   if (!arg1) {
16635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16636     return 0;
16637   }
16638   arg2 = (Dali::BaseHandle *)jarg2;
16639   if (!arg2) {
16640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16641     return 0;
16642   }
16643   {
16644     try {
16645       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16646     } catch (std::out_of_range& e) {
16647       {
16648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16649       };
16650     } catch (std::exception& e) {
16651       {
16652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16653       };
16654     } catch (...) {
16655       {
16656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16657       };
16658     }
16659   }
16660   jresult = result;
16661   return jresult;
16662 }
16663
16664
16665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16666   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16667
16668   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16669   {
16670     try {
16671       delete arg1;
16672     } catch (std::out_of_range& e) {
16673       {
16674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16675       };
16676     } catch (std::exception& e) {
16677       {
16678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16679       };
16680     } catch (...) {
16681       {
16682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16683       };
16684     }
16685   }
16686 }
16687
16688
16689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16690   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16691   SlotObserver *arg2 = (SlotObserver *) 0 ;
16692   CallbackBase *arg3 = (CallbackBase *) 0 ;
16693
16694   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16695   arg2 = (SlotObserver *)jarg2;
16696   arg3 = (CallbackBase *)jarg3;
16697   {
16698     try {
16699       (arg1)->SignalConnected(arg2,arg3);
16700     } catch (std::out_of_range& e) {
16701       {
16702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16703       };
16704     } catch (std::exception& e) {
16705       {
16706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16707       };
16708     } catch (...) {
16709       {
16710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16711       };
16712     }
16713   }
16714 }
16715
16716
16717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16718   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16719
16720   arg1 = (Dali::SignalObserver *)jarg1;
16721   {
16722     try {
16723       delete arg1;
16724     } catch (std::out_of_range& e) {
16725       {
16726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16727       };
16728     } catch (std::exception& e) {
16729       {
16730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16731       };
16732     } catch (...) {
16733       {
16734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16735       };
16736     }
16737   }
16738 }
16739
16740
16741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16742   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16743   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16744   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16745
16746   arg1 = (Dali::SignalObserver *)jarg1;
16747   arg2 = (Dali::SlotObserver *)jarg2;
16748   arg3 = (Dali::CallbackBase *)jarg3;
16749   {
16750     try {
16751       (arg1)->SignalDisconnected(arg2,arg3);
16752     } catch (std::out_of_range& e) {
16753       {
16754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16755       };
16756     } catch (std::exception& e) {
16757       {
16758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16759       };
16760     } catch (...) {
16761       {
16762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16763       };
16764     }
16765   }
16766 }
16767
16768
16769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16770   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16771
16772   arg1 = (Dali::SlotObserver *)jarg1;
16773   {
16774     try {
16775       delete arg1;
16776     } catch (std::out_of_range& e) {
16777       {
16778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16779       };
16780     } catch (std::exception& e) {
16781       {
16782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16783       };
16784     } catch (...) {
16785       {
16786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16787       };
16788     }
16789   }
16790 }
16791
16792
16793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16794   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16795   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16796
16797   arg1 = (Dali::SlotObserver *)jarg1;
16798   arg2 = (Dali::CallbackBase *)jarg2;
16799   {
16800     try {
16801       (arg1)->SlotDisconnected(arg2);
16802     } catch (std::out_of_range& e) {
16803       {
16804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16805       };
16806     } catch (std::exception& e) {
16807       {
16808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16809       };
16810     } catch (...) {
16811       {
16812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16813       };
16814     }
16815   }
16816 }
16817
16818
16819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16820   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16821
16822   arg1 = (Dali::ConnectionTracker *)jarg1;
16823   {
16824     try {
16825       delete arg1;
16826     } catch (std::out_of_range& e) {
16827       {
16828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16829       };
16830     } catch (std::exception& e) {
16831       {
16832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16833       };
16834     } catch (...) {
16835       {
16836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16837       };
16838     }
16839   }
16840 }
16841
16842
16843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16844   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16845
16846   arg1 = (Dali::ConnectionTracker *)jarg1;
16847   {
16848     try {
16849       (arg1)->DisconnectAll();
16850     } catch (std::out_of_range& e) {
16851       {
16852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16853       };
16854     } catch (std::exception& e) {
16855       {
16856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16857       };
16858     } catch (...) {
16859       {
16860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16861       };
16862     }
16863   }
16864 }
16865
16866
16867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16868   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16869   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16870   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16871
16872   arg1 = (Dali::ConnectionTracker *)jarg1;
16873   arg2 = (Dali::SlotObserver *)jarg2;
16874   arg3 = (Dali::CallbackBase *)jarg3;
16875   {
16876     try {
16877       (arg1)->SignalConnected(arg2,arg3);
16878     } catch (std::out_of_range& e) {
16879       {
16880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16881       };
16882     } catch (std::exception& e) {
16883       {
16884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16885       };
16886     } catch (...) {
16887       {
16888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16889       };
16890     }
16891   }
16892 }
16893
16894
16895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16896   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16897   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16898   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16899
16900   arg1 = (Dali::ConnectionTracker *)jarg1;
16901   arg2 = (Dali::SlotObserver *)jarg2;
16902   arg3 = (Dali::CallbackBase *)jarg3;
16903   {
16904     try {
16905       (arg1)->SignalDisconnected(arg2,arg3);
16906     } catch (std::out_of_range& e) {
16907       {
16908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16909       };
16910     } catch (std::exception& e) {
16911       {
16912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16913       };
16914     } catch (...) {
16915       {
16916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16917       };
16918     }
16919   }
16920 }
16921
16922
16923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16924   unsigned long jresult ;
16925   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16926   std::size_t result;
16927
16928   arg1 = (Dali::ConnectionTracker *)jarg1;
16929   {
16930     try {
16931       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16932     } catch (std::out_of_range& e) {
16933       {
16934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16935       };
16936     } catch (std::exception& e) {
16937       {
16938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16939       };
16940     } catch (...) {
16941       {
16942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16943       };
16944     }
16945   }
16946   jresult = (unsigned long)result;
16947   return jresult;
16948 }
16949
16950
16951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16952   void * jresult ;
16953   Dali::ObjectRegistry *result = 0 ;
16954
16955   {
16956     try {
16957       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16958     } catch (std::out_of_range& e) {
16959       {
16960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16961       };
16962     } catch (std::exception& e) {
16963       {
16964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16965       };
16966     } catch (...) {
16967       {
16968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16969       };
16970     }
16971   }
16972   jresult = (void *)result;
16973   return jresult;
16974 }
16975
16976
16977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16978   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16979
16980   arg1 = (Dali::ObjectRegistry *)jarg1;
16981   {
16982     try {
16983       delete arg1;
16984     } catch (std::out_of_range& e) {
16985       {
16986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16987       };
16988     } catch (std::exception& e) {
16989       {
16990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16991       };
16992     } catch (...) {
16993       {
16994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16995       };
16996     }
16997   }
16998 }
16999
17000
17001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
17002   void * jresult ;
17003   Dali::ObjectRegistry *arg1 = 0 ;
17004   Dali::ObjectRegistry *result = 0 ;
17005
17006   arg1 = (Dali::ObjectRegistry *)jarg1;
17007   if (!arg1) {
17008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
17009     return 0;
17010   }
17011   {
17012     try {
17013       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
17014     } catch (std::out_of_range& e) {
17015       {
17016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17017       };
17018     } catch (std::exception& e) {
17019       {
17020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17021       };
17022     } catch (...) {
17023       {
17024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17025       };
17026     }
17027   }
17028   jresult = (void *)result;
17029   return jresult;
17030 }
17031
17032
17033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
17034   void * jresult ;
17035   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17036   Dali::ObjectRegistry *arg2 = 0 ;
17037   Dali::ObjectRegistry *result = 0 ;
17038
17039   arg1 = (Dali::ObjectRegistry *)jarg1;
17040   arg2 = (Dali::ObjectRegistry *)jarg2;
17041   if (!arg2) {
17042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
17043     return 0;
17044   }
17045   {
17046     try {
17047       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
17048     } catch (std::out_of_range& e) {
17049       {
17050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17051       };
17052     } catch (std::exception& e) {
17053       {
17054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17055       };
17056     } catch (...) {
17057       {
17058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17059       };
17060     }
17061   }
17062   jresult = (void *)result;
17063   return jresult;
17064 }
17065
17066
17067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17068   void * jresult ;
17069   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17070   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17071
17072   arg1 = (Dali::ObjectRegistry *)jarg1;
17073   {
17074     try {
17075       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17076     } catch (std::out_of_range& e) {
17077       {
17078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17079       };
17080     } catch (std::exception& e) {
17081       {
17082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17083       };
17084     } catch (...) {
17085       {
17086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17087       };
17088     }
17089   }
17090   jresult = (void *)result;
17091   return jresult;
17092 }
17093
17094
17095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17096   void * jresult ;
17097   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17098   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17099
17100   arg1 = (Dali::ObjectRegistry *)jarg1;
17101   {
17102     try {
17103       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17104     } catch (std::out_of_range& e) {
17105       {
17106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17107       };
17108     } catch (std::exception& e) {
17109       {
17110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17111       };
17112     } catch (...) {
17113       {
17114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17115       };
17116     }
17117   }
17118   jresult = (void *)result;
17119   return jresult;
17120 }
17121
17122
17123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17124   void * jresult ;
17125   Dali::PropertyCondition *result = 0 ;
17126
17127   {
17128     try {
17129       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17130     } catch (std::out_of_range& e) {
17131       {
17132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17133       };
17134     } catch (std::exception& e) {
17135       {
17136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17137       };
17138     } catch (...) {
17139       {
17140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17141       };
17142     }
17143   }
17144   jresult = (void *)result;
17145   return jresult;
17146 }
17147
17148
17149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17150   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17151
17152   arg1 = (Dali::PropertyCondition *)jarg1;
17153   {
17154     try {
17155       delete arg1;
17156     } catch (std::out_of_range& e) {
17157       {
17158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17159       };
17160     } catch (std::exception& e) {
17161       {
17162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17163       };
17164     } catch (...) {
17165       {
17166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17167       };
17168     }
17169   }
17170 }
17171
17172
17173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17174   void * jresult ;
17175   Dali::PropertyCondition *arg1 = 0 ;
17176   Dali::PropertyCondition *result = 0 ;
17177
17178   arg1 = (Dali::PropertyCondition *)jarg1;
17179   if (!arg1) {
17180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17181     return 0;
17182   }
17183   {
17184     try {
17185       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17186     } catch (std::out_of_range& e) {
17187       {
17188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17189       };
17190     } catch (std::exception& e) {
17191       {
17192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17193       };
17194     } catch (...) {
17195       {
17196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17197       };
17198     }
17199   }
17200   jresult = (void *)result;
17201   return jresult;
17202 }
17203
17204
17205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17206   void * jresult ;
17207   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17208   Dali::PropertyCondition *arg2 = 0 ;
17209   Dali::PropertyCondition *result = 0 ;
17210
17211   arg1 = (Dali::PropertyCondition *)jarg1;
17212   arg2 = (Dali::PropertyCondition *)jarg2;
17213   if (!arg2) {
17214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17215     return 0;
17216   }
17217   {
17218     try {
17219       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17220     } catch (std::out_of_range& e) {
17221       {
17222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17223       };
17224     } catch (std::exception& e) {
17225       {
17226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17227       };
17228     } catch (...) {
17229       {
17230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17231       };
17232     }
17233   }
17234   jresult = (void *)result;
17235   return jresult;
17236 }
17237
17238
17239 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17240   unsigned long jresult ;
17241   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17242   std::size_t result;
17243
17244   arg1 = (Dali::PropertyCondition *)jarg1;
17245   {
17246     try {
17247       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17248     } catch (std::out_of_range& e) {
17249       {
17250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17251       };
17252     } catch (std::exception& e) {
17253       {
17254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17255       };
17256     } catch (...) {
17257       {
17258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17259       };
17260     }
17261   }
17262   jresult = (unsigned long)result;
17263   return jresult;
17264 }
17265
17266
17267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17268   float jresult ;
17269   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17270   std::size_t arg2 ;
17271   float result;
17272
17273   arg1 = (Dali::PropertyCondition *)jarg1;
17274   arg2 = (std::size_t)jarg2;
17275   {
17276     try {
17277       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17278     } catch (std::out_of_range& e) {
17279       {
17280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17281       };
17282     } catch (std::exception& e) {
17283       {
17284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17285       };
17286     } catch (...) {
17287       {
17288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17289       };
17290     }
17291   }
17292   jresult = result;
17293   return jresult;
17294 }
17295
17296
17297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17298   void * jresult ;
17299   float arg1 ;
17300   Dali::PropertyCondition result;
17301
17302   arg1 = (float)jarg1;
17303   {
17304     try {
17305       result = Dali::LessThanCondition(arg1);
17306     } catch (std::out_of_range& e) {
17307       {
17308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17309       };
17310     } catch (std::exception& e) {
17311       {
17312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17313       };
17314     } catch (...) {
17315       {
17316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17317       };
17318     }
17319   }
17320   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17321   return jresult;
17322 }
17323
17324
17325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17326   void * jresult ;
17327   float arg1 ;
17328   Dali::PropertyCondition result;
17329
17330   arg1 = (float)jarg1;
17331   {
17332     try {
17333       result = Dali::GreaterThanCondition(arg1);
17334     } catch (std::out_of_range& e) {
17335       {
17336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17337       };
17338     } catch (std::exception& e) {
17339       {
17340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17341       };
17342     } catch (...) {
17343       {
17344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17345       };
17346     }
17347   }
17348   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17349   return jresult;
17350 }
17351
17352
17353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17354   void * jresult ;
17355   float arg1 ;
17356   float arg2 ;
17357   Dali::PropertyCondition result;
17358
17359   arg1 = (float)jarg1;
17360   arg2 = (float)jarg2;
17361   {
17362     try {
17363       result = Dali::InsideCondition(arg1,arg2);
17364     } catch (std::out_of_range& e) {
17365       {
17366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17367       };
17368     } catch (std::exception& e) {
17369       {
17370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17371       };
17372     } catch (...) {
17373       {
17374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17375       };
17376     }
17377   }
17378   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17379   return jresult;
17380 }
17381
17382
17383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17384   void * jresult ;
17385   float arg1 ;
17386   float arg2 ;
17387   Dali::PropertyCondition result;
17388
17389   arg1 = (float)jarg1;
17390   arg2 = (float)jarg2;
17391   {
17392     try {
17393       result = Dali::OutsideCondition(arg1,arg2);
17394     } catch (std::out_of_range& e) {
17395       {
17396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17397       };
17398     } catch (std::exception& e) {
17399       {
17400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17401       };
17402     } catch (...) {
17403       {
17404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17405       };
17406     }
17407   }
17408   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17409   return jresult;
17410 }
17411
17412
17413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17414   void * jresult ;
17415   float arg1 ;
17416   float arg2 ;
17417   Dali::PropertyCondition result;
17418
17419   arg1 = (float)jarg1;
17420   arg2 = (float)jarg2;
17421   {
17422     try {
17423       result = Dali::StepCondition(arg1,arg2);
17424     } catch (std::out_of_range& e) {
17425       {
17426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17427       };
17428     } catch (std::exception& e) {
17429       {
17430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17431       };
17432     } catch (...) {
17433       {
17434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17435       };
17436     }
17437   }
17438   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17439   return jresult;
17440 }
17441
17442
17443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17444   void * jresult ;
17445   float arg1 ;
17446   Dali::PropertyCondition result;
17447
17448   arg1 = (float)jarg1;
17449   {
17450     try {
17451       result = Dali::StepCondition(arg1);
17452     } catch (std::out_of_range& e) {
17453       {
17454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17455       };
17456     } catch (std::exception& e) {
17457       {
17458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17459       };
17460     } catch (...) {
17461       {
17462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17463       };
17464     }
17465   }
17466   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17467   return jresult;
17468 }
17469
17470
17471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17472   void * jresult ;
17473   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17474   Dali::PropertyCondition result;
17475
17476   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17477   if (!arg1) {
17478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17479     return 0;
17480   }
17481   {
17482     try {
17483       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17484     } catch (std::out_of_range& e) {
17485       {
17486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17487       };
17488     } catch (std::exception& e) {
17489       {
17490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17491       };
17492     } catch (...) {
17493       {
17494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17495       };
17496     }
17497   }
17498   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17499   return jresult;
17500 }
17501
17502
17503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17504   void * jresult ;
17505   Dali::PropertyNotification *result = 0 ;
17506
17507   {
17508     try {
17509       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17510     } catch (std::out_of_range& e) {
17511       {
17512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17513       };
17514     } catch (std::exception& e) {
17515       {
17516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17517       };
17518     } catch (...) {
17519       {
17520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17521       };
17522     }
17523   }
17524   jresult = (void *)result;
17525   return jresult;
17526 }
17527
17528
17529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17530   void * jresult ;
17531   Dali::BaseHandle arg1 ;
17532   Dali::BaseHandle *argp1 ;
17533   Dali::PropertyNotification result;
17534
17535   argp1 = (Dali::BaseHandle *)jarg1;
17536   if (!argp1) {
17537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17538     return 0;
17539   }
17540   arg1 = *argp1;
17541   {
17542     try {
17543       result = Dali::PropertyNotification::DownCast(arg1);
17544     } catch (std::out_of_range& e) {
17545       {
17546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17547       };
17548     } catch (std::exception& e) {
17549       {
17550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17551       };
17552     } catch (...) {
17553       {
17554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17555       };
17556     }
17557   }
17558   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17559   return jresult;
17560 }
17561
17562
17563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17564   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17565
17566   arg1 = (Dali::PropertyNotification *)jarg1;
17567   {
17568     try {
17569       delete arg1;
17570     } catch (std::out_of_range& e) {
17571       {
17572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17573       };
17574     } catch (std::exception& e) {
17575       {
17576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17577       };
17578     } catch (...) {
17579       {
17580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17581       };
17582     }
17583   }
17584 }
17585
17586
17587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17588   void * jresult ;
17589   Dali::PropertyNotification *arg1 = 0 ;
17590   Dali::PropertyNotification *result = 0 ;
17591
17592   arg1 = (Dali::PropertyNotification *)jarg1;
17593   if (!arg1) {
17594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17595     return 0;
17596   }
17597   {
17598     try {
17599       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17600     } catch (std::out_of_range& e) {
17601       {
17602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17603       };
17604     } catch (std::exception& e) {
17605       {
17606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17607       };
17608     } catch (...) {
17609       {
17610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17611       };
17612     }
17613   }
17614   jresult = (void *)result;
17615   return jresult;
17616 }
17617
17618
17619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17620   void * jresult ;
17621   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17622   Dali::PropertyNotification *arg2 = 0 ;
17623   Dali::PropertyNotification *result = 0 ;
17624
17625   arg1 = (Dali::PropertyNotification *)jarg1;
17626   arg2 = (Dali::PropertyNotification *)jarg2;
17627   if (!arg2) {
17628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17629     return 0;
17630   }
17631   {
17632     try {
17633       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17634     } catch (std::out_of_range& e) {
17635       {
17636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17637       };
17638     } catch (std::exception& e) {
17639       {
17640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17641       };
17642     } catch (...) {
17643       {
17644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17645       };
17646     }
17647   }
17648   jresult = (void *)result;
17649   return jresult;
17650 }
17651
17652
17653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17654   void * jresult ;
17655   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17656   Dali::PropertyCondition result;
17657
17658   arg1 = (Dali::PropertyNotification *)jarg1;
17659   {
17660     try {
17661       result = (arg1)->GetCondition();
17662     } catch (std::out_of_range& e) {
17663       {
17664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17665       };
17666     } catch (std::exception& e) {
17667       {
17668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17669       };
17670     } catch (...) {
17671       {
17672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17673       };
17674     }
17675   }
17676   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17677   return jresult;
17678 }
17679
17680
17681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17682   void * jresult ;
17683   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17684   Dali::Handle result;
17685
17686   arg1 = (Dali::PropertyNotification *)jarg1;
17687   {
17688     try {
17689       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17690     } catch (std::out_of_range& e) {
17691       {
17692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17693       };
17694     } catch (std::exception& e) {
17695       {
17696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17697       };
17698     } catch (...) {
17699       {
17700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17701       };
17702     }
17703   }
17704   jresult = new Dali::Handle((const Dali::Handle &)result);
17705   return jresult;
17706 }
17707
17708
17709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17710   int jresult ;
17711   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17712   Dali::Property::Index result;
17713
17714   arg1 = (Dali::PropertyNotification *)jarg1;
17715   {
17716     try {
17717       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17718     } catch (std::out_of_range& e) {
17719       {
17720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17721       };
17722     } catch (std::exception& e) {
17723       {
17724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17725       };
17726     } catch (...) {
17727       {
17728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17729       };
17730     }
17731   }
17732   jresult = result;
17733   return jresult;
17734 }
17735
17736
17737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17738   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17739   Dali::PropertyNotification::NotifyMode arg2 ;
17740
17741   arg1 = (Dali::PropertyNotification *)jarg1;
17742   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17743   {
17744     try {
17745       (arg1)->SetNotifyMode(arg2);
17746     } catch (std::out_of_range& e) {
17747       {
17748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17749       };
17750     } catch (std::exception& e) {
17751       {
17752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17753       };
17754     } catch (...) {
17755       {
17756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17757       };
17758     }
17759   }
17760 }
17761
17762
17763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17764   int jresult ;
17765   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17766   Dali::PropertyNotification::NotifyMode result;
17767
17768   arg1 = (Dali::PropertyNotification *)jarg1;
17769   {
17770     try {
17771       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17772     } catch (std::out_of_range& e) {
17773       {
17774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17775       };
17776     } catch (std::exception& e) {
17777       {
17778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17779       };
17780     } catch (...) {
17781       {
17782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17783       };
17784     }
17785   }
17786   jresult = (int)result;
17787   return jresult;
17788 }
17789
17790
17791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17792   unsigned int jresult ;
17793   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17794   bool result;
17795
17796   arg1 = (Dali::PropertyNotification *)jarg1;
17797   {
17798     try {
17799       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17800     } catch (std::out_of_range& e) {
17801       {
17802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17803       };
17804     } catch (std::exception& e) {
17805       {
17806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17807       };
17808     } catch (...) {
17809       {
17810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17811       };
17812     }
17813   }
17814   jresult = result;
17815   return jresult;
17816 }
17817
17818
17819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17820   void * jresult ;
17821   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17822   Dali::PropertyNotifySignalType *result = 0 ;
17823
17824   arg1 = (Dali::PropertyNotification *)jarg1;
17825   {
17826     try {
17827       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17828     } catch (std::out_of_range& e) {
17829       {
17830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17831       };
17832     } catch (std::exception& e) {
17833       {
17834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17835       };
17836     } catch (...) {
17837       {
17838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17839       };
17840     }
17841   }
17842   jresult = (void *)result;
17843   return jresult;
17844 }
17845
17846
17847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17848   void * jresult ;
17849   Dali::Handle *result = 0 ;
17850
17851   {
17852     try {
17853       result = (Dali::Handle *)new Dali::Handle();
17854     } catch (std::out_of_range& e) {
17855       {
17856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17857       };
17858     } catch (std::exception& e) {
17859       {
17860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17861       };
17862     } catch (...) {
17863       {
17864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17865       };
17866     }
17867   }
17868   jresult = (void *)result;
17869   return jresult;
17870 }
17871
17872
17873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17874   void * jresult ;
17875   Dali::Handle result;
17876
17877   {
17878     try {
17879       result = Dali::Handle::New();
17880     } catch (std::out_of_range& e) {
17881       {
17882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17883       };
17884     } catch (std::exception& e) {
17885       {
17886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17887       };
17888     } catch (...) {
17889       {
17890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17891       };
17892     }
17893   }
17894   jresult = new Dali::Handle((const Dali::Handle &)result);
17895   return jresult;
17896 }
17897
17898
17899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17900   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17901
17902   arg1 = (Dali::Handle *)jarg1;
17903   {
17904     try {
17905       delete arg1;
17906     } catch (std::out_of_range& e) {
17907       {
17908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17909       };
17910     } catch (std::exception& e) {
17911       {
17912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17913       };
17914     } catch (...) {
17915       {
17916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17917       };
17918     }
17919   }
17920 }
17921
17922
17923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17924   void * jresult ;
17925   Dali::Handle *arg1 = 0 ;
17926   Dali::Handle *result = 0 ;
17927
17928   arg1 = (Dali::Handle *)jarg1;
17929   if (!arg1) {
17930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17931     return 0;
17932   }
17933   {
17934     try {
17935       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17936     } catch (std::out_of_range& e) {
17937       {
17938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17939       };
17940     } catch (std::exception& e) {
17941       {
17942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17943       };
17944     } catch (...) {
17945       {
17946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17947       };
17948     }
17949   }
17950   jresult = (void *)result;
17951   return jresult;
17952 }
17953
17954
17955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17956   void * jresult ;
17957   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17958   Dali::Handle *arg2 = 0 ;
17959   Dali::Handle *result = 0 ;
17960
17961   arg1 = (Dali::Handle *)jarg1;
17962   arg2 = (Dali::Handle *)jarg2;
17963   if (!arg2) {
17964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17965     return 0;
17966   }
17967   {
17968     try {
17969       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17970     } catch (std::out_of_range& e) {
17971       {
17972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17973       };
17974     } catch (std::exception& e) {
17975       {
17976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17977       };
17978     } catch (...) {
17979       {
17980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17981       };
17982     }
17983   }
17984   jresult = (void *)result;
17985   return jresult;
17986 }
17987
17988
17989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17990   void * jresult ;
17991   Dali::BaseHandle arg1 ;
17992   Dali::BaseHandle *argp1 ;
17993   Dali::Handle result;
17994
17995   argp1 = (Dali::BaseHandle *)jarg1;
17996   if (!argp1) {
17997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17998     return 0;
17999   }
18000   arg1 = *argp1;
18001   {
18002     try {
18003       result = Dali::Handle::DownCast(arg1);
18004     } catch (std::out_of_range& e) {
18005       {
18006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18007       };
18008     } catch (std::exception& e) {
18009       {
18010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18011       };
18012     } catch (...) {
18013       {
18014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18015       };
18016     }
18017   }
18018   jresult = new Dali::Handle((const Dali::Handle &)result);
18019   return jresult;
18020 }
18021
18022
18023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
18024   unsigned int jresult ;
18025   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18026   Dali::Handle::Capability arg2 ;
18027   bool result;
18028
18029   arg1 = (Dali::Handle *)jarg1;
18030   arg2 = (Dali::Handle::Capability)jarg2;
18031   {
18032     try {
18033       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
18034     } catch (std::out_of_range& e) {
18035       {
18036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18037       };
18038     } catch (std::exception& e) {
18039       {
18040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18041       };
18042     } catch (...) {
18043       {
18044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18045       };
18046     }
18047   }
18048   jresult = result;
18049   return jresult;
18050 }
18051
18052
18053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
18054   unsigned int jresult ;
18055   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18056   unsigned int result;
18057
18058   arg1 = (Dali::Handle *)jarg1;
18059   {
18060     try {
18061       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
18062     } catch (std::out_of_range& e) {
18063       {
18064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18065       };
18066     } catch (std::exception& e) {
18067       {
18068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18069       };
18070     } catch (...) {
18071       {
18072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18073       };
18074     }
18075   }
18076   jresult = result;
18077   return jresult;
18078 }
18079
18080
18081 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
18082   char * jresult ;
18083   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18084   Dali::Property::Index arg2 ;
18085   std::string result;
18086
18087   arg1 = (Dali::Handle *)jarg1;
18088   arg2 = (Dali::Property::Index)jarg2;
18089   {
18090     try {
18091       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18092     } catch (std::out_of_range& e) {
18093       {
18094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18095       };
18096     } catch (std::exception& e) {
18097       {
18098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18099       };
18100     } catch (...) {
18101       {
18102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18103       };
18104     }
18105   }
18106   jresult = SWIG_csharp_string_callback((&result)->c_str());
18107   return jresult;
18108 }
18109
18110
18111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18112   int jresult ;
18113   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18114   std::string *arg2 = 0 ;
18115   Dali::Property::Index result;
18116
18117   arg1 = (Dali::Handle *)jarg1;
18118   if (!jarg2) {
18119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18120     return 0;
18121   }
18122   std::string arg2_str(jarg2);
18123   arg2 = &arg2_str;
18124   {
18125     try {
18126       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18127     } catch (std::out_of_range& e) {
18128       {
18129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18130       };
18131     } catch (std::exception& e) {
18132       {
18133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18134       };
18135     } catch (...) {
18136       {
18137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18138       };
18139     }
18140   }
18141   jresult = result;
18142
18143   //argout typemap for const std::string&
18144
18145   return jresult;
18146 }
18147
18148
18149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18150   unsigned int jresult ;
18151   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18152   Dali::Property::Index arg2 ;
18153   bool result;
18154
18155   arg1 = (Dali::Handle *)jarg1;
18156   arg2 = (Dali::Property::Index)jarg2;
18157   {
18158     try {
18159       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18160     } catch (std::out_of_range& e) {
18161       {
18162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18163       };
18164     } catch (std::exception& e) {
18165       {
18166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18167       };
18168     } catch (...) {
18169       {
18170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18171       };
18172     }
18173   }
18174   jresult = result;
18175   return jresult;
18176 }
18177
18178
18179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18180   unsigned int jresult ;
18181   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18182   Dali::Property::Index arg2 ;
18183   bool result;
18184
18185   arg1 = (Dali::Handle *)jarg1;
18186   arg2 = (Dali::Property::Index)jarg2;
18187   {
18188     try {
18189       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18190     } catch (std::out_of_range& e) {
18191       {
18192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18193       };
18194     } catch (std::exception& e) {
18195       {
18196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18197       };
18198     } catch (...) {
18199       {
18200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18201       };
18202     }
18203   }
18204   jresult = result;
18205   return jresult;
18206 }
18207
18208
18209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18210   unsigned int jresult ;
18211   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18212   Dali::Property::Index arg2 ;
18213   bool result;
18214
18215   arg1 = (Dali::Handle *)jarg1;
18216   arg2 = (Dali::Property::Index)jarg2;
18217   {
18218     try {
18219       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18220     } catch (std::out_of_range& e) {
18221       {
18222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18223       };
18224     } catch (std::exception& e) {
18225       {
18226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18227       };
18228     } catch (...) {
18229       {
18230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18231       };
18232     }
18233   }
18234   jresult = result;
18235   return jresult;
18236 }
18237
18238
18239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18240   int jresult ;
18241   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18242   Dali::Property::Index arg2 ;
18243   Dali::Property::Type result;
18244
18245   arg1 = (Dali::Handle *)jarg1;
18246   arg2 = (Dali::Property::Index)jarg2;
18247   {
18248     try {
18249       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18250     } catch (std::out_of_range& e) {
18251       {
18252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18253       };
18254     } catch (std::exception& e) {
18255       {
18256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18257       };
18258     } catch (...) {
18259       {
18260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18261       };
18262     }
18263   }
18264   jresult = (int)result;
18265   return jresult;
18266 }
18267
18268
18269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18270   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18271   Dali::Property::Index arg2 ;
18272   Dali::Property::Value *arg3 = 0 ;
18273
18274   arg1 = (Dali::Handle *)jarg1;
18275   arg2 = (Dali::Property::Index)jarg2;
18276   arg3 = (Dali::Property::Value *)jarg3;
18277   if (!arg3) {
18278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18279     return ;
18280   }
18281   {
18282     try {
18283       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18284     } catch (std::out_of_range& e) {
18285       {
18286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18287       };
18288     } catch (std::exception& e) {
18289       {
18290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18291       };
18292     } catch (...) {
18293       {
18294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18295       };
18296     }
18297   }
18298 }
18299
18300
18301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18302   int jresult ;
18303   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18304   std::string *arg2 = 0 ;
18305   Dali::Property::Value *arg3 = 0 ;
18306   Dali::Property::Index result;
18307
18308   arg1 = (Dali::Handle *)jarg1;
18309   if (!jarg2) {
18310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18311     return 0;
18312   }
18313   std::string arg2_str(jarg2);
18314   arg2 = &arg2_str;
18315   arg3 = (Dali::Property::Value *)jarg3;
18316   if (!arg3) {
18317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18318     return 0;
18319   }
18320   {
18321     try {
18322       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18323     } catch (std::out_of_range& e) {
18324       {
18325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18326       };
18327     } catch (std::exception& e) {
18328       {
18329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18330       };
18331     } catch (...) {
18332       {
18333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18334       };
18335     }
18336   }
18337   jresult = result;
18338
18339   //argout typemap for const std::string&
18340
18341   return jresult;
18342 }
18343
18344
18345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18346   int jresult ;
18347   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18348   std::string *arg2 = 0 ;
18349   Dali::Property::Value *arg3 = 0 ;
18350   Dali::Property::AccessMode arg4 ;
18351   Dali::Property::Index result;
18352
18353   arg1 = (Dali::Handle *)jarg1;
18354   if (!jarg2) {
18355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18356     return 0;
18357   }
18358   std::string arg2_str(jarg2);
18359   arg2 = &arg2_str;
18360   arg3 = (Dali::Property::Value *)jarg3;
18361   if (!arg3) {
18362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18363     return 0;
18364   }
18365   arg4 = (Dali::Property::AccessMode)jarg4;
18366   {
18367     try {
18368       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18369     } catch (std::out_of_range& e) {
18370       {
18371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18372       };
18373     } catch (std::exception& e) {
18374       {
18375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18376       };
18377     } catch (...) {
18378       {
18379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18380       };
18381     }
18382   }
18383   jresult = result;
18384
18385   //argout typemap for const std::string&
18386
18387   return jresult;
18388 }
18389
18390
18391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18392   void * jresult ;
18393   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18394   Dali::Property::Index arg2 ;
18395   Dali::Property::Value result;
18396
18397   arg1 = (Dali::Handle *)jarg1;
18398   arg2 = (Dali::Property::Index)jarg2;
18399   {
18400     try {
18401       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18402     } catch (std::out_of_range& e) {
18403       {
18404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18405       };
18406     } catch (std::exception& e) {
18407       {
18408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18409       };
18410     } catch (...) {
18411       {
18412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18413       };
18414     }
18415   }
18416   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18417   return jresult;
18418 }
18419
18420
18421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18422   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18423   Dali::Property::IndexContainer *arg2 = 0 ;
18424
18425   arg1 = (Dali::Handle *)jarg1;
18426   arg2 = (Dali::Property::IndexContainer *)jarg2;
18427   if (!arg2) {
18428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18429     return ;
18430   }
18431   {
18432     try {
18433       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18434     } catch (std::out_of_range& e) {
18435       {
18436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18437       };
18438     } catch (std::exception& e) {
18439       {
18440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18441       };
18442     } catch (...) {
18443       {
18444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18445       };
18446     }
18447   }
18448 }
18449
18450
18451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18452   void * jresult ;
18453   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18454   Dali::Property::Index arg2 ;
18455   Dali::PropertyCondition *arg3 = 0 ;
18456   Dali::PropertyNotification result;
18457
18458   arg1 = (Dali::Handle *)jarg1;
18459   arg2 = (Dali::Property::Index)jarg2;
18460   arg3 = (Dali::PropertyCondition *)jarg3;
18461   if (!arg3) {
18462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18463     return 0;
18464   }
18465   {
18466     try {
18467       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18468     } catch (std::out_of_range& e) {
18469       {
18470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18471       };
18472     } catch (std::exception& e) {
18473       {
18474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18475       };
18476     } catch (...) {
18477       {
18478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18479       };
18480     }
18481   }
18482   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18483   return jresult;
18484 }
18485
18486
18487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18488   void * jresult ;
18489   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18490   Dali::Property::Index arg2 ;
18491   int arg3 ;
18492   Dali::PropertyCondition *arg4 = 0 ;
18493   Dali::PropertyNotification result;
18494
18495   arg1 = (Dali::Handle *)jarg1;
18496   arg2 = (Dali::Property::Index)jarg2;
18497   arg3 = (int)jarg3;
18498   arg4 = (Dali::PropertyCondition *)jarg4;
18499   if (!arg4) {
18500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18501     return 0;
18502   }
18503   {
18504     try {
18505       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18506     } catch (std::out_of_range& e) {
18507       {
18508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18509       };
18510     } catch (std::exception& e) {
18511       {
18512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18513       };
18514     } catch (...) {
18515       {
18516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18517       };
18518     }
18519   }
18520   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18521   return jresult;
18522 }
18523
18524
18525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18526   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18527   Dali::PropertyNotification arg2 ;
18528   Dali::PropertyNotification *argp2 ;
18529
18530   arg1 = (Dali::Handle *)jarg1;
18531   argp2 = (Dali::PropertyNotification *)jarg2;
18532   if (!argp2) {
18533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18534     return ;
18535   }
18536   arg2 = *argp2;
18537   {
18538     try {
18539       (arg1)->RemovePropertyNotification(arg2);
18540     } catch (std::out_of_range& e) {
18541       {
18542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18543       };
18544     } catch (std::exception& e) {
18545       {
18546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18547       };
18548     } catch (...) {
18549       {
18550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18551       };
18552     }
18553   }
18554 }
18555
18556
18557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18558   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18559
18560   arg1 = (Dali::Handle *)jarg1;
18561   {
18562     try {
18563       (arg1)->RemovePropertyNotifications();
18564     } catch (std::out_of_range& e) {
18565       {
18566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18567       };
18568     } catch (std::exception& e) {
18569       {
18570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18571       };
18572     } catch (...) {
18573       {
18574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18575       };
18576     }
18577   }
18578 }
18579
18580
18581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18582   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18583
18584   arg1 = (Dali::Handle *)jarg1;
18585   {
18586     try {
18587       (arg1)->RemoveConstraints();
18588     } catch (std::out_of_range& e) {
18589       {
18590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18591       };
18592     } catch (std::exception& e) {
18593       {
18594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18595       };
18596     } catch (...) {
18597       {
18598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18599       };
18600     }
18601   }
18602 }
18603
18604
18605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18606   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18607   unsigned int arg2 ;
18608
18609   arg1 = (Dali::Handle *)jarg1;
18610   arg2 = (unsigned int)jarg2;
18611   {
18612     try {
18613       (arg1)->RemoveConstraints(arg2);
18614     } catch (std::out_of_range& e) {
18615       {
18616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18617       };
18618     } catch (std::exception& e) {
18619       {
18620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18621       };
18622     } catch (...) {
18623       {
18624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18625       };
18626     }
18627   }
18628 }
18629
18630
18631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18632   int jresult ;
18633   Dali::Property::Index result;
18634
18635   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18636   jresult = result;
18637   return jresult;
18638 }
18639
18640
18641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18642   void * jresult ;
18643   Dali::Handle result;
18644
18645   {
18646     try {
18647       result = Dali::WeightObject::New();
18648     } catch (std::out_of_range& e) {
18649       {
18650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18651       };
18652     } catch (std::exception& e) {
18653       {
18654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18655       };
18656     } catch (...) {
18657       {
18658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18659       };
18660     }
18661   }
18662   jresult = new Dali::Handle((const Dali::Handle &)result);
18663   return jresult;
18664 }
18665
18666
18667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18668   void * jresult ;
18669   Dali::TypeInfo *result = 0 ;
18670
18671   {
18672     try {
18673       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18674     } catch (std::out_of_range& e) {
18675       {
18676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18677       };
18678     } catch (std::exception& e) {
18679       {
18680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18681       };
18682     } catch (...) {
18683       {
18684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18685       };
18686     }
18687   }
18688   jresult = (void *)result;
18689   return jresult;
18690 }
18691
18692
18693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18694   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18695
18696   arg1 = (Dali::TypeInfo *)jarg1;
18697   {
18698     try {
18699       delete arg1;
18700     } catch (std::out_of_range& e) {
18701       {
18702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18703       };
18704     } catch (std::exception& e) {
18705       {
18706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18707       };
18708     } catch (...) {
18709       {
18710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18711       };
18712     }
18713   }
18714 }
18715
18716
18717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18718   void * jresult ;
18719   Dali::TypeInfo *arg1 = 0 ;
18720   Dali::TypeInfo *result = 0 ;
18721
18722   arg1 = (Dali::TypeInfo *)jarg1;
18723   if (!arg1) {
18724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18725     return 0;
18726   }
18727   {
18728     try {
18729       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18730     } catch (std::out_of_range& e) {
18731       {
18732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18733       };
18734     } catch (std::exception& e) {
18735       {
18736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18737       };
18738     } catch (...) {
18739       {
18740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18741       };
18742     }
18743   }
18744   jresult = (void *)result;
18745   return jresult;
18746 }
18747
18748
18749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18750   void * jresult ;
18751   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18752   Dali::TypeInfo *arg2 = 0 ;
18753   Dali::TypeInfo *result = 0 ;
18754
18755   arg1 = (Dali::TypeInfo *)jarg1;
18756   arg2 = (Dali::TypeInfo *)jarg2;
18757   if (!arg2) {
18758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18759     return 0;
18760   }
18761   {
18762     try {
18763       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18764     } catch (std::out_of_range& e) {
18765       {
18766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18767       };
18768     } catch (std::exception& e) {
18769       {
18770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18771       };
18772     } catch (...) {
18773       {
18774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18775       };
18776     }
18777   }
18778   jresult = (void *)result;
18779   return jresult;
18780 }
18781
18782
18783 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18784   char * jresult ;
18785   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18786   std::string *result = 0 ;
18787
18788   arg1 = (Dali::TypeInfo *)jarg1;
18789   {
18790     try {
18791       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18792     } catch (std::out_of_range& e) {
18793       {
18794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18795       };
18796     } catch (std::exception& e) {
18797       {
18798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18799       };
18800     } catch (...) {
18801       {
18802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18803       };
18804     }
18805   }
18806   jresult = SWIG_csharp_string_callback(result->c_str());
18807   return jresult;
18808 }
18809
18810
18811 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18812   char * jresult ;
18813   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18814   std::string *result = 0 ;
18815
18816   arg1 = (Dali::TypeInfo *)jarg1;
18817   {
18818     try {
18819       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18820     } catch (std::out_of_range& e) {
18821       {
18822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18823       };
18824     } catch (std::exception& e) {
18825       {
18826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18827       };
18828     } catch (...) {
18829       {
18830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18831       };
18832     }
18833   }
18834   jresult = SWIG_csharp_string_callback(result->c_str());
18835   return jresult;
18836 }
18837
18838
18839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18840   void * jresult ;
18841   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18842   Dali::BaseHandle result;
18843
18844   arg1 = (Dali::TypeInfo *)jarg1;
18845   {
18846     try {
18847       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18848     } catch (std::out_of_range& e) {
18849       {
18850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18851       };
18852     } catch (std::exception& e) {
18853       {
18854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18855       };
18856     } catch (...) {
18857       {
18858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18859       };
18860     }
18861   }
18862   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18863   return jresult;
18864 }
18865
18866
18867 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18868   unsigned long jresult ;
18869   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18870   size_t result;
18871
18872   arg1 = (Dali::TypeInfo *)jarg1;
18873   {
18874     try {
18875       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18876     } catch (std::out_of_range& e) {
18877       {
18878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18879       };
18880     } catch (std::exception& e) {
18881       {
18882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18883       };
18884     } catch (...) {
18885       {
18886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18887       };
18888     }
18889   }
18890   jresult = (unsigned long)result;
18891   return jresult;
18892 }
18893
18894
18895 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18896   char * jresult ;
18897   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18898   size_t arg2 ;
18899   std::string result;
18900
18901   arg1 = (Dali::TypeInfo *)jarg1;
18902   arg2 = (size_t)jarg2;
18903   {
18904     try {
18905       result = (arg1)->GetActionName(arg2);
18906     } catch (std::out_of_range& e) {
18907       {
18908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18909       };
18910     } catch (std::exception& e) {
18911       {
18912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18913       };
18914     } catch (...) {
18915       {
18916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18917       };
18918     }
18919   }
18920   jresult = SWIG_csharp_string_callback((&result)->c_str());
18921   return jresult;
18922 }
18923
18924
18925 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18926   unsigned long jresult ;
18927   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18928   size_t result;
18929
18930   arg1 = (Dali::TypeInfo *)jarg1;
18931   {
18932     try {
18933       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18934     } catch (std::out_of_range& e) {
18935       {
18936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18937       };
18938     } catch (std::exception& e) {
18939       {
18940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18941       };
18942     } catch (...) {
18943       {
18944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18945       };
18946     }
18947   }
18948   jresult = (unsigned long)result;
18949   return jresult;
18950 }
18951
18952
18953 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18954   char * jresult ;
18955   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18956   size_t arg2 ;
18957   std::string result;
18958
18959   arg1 = (Dali::TypeInfo *)jarg1;
18960   arg2 = (size_t)jarg2;
18961   {
18962     try {
18963       result = (arg1)->GetSignalName(arg2);
18964     } catch (std::out_of_range& e) {
18965       {
18966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18967       };
18968     } catch (std::exception& e) {
18969       {
18970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18971       };
18972     } catch (...) {
18973       {
18974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18975       };
18976     }
18977   }
18978   jresult = SWIG_csharp_string_callback((&result)->c_str());
18979   return jresult;
18980 }
18981
18982
18983 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18984   unsigned long jresult ;
18985   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18986   size_t result;
18987
18988   arg1 = (Dali::TypeInfo *)jarg1;
18989   {
18990     try {
18991       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18992     } catch (std::out_of_range& e) {
18993       {
18994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18995       };
18996     } catch (std::exception& e) {
18997       {
18998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18999       };
19000     } catch (...) {
19001       {
19002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19003       };
19004     }
19005   }
19006   jresult = (unsigned long)result;
19007   return jresult;
19008 }
19009
19010
19011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
19012   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
19013   Dali::Property::IndexContainer *arg2 = 0 ;
19014
19015   arg1 = (Dali::TypeInfo *)jarg1;
19016   arg2 = (Dali::Property::IndexContainer *)jarg2;
19017   if (!arg2) {
19018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
19019     return ;
19020   }
19021   {
19022     try {
19023       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
19024     } catch (std::out_of_range& e) {
19025       {
19026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19027       };
19028     } catch (std::exception& e) {
19029       {
19030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19031       };
19032     } catch (...) {
19033       {
19034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19035       };
19036     }
19037   }
19038 }
19039
19040
19041 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
19042   char * jresult ;
19043   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
19044   Dali::Property::Index arg2 ;
19045   std::string *result = 0 ;
19046
19047   arg1 = (Dali::TypeInfo *)jarg1;
19048   arg2 = (Dali::Property::Index)jarg2;
19049   {
19050     try {
19051       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
19052     } catch (std::out_of_range& e) {
19053       {
19054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19055       };
19056     } catch (std::exception& e) {
19057       {
19058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19059       };
19060     } catch (...) {
19061       {
19062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19063       };
19064     }
19065   }
19066   jresult = SWIG_csharp_string_callback(result->c_str());
19067   return jresult;
19068 }
19069
19070
19071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
19072   void * jresult ;
19073   Dali::TypeRegistry result;
19074
19075   {
19076     try {
19077       result = Dali::TypeRegistry::Get();
19078     } catch (std::out_of_range& e) {
19079       {
19080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19081       };
19082     } catch (std::exception& e) {
19083       {
19084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19085       };
19086     } catch (...) {
19087       {
19088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19089       };
19090     }
19091   }
19092   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19093   return jresult;
19094 }
19095
19096
19097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
19098   void * jresult ;
19099   Dali::TypeRegistry *result = 0 ;
19100
19101   {
19102     try {
19103       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19104     } catch (std::out_of_range& e) {
19105       {
19106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19107       };
19108     } catch (std::exception& e) {
19109       {
19110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19111       };
19112     } catch (...) {
19113       {
19114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19115       };
19116     }
19117   }
19118   jresult = (void *)result;
19119   return jresult;
19120 }
19121
19122
19123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19124   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19125
19126   arg1 = (Dali::TypeRegistry *)jarg1;
19127   {
19128     try {
19129       delete arg1;
19130     } catch (std::out_of_range& e) {
19131       {
19132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19133       };
19134     } catch (std::exception& e) {
19135       {
19136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19137       };
19138     } catch (...) {
19139       {
19140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19141       };
19142     }
19143   }
19144 }
19145
19146
19147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19148   void * jresult ;
19149   Dali::TypeRegistry *arg1 = 0 ;
19150   Dali::TypeRegistry *result = 0 ;
19151
19152   arg1 = (Dali::TypeRegistry *)jarg1;
19153   if (!arg1) {
19154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19155     return 0;
19156   }
19157   {
19158     try {
19159       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19160     } catch (std::out_of_range& e) {
19161       {
19162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19163       };
19164     } catch (std::exception& e) {
19165       {
19166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19167       };
19168     } catch (...) {
19169       {
19170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19171       };
19172     }
19173   }
19174   jresult = (void *)result;
19175   return jresult;
19176 }
19177
19178
19179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19180   void * jresult ;
19181   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19182   Dali::TypeRegistry *arg2 = 0 ;
19183   Dali::TypeRegistry *result = 0 ;
19184
19185   arg1 = (Dali::TypeRegistry *)jarg1;
19186   arg2 = (Dali::TypeRegistry *)jarg2;
19187   if (!arg2) {
19188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19189     return 0;
19190   }
19191   {
19192     try {
19193       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19194     } catch (std::out_of_range& e) {
19195       {
19196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19197       };
19198     } catch (std::exception& e) {
19199       {
19200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19201       };
19202     } catch (...) {
19203       {
19204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19205       };
19206     }
19207   }
19208   jresult = (void *)result;
19209   return jresult;
19210 }
19211
19212
19213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19214   void * jresult ;
19215   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19216   std::string *arg2 = 0 ;
19217   Dali::TypeInfo result;
19218
19219   arg1 = (Dali::TypeRegistry *)jarg1;
19220   if (!jarg2) {
19221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19222     return 0;
19223   }
19224   std::string arg2_str(jarg2);
19225   arg2 = &arg2_str;
19226   {
19227     try {
19228       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19229     } catch (std::out_of_range& e) {
19230       {
19231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19232       };
19233     } catch (std::exception& e) {
19234       {
19235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19236       };
19237     } catch (...) {
19238       {
19239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19240       };
19241     }
19242   }
19243   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19244
19245   //argout typemap for const std::string&
19246
19247   return jresult;
19248 }
19249
19250
19251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19252   void * jresult ;
19253   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19254   std::type_info *arg2 = 0 ;
19255   Dali::TypeInfo result;
19256
19257   arg1 = (Dali::TypeRegistry *)jarg1;
19258   arg2 = (std::type_info *)jarg2;
19259   if (!arg2) {
19260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19261     return 0;
19262   }
19263   {
19264     try {
19265       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19266     } catch (std::out_of_range& e) {
19267       {
19268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19269       };
19270     } catch (std::exception& e) {
19271       {
19272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19273       };
19274     } catch (...) {
19275       {
19276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19277       };
19278     }
19279   }
19280   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19281   return jresult;
19282 }
19283
19284
19285 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19286   unsigned long jresult ;
19287   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19288   size_t result;
19289
19290   arg1 = (Dali::TypeRegistry *)jarg1;
19291   {
19292     try {
19293       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19294     } catch (std::out_of_range& e) {
19295       {
19296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19297       };
19298     } catch (std::exception& e) {
19299       {
19300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19301       };
19302     } catch (...) {
19303       {
19304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19305       };
19306     }
19307   }
19308   jresult = (unsigned long)result;
19309   return jresult;
19310 }
19311
19312
19313 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19314   char * jresult ;
19315   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19316   size_t arg2 ;
19317   std::string result;
19318
19319   arg1 = (Dali::TypeRegistry *)jarg1;
19320   arg2 = (size_t)jarg2;
19321   {
19322     try {
19323       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19324     } catch (std::out_of_range& e) {
19325       {
19326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19327       };
19328     } catch (std::exception& e) {
19329       {
19330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19331       };
19332     } catch (...) {
19333       {
19334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19335       };
19336     }
19337   }
19338   jresult = SWIG_csharp_string_callback((&result)->c_str());
19339   return jresult;
19340 }
19341
19342
19343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19344   void * jresult ;
19345   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19346   Dali::TypeRegistry *result = 0 ;
19347
19348   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19349   {
19350     try {
19351       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19352     } catch (std::out_of_range& e) {
19353       {
19354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19355       };
19356     } catch (std::exception& e) {
19357       {
19358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19359       };
19360     } catch (...) {
19361       {
19362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19363       };
19364     }
19365   }
19366   jresult = (void *)result;
19367   return jresult;
19368 }
19369
19370
19371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19372   void * jresult ;
19373   std::type_info *arg1 = 0 ;
19374   std::type_info *arg2 = 0 ;
19375   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19376   Dali::TypeRegistration *result = 0 ;
19377
19378   arg1 = (std::type_info *)jarg1;
19379   if (!arg1) {
19380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19381     return 0;
19382   }
19383   arg2 = (std::type_info *)jarg2;
19384   if (!arg2) {
19385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19386     return 0;
19387   }
19388   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19389   {
19390     try {
19391       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19392     } catch (std::out_of_range& e) {
19393       {
19394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19395       };
19396     } catch (std::exception& e) {
19397       {
19398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19399       };
19400     } catch (...) {
19401       {
19402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19403       };
19404     }
19405   }
19406   jresult = (void *)result;
19407   return jresult;
19408 }
19409
19410
19411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19412   void * jresult ;
19413   std::type_info *arg1 = 0 ;
19414   std::type_info *arg2 = 0 ;
19415   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19416   bool arg4 ;
19417   Dali::TypeRegistration *result = 0 ;
19418
19419   arg1 = (std::type_info *)jarg1;
19420   if (!arg1) {
19421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19422     return 0;
19423   }
19424   arg2 = (std::type_info *)jarg2;
19425   if (!arg2) {
19426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19427     return 0;
19428   }
19429   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19430   arg4 = jarg4 ? true : false;
19431   {
19432     try {
19433       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19434     } catch (std::out_of_range& e) {
19435       {
19436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19437       };
19438     } catch (std::exception& e) {
19439       {
19440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19441       };
19442     } catch (...) {
19443       {
19444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19445       };
19446     }
19447   }
19448   jresult = (void *)result;
19449   return jresult;
19450 }
19451
19452
19453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19454   void * jresult ;
19455   std::string *arg1 = 0 ;
19456   std::type_info *arg2 = 0 ;
19457   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19458   Dali::TypeRegistration *result = 0 ;
19459
19460   if (!jarg1) {
19461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19462     return 0;
19463   }
19464   std::string arg1_str(jarg1);
19465   arg1 = &arg1_str;
19466   arg2 = (std::type_info *)jarg2;
19467   if (!arg2) {
19468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19469     return 0;
19470   }
19471   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19472   {
19473     try {
19474       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19475     } catch (std::out_of_range& e) {
19476       {
19477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19478       };
19479     } catch (std::exception& e) {
19480       {
19481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19482       };
19483     } catch (...) {
19484       {
19485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19486       };
19487     }
19488   }
19489   jresult = (void *)result;
19490
19491   //argout typemap for const std::string&
19492
19493   return jresult;
19494 }
19495
19496
19497 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19498   char * jresult ;
19499   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19500   std::string result;
19501
19502   arg1 = (Dali::TypeRegistration *)jarg1;
19503   {
19504     try {
19505       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19506     } catch (std::out_of_range& e) {
19507       {
19508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19509       };
19510     } catch (std::exception& e) {
19511       {
19512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19513       };
19514     } catch (...) {
19515       {
19516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19517       };
19518     }
19519   }
19520   jresult = SWIG_csharp_string_callback((&result)->c_str());
19521   return jresult;
19522 }
19523
19524
19525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19526   std::string *arg1 = 0 ;
19527   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19528
19529   if (!jarg1) {
19530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19531     return ;
19532   }
19533   std::string arg1_str(jarg1);
19534   arg1 = &arg1_str;
19535   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19536   {
19537     try {
19538       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19539     } catch (std::out_of_range& e) {
19540       {
19541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19542       };
19543     } catch (std::exception& e) {
19544       {
19545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19546       };
19547     } catch (...) {
19548       {
19549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19550       };
19551     }
19552   }
19553
19554   //argout typemap for const std::string&
19555
19556 }
19557
19558
19559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19560   std::string *arg1 = 0 ;
19561   std::string *arg2 = 0 ;
19562   int arg3 ;
19563   Dali::Property::Type arg4 ;
19564   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19565   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19566
19567   if (!jarg1) {
19568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19569     return ;
19570   }
19571   std::string arg1_str(jarg1);
19572   arg1 = &arg1_str;
19573   if (!jarg2) {
19574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19575     return ;
19576   }
19577   std::string arg2_str(jarg2);
19578   arg2 = &arg2_str;
19579   arg3 = (int)jarg3;
19580   arg4 = (Dali::Property::Type)jarg4;
19581   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19582   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19583   {
19584     try {
19585       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19586     } catch (std::out_of_range& e) {
19587       {
19588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19589       };
19590     } catch (std::exception& e) {
19591       {
19592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19593       };
19594     } catch (...) {
19595       {
19596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19597       };
19598     }
19599   }
19600
19601   //argout typemap for const std::string&
19602
19603
19604   //argout typemap for const std::string&
19605
19606 }
19607
19608
19609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19610   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19611
19612   arg1 = (Dali::TypeRegistration *)jarg1;
19613   {
19614     try {
19615       delete arg1;
19616     } catch (std::out_of_range& e) {
19617       {
19618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19619       };
19620     } catch (std::exception& e) {
19621       {
19622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19623       };
19624     } catch (...) {
19625       {
19626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19627       };
19628     }
19629   }
19630 }
19631
19632
19633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19634   void * jresult ;
19635   Dali::TypeRegistration *arg1 = 0 ;
19636   std::string *arg2 = 0 ;
19637   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19638   Dali::SignalConnectorType *result = 0 ;
19639
19640   arg1 = (Dali::TypeRegistration *)jarg1;
19641   if (!arg1) {
19642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19643     return 0;
19644   }
19645   if (!jarg2) {
19646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19647     return 0;
19648   }
19649   std::string arg2_str(jarg2);
19650   arg2 = &arg2_str;
19651   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19652   {
19653     try {
19654       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19655     } catch (std::out_of_range& e) {
19656       {
19657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19658       };
19659     } catch (std::exception& e) {
19660       {
19661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19662       };
19663     } catch (...) {
19664       {
19665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19666       };
19667     }
19668   }
19669   jresult = (void *)result;
19670
19671   //argout typemap for const std::string&
19672
19673   return jresult;
19674 }
19675
19676
19677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19678   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19679
19680   arg1 = (Dali::SignalConnectorType *)jarg1;
19681   {
19682     try {
19683       delete arg1;
19684     } catch (std::out_of_range& e) {
19685       {
19686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19687       };
19688     } catch (std::exception& e) {
19689       {
19690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19691       };
19692     } catch (...) {
19693       {
19694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19695       };
19696     }
19697   }
19698 }
19699
19700
19701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19702   void * jresult ;
19703   Dali::TypeRegistration *arg1 = 0 ;
19704   std::string *arg2 = 0 ;
19705   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19706   Dali::TypeAction *result = 0 ;
19707
19708   arg1 = (Dali::TypeRegistration *)jarg1;
19709   if (!arg1) {
19710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19711     return 0;
19712   }
19713   if (!jarg2) {
19714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19715     return 0;
19716   }
19717   std::string arg2_str(jarg2);
19718   arg2 = &arg2_str;
19719   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19720   {
19721     try {
19722       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19723     } catch (std::out_of_range& e) {
19724       {
19725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19726       };
19727     } catch (std::exception& e) {
19728       {
19729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19730       };
19731     } catch (...) {
19732       {
19733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19734       };
19735     }
19736   }
19737   jresult = (void *)result;
19738
19739   //argout typemap for const std::string&
19740
19741   return jresult;
19742 }
19743
19744
19745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19746   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19747
19748   arg1 = (Dali::TypeAction *)jarg1;
19749   {
19750     try {
19751       delete arg1;
19752     } catch (std::out_of_range& e) {
19753       {
19754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19755       };
19756     } catch (std::exception& e) {
19757       {
19758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19759       };
19760     } catch (...) {
19761       {
19762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19763       };
19764     }
19765   }
19766 }
19767
19768
19769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19770   void * jresult ;
19771   Dali::TypeRegistration *arg1 = 0 ;
19772   std::string *arg2 = 0 ;
19773   Dali::Property::Index arg3 ;
19774   Dali::Property::Type arg4 ;
19775   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19776   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19777   Dali::PropertyRegistration *result = 0 ;
19778
19779   arg1 = (Dali::TypeRegistration *)jarg1;
19780   if (!arg1) {
19781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19782     return 0;
19783   }
19784   if (!jarg2) {
19785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19786     return 0;
19787   }
19788   std::string arg2_str(jarg2);
19789   arg2 = &arg2_str;
19790   arg3 = (Dali::Property::Index)jarg3;
19791   arg4 = (Dali::Property::Type)jarg4;
19792   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19793   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19794   {
19795     try {
19796       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19797     } catch (std::out_of_range& e) {
19798       {
19799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19800       };
19801     } catch (std::exception& e) {
19802       {
19803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19804       };
19805     } catch (...) {
19806       {
19807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19808       };
19809     }
19810   }
19811   jresult = (void *)result;
19812
19813   //argout typemap for const std::string&
19814
19815   return jresult;
19816 }
19817
19818
19819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19820   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19821
19822   arg1 = (Dali::PropertyRegistration *)jarg1;
19823   {
19824     try {
19825       delete arg1;
19826     } catch (std::out_of_range& e) {
19827       {
19828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19829       };
19830     } catch (std::exception& e) {
19831       {
19832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19833       };
19834     } catch (...) {
19835       {
19836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19837       };
19838     }
19839   }
19840 }
19841
19842
19843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19844   void * jresult ;
19845   Dali::TypeRegistration *arg1 = 0 ;
19846   std::string *arg2 = 0 ;
19847   Dali::Property::Index arg3 ;
19848   Dali::Property::Type arg4 ;
19849   Dali::AnimatablePropertyRegistration *result = 0 ;
19850
19851   arg1 = (Dali::TypeRegistration *)jarg1;
19852   if (!arg1) {
19853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19854     return 0;
19855   }
19856   if (!jarg2) {
19857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19858     return 0;
19859   }
19860   std::string arg2_str(jarg2);
19861   arg2 = &arg2_str;
19862   arg3 = (Dali::Property::Index)jarg3;
19863   arg4 = (Dali::Property::Type)jarg4;
19864   {
19865     try {
19866       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19867     } catch (std::out_of_range& e) {
19868       {
19869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19870       };
19871     } catch (std::exception& e) {
19872       {
19873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19874       };
19875     } catch (...) {
19876       {
19877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19878       };
19879     }
19880   }
19881   jresult = (void *)result;
19882
19883   //argout typemap for const std::string&
19884
19885   return jresult;
19886 }
19887
19888
19889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19890   void * jresult ;
19891   Dali::TypeRegistration *arg1 = 0 ;
19892   std::string *arg2 = 0 ;
19893   Dali::Property::Index arg3 ;
19894   Dali::Property::Value *arg4 = 0 ;
19895   Dali::AnimatablePropertyRegistration *result = 0 ;
19896
19897   arg1 = (Dali::TypeRegistration *)jarg1;
19898   if (!arg1) {
19899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19900     return 0;
19901   }
19902   if (!jarg2) {
19903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19904     return 0;
19905   }
19906   std::string arg2_str(jarg2);
19907   arg2 = &arg2_str;
19908   arg3 = (Dali::Property::Index)jarg3;
19909   arg4 = (Dali::Property::Value *)jarg4;
19910   if (!arg4) {
19911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19912     return 0;
19913   }
19914   {
19915     try {
19916       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19917     } catch (std::out_of_range& e) {
19918       {
19919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19920       };
19921     } catch (std::exception& e) {
19922       {
19923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19924       };
19925     } catch (...) {
19926       {
19927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19928       };
19929     }
19930   }
19931   jresult = (void *)result;
19932
19933   //argout typemap for const std::string&
19934
19935   return jresult;
19936 }
19937
19938
19939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19940   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19941
19942   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19943   {
19944     try {
19945       delete arg1;
19946     } catch (std::out_of_range& e) {
19947       {
19948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19949       };
19950     } catch (std::exception& e) {
19951       {
19952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19953       };
19954     } catch (...) {
19955       {
19956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19957       };
19958     }
19959   }
19960 }
19961
19962
19963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19964   void * jresult ;
19965   Dali::TypeRegistration *arg1 = 0 ;
19966   std::string *arg2 = 0 ;
19967   Dali::Property::Index arg3 ;
19968   Dali::Property::Index arg4 ;
19969   unsigned int arg5 ;
19970   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19971
19972   arg1 = (Dali::TypeRegistration *)jarg1;
19973   if (!arg1) {
19974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19975     return 0;
19976   }
19977   if (!jarg2) {
19978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19979     return 0;
19980   }
19981   std::string arg2_str(jarg2);
19982   arg2 = &arg2_str;
19983   arg3 = (Dali::Property::Index)jarg3;
19984   arg4 = (Dali::Property::Index)jarg4;
19985   arg5 = (unsigned int)jarg5;
19986   {
19987     try {
19988       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19989     } catch (std::out_of_range& e) {
19990       {
19991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19992       };
19993     } catch (std::exception& e) {
19994       {
19995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19996       };
19997     } catch (...) {
19998       {
19999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20000       };
20001     }
20002   }
20003   jresult = (void *)result;
20004
20005   //argout typemap for const std::string&
20006
20007   return jresult;
20008 }
20009
20010
20011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
20012   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
20013
20014   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
20015   {
20016     try {
20017       delete arg1;
20018     } catch (std::out_of_range& e) {
20019       {
20020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20021       };
20022     } catch (std::exception& e) {
20023       {
20024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20025       };
20026     } catch (...) {
20027       {
20028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20029       };
20030     }
20031   }
20032 }
20033
20034
20035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
20036   void * jresult ;
20037   Dali::TypeRegistration *arg1 = 0 ;
20038   std::string *arg2 = 0 ;
20039   Dali::Property::Index arg3 ;
20040   Dali::Property::Type arg4 ;
20041   Dali::ChildPropertyRegistration *result = 0 ;
20042
20043   arg1 = (Dali::TypeRegistration *)jarg1;
20044   if (!arg1) {
20045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
20046     return 0;
20047   }
20048   if (!jarg2) {
20049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20050     return 0;
20051   }
20052   std::string arg2_str(jarg2);
20053   arg2 = &arg2_str;
20054   arg3 = (Dali::Property::Index)jarg3;
20055   arg4 = (Dali::Property::Type)jarg4;
20056   {
20057     try {
20058       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
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 = (void *)result;
20074
20075   //argout typemap for const std::string&
20076
20077   return jresult;
20078 }
20079
20080
20081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
20082   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
20083
20084   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
20085   {
20086     try {
20087       delete arg1;
20088     } catch (std::out_of_range& e) {
20089       {
20090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20091       };
20092     } catch (std::exception& e) {
20093       {
20094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20095       };
20096     } catch (...) {
20097       {
20098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20099       };
20100     }
20101   }
20102 }
20103
20104
20105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
20106   unsigned int jresult ;
20107   std::string *arg1 = 0 ;
20108   std::type_info *arg2 = 0 ;
20109   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
20110   bool result;
20111
20112   if (!jarg1) {
20113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20114     return 0;
20115   }
20116   std::string arg1_str(jarg1);
20117   arg1 = &arg1_str;
20118   arg2 = (std::type_info *)jarg2;
20119   if (!arg2) {
20120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20121     return 0;
20122   }
20123   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20124   {
20125     try {
20126       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20127     } catch (std::out_of_range& e) {
20128       {
20129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20130       };
20131     } catch (std::exception& e) {
20132       {
20133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20134       };
20135     } catch (...) {
20136       {
20137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20138       };
20139     }
20140   }
20141   jresult = result;
20142
20143   //argout typemap for const std::string&
20144
20145   return jresult;
20146 }
20147
20148
20149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20150   unsigned int jresult ;
20151   std::string *arg1 = 0 ;
20152   std::string *arg2 = 0 ;
20153   Dali::Property::Index arg3 ;
20154   Dali::Property::Type arg4 ;
20155   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20156   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20157   bool result;
20158
20159   if (!jarg1) {
20160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20161     return 0;
20162   }
20163   std::string arg1_str(jarg1);
20164   arg1 = &arg1_str;
20165   if (!jarg2) {
20166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20167     return 0;
20168   }
20169   std::string arg2_str(jarg2);
20170   arg2 = &arg2_str;
20171   arg3 = (Dali::Property::Index)jarg3;
20172   arg4 = (Dali::Property::Type)jarg4;
20173   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20174   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20175   {
20176     try {
20177       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20178     } catch (std::out_of_range& e) {
20179       {
20180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20181       };
20182     } catch (std::exception& e) {
20183       {
20184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20185       };
20186     } catch (...) {
20187       {
20188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20189       };
20190     }
20191   }
20192   jresult = result;
20193
20194   //argout typemap for const std::string&
20195
20196
20197   //argout typemap for const std::string&
20198
20199   return jresult;
20200 }
20201
20202
20203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20204   float jresult ;
20205   float result;
20206
20207   result = (float)(float)Dali::ParentOrigin::TOP;
20208   jresult = result;
20209   return jresult;
20210 }
20211
20212
20213 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20214   float jresult ;
20215   float result;
20216
20217   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20218   jresult = result;
20219   return jresult;
20220 }
20221
20222
20223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20224   float jresult ;
20225   float result;
20226
20227   result = (float)(float)Dali::ParentOrigin::LEFT;
20228   jresult = result;
20229   return jresult;
20230 }
20231
20232
20233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20234   float jresult ;
20235   float result;
20236
20237   result = (float)(float)Dali::ParentOrigin::RIGHT;
20238   jresult = result;
20239   return jresult;
20240 }
20241
20242
20243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20244   float jresult ;
20245   float result;
20246
20247   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20248   jresult = result;
20249   return jresult;
20250 }
20251
20252
20253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20254   void * jresult ;
20255   Dali::Vector3 *result = 0 ;
20256
20257   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20258   jresult = (void *)result;
20259   return jresult;
20260 }
20261
20262
20263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20264   void * jresult ;
20265   Dali::Vector3 *result = 0 ;
20266
20267   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20268   jresult = (void *)result;
20269   return jresult;
20270 }
20271
20272
20273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20274   void * jresult ;
20275   Dali::Vector3 *result = 0 ;
20276
20277   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20278   jresult = (void *)result;
20279   return jresult;
20280 }
20281
20282
20283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20284   void * jresult ;
20285   Dali::Vector3 *result = 0 ;
20286
20287   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20288   jresult = (void *)result;
20289   return jresult;
20290 }
20291
20292
20293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20294   void * jresult ;
20295   Dali::Vector3 *result = 0 ;
20296
20297   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20298   jresult = (void *)result;
20299   return jresult;
20300 }
20301
20302
20303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20304   void * jresult ;
20305   Dali::Vector3 *result = 0 ;
20306
20307   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20308   jresult = (void *)result;
20309   return jresult;
20310 }
20311
20312
20313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20314   void * jresult ;
20315   Dali::Vector3 *result = 0 ;
20316
20317   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20318   jresult = (void *)result;
20319   return jresult;
20320 }
20321
20322
20323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20324   void * jresult ;
20325   Dali::Vector3 *result = 0 ;
20326
20327   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20328   jresult = (void *)result;
20329   return jresult;
20330 }
20331
20332
20333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20334   void * jresult ;
20335   Dali::Vector3 *result = 0 ;
20336
20337   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20338   jresult = (void *)result;
20339   return jresult;
20340 }
20341
20342
20343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20344   float jresult ;
20345   float result;
20346
20347   result = (float)(float)Dali::AnchorPoint::TOP;
20348   jresult = result;
20349   return jresult;
20350 }
20351
20352
20353 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20354   float jresult ;
20355   float result;
20356
20357   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20358   jresult = result;
20359   return jresult;
20360 }
20361
20362
20363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20364   float jresult ;
20365   float result;
20366
20367   result = (float)(float)Dali::AnchorPoint::LEFT;
20368   jresult = result;
20369   return jresult;
20370 }
20371
20372
20373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20374   float jresult ;
20375   float result;
20376
20377   result = (float)(float)Dali::AnchorPoint::RIGHT;
20378   jresult = result;
20379   return jresult;
20380 }
20381
20382
20383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20384   float jresult ;
20385   float result;
20386
20387   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20388   jresult = result;
20389   return jresult;
20390 }
20391
20392
20393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20394   void * jresult ;
20395   Dali::Vector3 *result = 0 ;
20396
20397   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20398   jresult = (void *)result;
20399   return jresult;
20400 }
20401
20402
20403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20404   void * jresult ;
20405   Dali::Vector3 *result = 0 ;
20406
20407   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20408   jresult = (void *)result;
20409   return jresult;
20410 }
20411
20412
20413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20414   void * jresult ;
20415   Dali::Vector3 *result = 0 ;
20416
20417   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20418   jresult = (void *)result;
20419   return jresult;
20420 }
20421
20422
20423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20424   void * jresult ;
20425   Dali::Vector3 *result = 0 ;
20426
20427   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20428   jresult = (void *)result;
20429   return jresult;
20430 }
20431
20432
20433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20434   void * jresult ;
20435   Dali::Vector3 *result = 0 ;
20436
20437   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20438   jresult = (void *)result;
20439   return jresult;
20440 }
20441
20442
20443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20444   void * jresult ;
20445   Dali::Vector3 *result = 0 ;
20446
20447   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20448   jresult = (void *)result;
20449   return jresult;
20450 }
20451
20452
20453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20454   void * jresult ;
20455   Dali::Vector3 *result = 0 ;
20456
20457   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20458   jresult = (void *)result;
20459   return jresult;
20460 }
20461
20462
20463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20464   void * jresult ;
20465   Dali::Vector3 *result = 0 ;
20466
20467   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20468   jresult = (void *)result;
20469   return jresult;
20470 }
20471
20472
20473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20474   void * jresult ;
20475   Dali::Vector3 *result = 0 ;
20476
20477   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20478   jresult = (void *)result;
20479   return jresult;
20480 }
20481
20482
20483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20484   void * jresult ;
20485   Dali::Vector4 *result = 0 ;
20486
20487   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20488   jresult = (void *)result;
20489   return jresult;
20490 }
20491
20492
20493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20494   void * jresult ;
20495   Dali::Vector4 *result = 0 ;
20496
20497   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20498   jresult = (void *)result;
20499   return jresult;
20500 }
20501
20502
20503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20504   void * jresult ;
20505   Dali::Vector4 *result = 0 ;
20506
20507   result = (Dali::Vector4 *)&Dali::Color::RED;
20508   jresult = (void *)result;
20509   return jresult;
20510 }
20511
20512
20513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20514   void * jresult ;
20515   Dali::Vector4 *result = 0 ;
20516
20517   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20518   jresult = (void *)result;
20519   return jresult;
20520 }
20521
20522
20523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20524   void * jresult ;
20525   Dali::Vector4 *result = 0 ;
20526
20527   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20528   jresult = (void *)result;
20529   return jresult;
20530 }
20531
20532
20533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20534   void * jresult ;
20535   Dali::Vector4 *result = 0 ;
20536
20537   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20538   jresult = (void *)result;
20539   return jresult;
20540 }
20541
20542
20543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20544   void * jresult ;
20545   Dali::Vector4 *result = 0 ;
20546
20547   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20548   jresult = (void *)result;
20549   return jresult;
20550 }
20551
20552
20553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20554   void * jresult ;
20555   Dali::Vector4 *result = 0 ;
20556
20557   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20558   jresult = (void *)result;
20559   return jresult;
20560 }
20561
20562
20563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20564   void * jresult ;
20565   Dali::Vector4 *result = 0 ;
20566
20567   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20568   jresult = (void *)result;
20569   return jresult;
20570 }
20571
20572
20573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20574   float jresult ;
20575   float result;
20576
20577   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20578   jresult = result;
20579   return jresult;
20580 }
20581
20582
20583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20584   float jresult ;
20585   float result;
20586
20587   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20588   jresult = result;
20589   return jresult;
20590 }
20591
20592
20593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20594   float jresult ;
20595   float result;
20596
20597   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20598   jresult = result;
20599   return jresult;
20600 }
20601
20602
20603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20604   float jresult ;
20605   float result;
20606
20607   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20608   jresult = result;
20609   return jresult;
20610 }
20611
20612
20613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20614   float jresult ;
20615   float result;
20616
20617   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20618   jresult = result;
20619   return jresult;
20620 }
20621
20622
20623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20624   float jresult ;
20625   float result;
20626
20627   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20628   jresult = result;
20629   return jresult;
20630 }
20631
20632
20633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20634   float jresult ;
20635   float result;
20636
20637   result = (float)(float)Dali::Math::PI;
20638   jresult = result;
20639   return jresult;
20640 }
20641
20642
20643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20644   float jresult ;
20645   float result;
20646
20647   result = (float)(float)Dali::Math::PI_2;
20648   jresult = result;
20649   return jresult;
20650 }
20651
20652
20653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20654   float jresult ;
20655   float result;
20656
20657   result = (float)(float)Dali::Math::PI_4;
20658   jresult = result;
20659   return jresult;
20660 }
20661
20662
20663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20664   float jresult ;
20665   float result;
20666
20667   result = (float)(float)Dali::Math::PI_OVER_180;
20668   jresult = result;
20669   return jresult;
20670 }
20671
20672
20673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20674   float jresult ;
20675   float result;
20676
20677   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20678   jresult = result;
20679   return jresult;
20680 }
20681
20682
20683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20684   int jresult ;
20685   Dali::ResizePolicy::Type result;
20686
20687   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20688   jresult = (int)result;
20689   return jresult;
20690 }
20691
20692
20693 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20694   unsigned long jresult ;
20695   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20696   Dali::VectorBase::SizeType result;
20697
20698   arg1 = (Dali::VectorBase *)jarg1;
20699   {
20700     try {
20701       result = ((Dali::VectorBase const *)arg1)->Count();
20702     } catch (std::out_of_range& e) {
20703       {
20704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20705       };
20706     } catch (std::exception& e) {
20707       {
20708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20709       };
20710     } catch (...) {
20711       {
20712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20713       };
20714     }
20715   }
20716   jresult = (unsigned long)result;
20717   return jresult;
20718 }
20719
20720
20721 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20722   unsigned long jresult ;
20723   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20724   Dali::VectorBase::SizeType result;
20725
20726   arg1 = (Dali::VectorBase *)jarg1;
20727   {
20728     try {
20729       result = ((Dali::VectorBase const *)arg1)->Size();
20730     } catch (std::out_of_range& e) {
20731       {
20732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20733       };
20734     } catch (std::exception& e) {
20735       {
20736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20737       };
20738     } catch (...) {
20739       {
20740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20741       };
20742     }
20743   }
20744   jresult = (unsigned long)result;
20745   return jresult;
20746 }
20747
20748
20749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20750   unsigned int jresult ;
20751   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20752   bool result;
20753
20754   arg1 = (Dali::VectorBase *)jarg1;
20755   {
20756     try {
20757       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20758     } catch (std::out_of_range& e) {
20759       {
20760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20761       };
20762     } catch (std::exception& e) {
20763       {
20764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20765       };
20766     } catch (...) {
20767       {
20768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20769       };
20770     }
20771   }
20772   jresult = result;
20773   return jresult;
20774 }
20775
20776
20777 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20778   unsigned long jresult ;
20779   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20780   Dali::VectorBase::SizeType result;
20781
20782   arg1 = (Dali::VectorBase *)jarg1;
20783   {
20784     try {
20785       result = ((Dali::VectorBase const *)arg1)->Capacity();
20786     } catch (std::out_of_range& e) {
20787       {
20788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20789       };
20790     } catch (std::exception& e) {
20791       {
20792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20793       };
20794     } catch (...) {
20795       {
20796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20797       };
20798     }
20799   }
20800   jresult = (unsigned long)result;
20801   return jresult;
20802 }
20803
20804
20805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20806   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20807
20808   arg1 = (Dali::VectorBase *)jarg1;
20809   {
20810     try {
20811       (arg1)->Release();
20812     } catch (std::out_of_range& e) {
20813       {
20814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20815       };
20816     } catch (std::exception& e) {
20817       {
20818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20819       };
20820     } catch (...) {
20821       {
20822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20823       };
20824     }
20825   }
20826 }
20827
20828
20829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20830   void * jresult ;
20831   Dali::Image *result = 0 ;
20832
20833   {
20834     try {
20835       result = (Dali::Image *)new Dali::Image();
20836     } catch (std::out_of_range& e) {
20837       {
20838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20839       };
20840     } catch (std::exception& e) {
20841       {
20842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20843       };
20844     } catch (...) {
20845       {
20846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20847       };
20848     }
20849   }
20850   jresult = (void *)result;
20851   return jresult;
20852 }
20853
20854
20855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20856   Dali::Image *arg1 = (Dali::Image *) 0 ;
20857
20858   arg1 = (Dali::Image *)jarg1;
20859   {
20860     try {
20861       delete arg1;
20862     } catch (std::out_of_range& e) {
20863       {
20864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20865       };
20866     } catch (std::exception& e) {
20867       {
20868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20869       };
20870     } catch (...) {
20871       {
20872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20873       };
20874     }
20875   }
20876 }
20877
20878
20879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20880   void * jresult ;
20881   Dali::Image *arg1 = 0 ;
20882   Dali::Image *result = 0 ;
20883
20884   arg1 = (Dali::Image *)jarg1;
20885   if (!arg1) {
20886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20887     return 0;
20888   }
20889   {
20890     try {
20891       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20892     } catch (std::out_of_range& e) {
20893       {
20894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20895       };
20896     } catch (std::exception& e) {
20897       {
20898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20899       };
20900     } catch (...) {
20901       {
20902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20903       };
20904     }
20905   }
20906   jresult = (void *)result;
20907   return jresult;
20908 }
20909
20910
20911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20912   void * jresult ;
20913   Dali::Image *arg1 = (Dali::Image *) 0 ;
20914   Dali::Image *arg2 = 0 ;
20915   Dali::Image *result = 0 ;
20916
20917   arg1 = (Dali::Image *)jarg1;
20918   arg2 = (Dali::Image *)jarg2;
20919   if (!arg2) {
20920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20921     return 0;
20922   }
20923   {
20924     try {
20925       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20926     } catch (std::out_of_range& e) {
20927       {
20928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20929       };
20930     } catch (std::exception& e) {
20931       {
20932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20933       };
20934     } catch (...) {
20935       {
20936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20937       };
20938     }
20939   }
20940   jresult = (void *)result;
20941   return jresult;
20942 }
20943
20944
20945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20946   void * jresult ;
20947   Dali::BaseHandle arg1 ;
20948   Dali::BaseHandle *argp1 ;
20949   Dali::Image result;
20950
20951   argp1 = (Dali::BaseHandle *)jarg1;
20952   if (!argp1) {
20953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20954     return 0;
20955   }
20956   arg1 = *argp1;
20957   {
20958     try {
20959       result = Dali::Image::DownCast(arg1);
20960     } catch (std::out_of_range& e) {
20961       {
20962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20963       };
20964     } catch (std::exception& e) {
20965       {
20966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20967       };
20968     } catch (...) {
20969       {
20970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20971       };
20972     }
20973   }
20974   jresult = new Dali::Image((const Dali::Image &)result);
20975   return jresult;
20976 }
20977
20978
20979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20980   unsigned int jresult ;
20981   Dali::Image *arg1 = (Dali::Image *) 0 ;
20982   unsigned int result;
20983
20984   arg1 = (Dali::Image *)jarg1;
20985   {
20986     try {
20987       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20988     } catch (std::out_of_range& e) {
20989       {
20990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20991       };
20992     } catch (std::exception& e) {
20993       {
20994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20995       };
20996     } catch (...) {
20997       {
20998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20999       };
21000     }
21001   }
21002   jresult = result;
21003   return jresult;
21004 }
21005
21006
21007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
21008   unsigned int jresult ;
21009   Dali::Image *arg1 = (Dali::Image *) 0 ;
21010   unsigned int result;
21011
21012   arg1 = (Dali::Image *)jarg1;
21013   {
21014     try {
21015       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
21016     } catch (std::out_of_range& e) {
21017       {
21018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21019       };
21020     } catch (std::exception& e) {
21021       {
21022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21023       };
21024     } catch (...) {
21025       {
21026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21027       };
21028     }
21029   }
21030   jresult = result;
21031   return jresult;
21032 }
21033
21034
21035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
21036   void * jresult ;
21037   Dali::Image *arg1 = (Dali::Image *) 0 ;
21038   Dali::Image::ImageSignalType *result = 0 ;
21039
21040   arg1 = (Dali::Image *)jarg1;
21041   {
21042     try {
21043       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
21044     } catch (std::out_of_range& e) {
21045       {
21046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21047       };
21048     } catch (std::exception& e) {
21049       {
21050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21051       };
21052     } catch (...) {
21053       {
21054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21055       };
21056     }
21057   }
21058   jresult = (void *)result;
21059   return jresult;
21060 }
21061
21062
21063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
21064   int jresult ;
21065   Dali::Pixel::Format result;
21066
21067   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
21068   jresult = (int)result;
21069   return jresult;
21070 }
21071
21072
21073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
21074   int jresult ;
21075   Dali::Pixel::Format result;
21076
21077   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
21078   jresult = (int)result;
21079   return jresult;
21080 }
21081
21082
21083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
21084   unsigned int jresult ;
21085   Dali::Pixel::Format arg1 ;
21086   bool result;
21087
21088   arg1 = (Dali::Pixel::Format)jarg1;
21089   {
21090     try {
21091       result = (bool)Dali::Pixel::HasAlpha(arg1);
21092     } catch (std::out_of_range& e) {
21093       {
21094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21095       };
21096     } catch (std::exception& e) {
21097       {
21098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21099       };
21100     } catch (...) {
21101       {
21102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21103       };
21104     }
21105   }
21106   jresult = result;
21107   return jresult;
21108 }
21109
21110
21111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
21112   unsigned int jresult ;
21113   Dali::Pixel::Format arg1 ;
21114   unsigned int result;
21115
21116   arg1 = (Dali::Pixel::Format)jarg1;
21117   {
21118     try {
21119       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21120     } catch (std::out_of_range& e) {
21121       {
21122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21123       };
21124     } catch (std::exception& e) {
21125       {
21126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21127       };
21128     } catch (...) {
21129       {
21130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21131       };
21132     }
21133   }
21134   jresult = result;
21135   return jresult;
21136 }
21137
21138
21139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21140   Dali::Pixel::Format arg1 ;
21141   int *arg2 = 0 ;
21142   int *arg3 = 0 ;
21143
21144   arg1 = (Dali::Pixel::Format)jarg1;
21145   arg2 = (int *)jarg2;
21146   if (!arg2) {
21147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21148     return ;
21149   }
21150   arg3 = (int *)jarg3;
21151   if (!arg3) {
21152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21153     return ;
21154   }
21155   {
21156     try {
21157       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21158     } catch (std::out_of_range& e) {
21159       {
21160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21161       };
21162     } catch (std::exception& e) {
21163       {
21164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21165       };
21166     } catch (...) {
21167       {
21168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21169       };
21170     }
21171   }
21172 }
21173
21174
21175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21176   void * jresult ;
21177   unsigned char *arg1 = (unsigned char *) 0 ;
21178   unsigned int arg2 ;
21179   unsigned int arg3 ;
21180   unsigned int arg4 ;
21181   Dali::Pixel::Format arg5 ;
21182   Dali::PixelData::ReleaseFunction arg6 ;
21183   Dali::PixelData result;
21184
21185   arg1 = jarg1;
21186   arg2 = (unsigned int)jarg2;
21187   arg3 = (unsigned int)jarg3;
21188   arg4 = (unsigned int)jarg4;
21189   arg5 = (Dali::Pixel::Format)jarg5;
21190   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21191   {
21192     try {
21193       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21194     } catch (std::out_of_range& e) {
21195       {
21196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21197       };
21198     } catch (std::exception& e) {
21199       {
21200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21201       };
21202     } catch (...) {
21203       {
21204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21205       };
21206     }
21207   }
21208   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21209
21210
21211   return jresult;
21212 }
21213
21214
21215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21216   void * jresult ;
21217   Dali::PixelData *result = 0 ;
21218
21219   {
21220     try {
21221       result = (Dali::PixelData *)new Dali::PixelData();
21222     } catch (std::out_of_range& e) {
21223       {
21224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21225       };
21226     } catch (std::exception& e) {
21227       {
21228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21229       };
21230     } catch (...) {
21231       {
21232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21233       };
21234     }
21235   }
21236   jresult = (void *)result;
21237   return jresult;
21238 }
21239
21240
21241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21242   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21243
21244   arg1 = (Dali::PixelData *)jarg1;
21245   {
21246     try {
21247       delete arg1;
21248     } catch (std::out_of_range& e) {
21249       {
21250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21251       };
21252     } catch (std::exception& e) {
21253       {
21254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21255       };
21256     } catch (...) {
21257       {
21258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21259       };
21260     }
21261   }
21262 }
21263
21264
21265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21266   void * jresult ;
21267   Dali::PixelData *arg1 = 0 ;
21268   Dali::PixelData *result = 0 ;
21269
21270   arg1 = (Dali::PixelData *)jarg1;
21271   if (!arg1) {
21272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21273     return 0;
21274   }
21275   {
21276     try {
21277       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21278     } catch (std::out_of_range& e) {
21279       {
21280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21281       };
21282     } catch (std::exception& e) {
21283       {
21284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21285       };
21286     } catch (...) {
21287       {
21288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21289       };
21290     }
21291   }
21292   jresult = (void *)result;
21293   return jresult;
21294 }
21295
21296
21297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21298   void * jresult ;
21299   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21300   Dali::PixelData *arg2 = 0 ;
21301   Dali::PixelData *result = 0 ;
21302
21303   arg1 = (Dali::PixelData *)jarg1;
21304   arg2 = (Dali::PixelData *)jarg2;
21305   if (!arg2) {
21306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21307     return 0;
21308   }
21309   {
21310     try {
21311       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21312     } catch (std::out_of_range& e) {
21313       {
21314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21315       };
21316     } catch (std::exception& e) {
21317       {
21318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21319       };
21320     } catch (...) {
21321       {
21322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21323       };
21324     }
21325   }
21326   jresult = (void *)result;
21327   return jresult;
21328 }
21329
21330
21331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21332   unsigned int jresult ;
21333   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21334   unsigned int result;
21335
21336   arg1 = (Dali::PixelData *)jarg1;
21337   {
21338     try {
21339       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21340     } catch (std::out_of_range& e) {
21341       {
21342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21343       };
21344     } catch (std::exception& e) {
21345       {
21346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21347       };
21348     } catch (...) {
21349       {
21350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21351       };
21352     }
21353   }
21354   jresult = result;
21355   return jresult;
21356 }
21357
21358
21359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21360   unsigned int jresult ;
21361   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21362   unsigned int result;
21363
21364   arg1 = (Dali::PixelData *)jarg1;
21365   {
21366     try {
21367       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21368     } catch (std::out_of_range& e) {
21369       {
21370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21371       };
21372     } catch (std::exception& e) {
21373       {
21374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21375       };
21376     } catch (...) {
21377       {
21378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21379       };
21380     }
21381   }
21382   jresult = result;
21383   return jresult;
21384 }
21385
21386
21387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21388   int jresult ;
21389   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21390   Dali::Pixel::Format result;
21391
21392   arg1 = (Dali::PixelData *)jarg1;
21393   {
21394     try {
21395       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21396     } catch (std::out_of_range& e) {
21397       {
21398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21399       };
21400     } catch (std::exception& e) {
21401       {
21402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21403       };
21404     } catch (...) {
21405       {
21406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21407       };
21408     }
21409   }
21410   jresult = (int)result;
21411   return jresult;
21412 }
21413
21414
21415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21416   unsigned int jresult ;
21417   unsigned int result;
21418
21419   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21420   jresult = result;
21421   return jresult;
21422 }
21423
21424
21425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21426   unsigned int jresult ;
21427   unsigned int result;
21428
21429   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21430   jresult = result;
21431   return jresult;
21432 }
21433
21434
21435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21436   unsigned int jresult ;
21437   unsigned int result;
21438
21439   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21440   jresult = result;
21441   return jresult;
21442 }
21443
21444
21445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21446   unsigned int jresult ;
21447   unsigned int result;
21448
21449   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21450   jresult = result;
21451   return jresult;
21452 }
21453
21454
21455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21456   unsigned int jresult ;
21457   unsigned int result;
21458
21459   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21460   jresult = result;
21461   return jresult;
21462 }
21463
21464
21465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21466   unsigned int jresult ;
21467   unsigned int result;
21468
21469   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21470   jresult = result;
21471   return jresult;
21472 }
21473
21474
21475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21476   void * jresult ;
21477   Dali::TextureType::Type arg1 ;
21478   Dali::Pixel::Format arg2 ;
21479   unsigned int arg3 ;
21480   unsigned int arg4 ;
21481   Dali::Texture result;
21482
21483   arg1 = (Dali::TextureType::Type)jarg1;
21484   arg2 = (Dali::Pixel::Format)jarg2;
21485   arg3 = (unsigned int)jarg3;
21486   arg4 = (unsigned int)jarg4;
21487   {
21488     try {
21489       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21490     } catch (std::out_of_range& e) {
21491       {
21492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21493       };
21494     } catch (std::exception& e) {
21495       {
21496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21497       };
21498     } catch (...) {
21499       {
21500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21501       };
21502     }
21503   }
21504   jresult = new Dali::Texture((const Dali::Texture &)result);
21505   return jresult;
21506 }
21507
21508
21509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21510   void * jresult ;
21511   NativeImageInterface *arg1 = 0 ;
21512   Dali::Texture result;
21513
21514   arg1 = (NativeImageInterface *)jarg1;
21515   if (!arg1) {
21516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21517     return 0;
21518   }
21519   {
21520     try {
21521       result = Dali::Texture::New(*arg1);
21522     } catch (std::out_of_range& e) {
21523       {
21524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21525       };
21526     } catch (std::exception& e) {
21527       {
21528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21529       };
21530     } catch (...) {
21531       {
21532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21533       };
21534     }
21535   }
21536   jresult = new Dali::Texture((const Dali::Texture &)result);
21537   return jresult;
21538 }
21539
21540
21541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21542   void * jresult ;
21543   Dali::Texture *result = 0 ;
21544
21545   {
21546     try {
21547       result = (Dali::Texture *)new Dali::Texture();
21548     } catch (std::out_of_range& e) {
21549       {
21550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21551       };
21552     } catch (std::exception& e) {
21553       {
21554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21555       };
21556     } catch (...) {
21557       {
21558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21559       };
21560     }
21561   }
21562   jresult = (void *)result;
21563   return jresult;
21564 }
21565
21566
21567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21568   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21569
21570   arg1 = (Dali::Texture *)jarg1;
21571   {
21572     try {
21573       delete arg1;
21574     } catch (std::out_of_range& e) {
21575       {
21576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21577       };
21578     } catch (std::exception& e) {
21579       {
21580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21581       };
21582     } catch (...) {
21583       {
21584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21585       };
21586     }
21587   }
21588 }
21589
21590
21591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21592   void * jresult ;
21593   Dali::Texture *arg1 = 0 ;
21594   Dali::Texture *result = 0 ;
21595
21596   arg1 = (Dali::Texture *)jarg1;
21597   if (!arg1) {
21598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21599     return 0;
21600   }
21601   {
21602     try {
21603       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21604     } catch (std::out_of_range& e) {
21605       {
21606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21607       };
21608     } catch (std::exception& e) {
21609       {
21610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21611       };
21612     } catch (...) {
21613       {
21614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21615       };
21616     }
21617   }
21618   jresult = (void *)result;
21619   return jresult;
21620 }
21621
21622
21623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21624   void * jresult ;
21625   Dali::BaseHandle arg1 ;
21626   Dali::BaseHandle *argp1 ;
21627   Dali::Texture result;
21628
21629   argp1 = (Dali::BaseHandle *)jarg1;
21630   if (!argp1) {
21631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21632     return 0;
21633   }
21634   arg1 = *argp1;
21635   {
21636     try {
21637       result = Dali::Texture::DownCast(arg1);
21638     } catch (std::out_of_range& e) {
21639       {
21640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21641       };
21642     } catch (std::exception& e) {
21643       {
21644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21645       };
21646     } catch (...) {
21647       {
21648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21649       };
21650     }
21651   }
21652   jresult = new Dali::Texture((const Dali::Texture &)result);
21653   return jresult;
21654 }
21655
21656
21657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21658   void * jresult ;
21659   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21660   Dali::Texture *arg2 = 0 ;
21661   Dali::Texture *result = 0 ;
21662
21663   arg1 = (Dali::Texture *)jarg1;
21664   arg2 = (Dali::Texture *)jarg2;
21665   if (!arg2) {
21666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21667     return 0;
21668   }
21669   {
21670     try {
21671       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21672     } catch (std::out_of_range& e) {
21673       {
21674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21675       };
21676     } catch (std::exception& e) {
21677       {
21678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21679       };
21680     } catch (...) {
21681       {
21682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21683       };
21684     }
21685   }
21686   jresult = (void *)result;
21687   return jresult;
21688 }
21689
21690
21691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21692   unsigned int jresult ;
21693   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21694   Dali::PixelData arg2 ;
21695   Dali::PixelData *argp2 ;
21696   bool result;
21697
21698   arg1 = (Dali::Texture *)jarg1;
21699   argp2 = (Dali::PixelData *)jarg2;
21700   if (!argp2) {
21701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21702     return 0;
21703   }
21704   arg2 = *argp2;
21705   {
21706     try {
21707       result = (bool)(arg1)->Upload(arg2);
21708     } catch (std::out_of_range& e) {
21709       {
21710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21711       };
21712     } catch (std::exception& e) {
21713       {
21714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21715       };
21716     } catch (...) {
21717       {
21718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21719       };
21720     }
21721   }
21722   jresult = result;
21723   return jresult;
21724 }
21725
21726
21727 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) {
21728   unsigned int jresult ;
21729   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21730   Dali::PixelData arg2 ;
21731   unsigned int arg3 ;
21732   unsigned int arg4 ;
21733   unsigned int arg5 ;
21734   unsigned int arg6 ;
21735   unsigned int arg7 ;
21736   unsigned int arg8 ;
21737   Dali::PixelData *argp2 ;
21738   bool result;
21739
21740   arg1 = (Dali::Texture *)jarg1;
21741   argp2 = (Dali::PixelData *)jarg2;
21742   if (!argp2) {
21743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21744     return 0;
21745   }
21746   arg2 = *argp2;
21747   arg3 = (unsigned int)jarg3;
21748   arg4 = (unsigned int)jarg4;
21749   arg5 = (unsigned int)jarg5;
21750   arg6 = (unsigned int)jarg6;
21751   arg7 = (unsigned int)jarg7;
21752   arg8 = (unsigned int)jarg8;
21753   {
21754     try {
21755       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21756     } catch (std::out_of_range& e) {
21757       {
21758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21759       };
21760     } catch (std::exception& e) {
21761       {
21762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21763       };
21764     } catch (...) {
21765       {
21766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21767       };
21768     }
21769   }
21770   jresult = result;
21771   return jresult;
21772 }
21773
21774
21775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21776   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21777
21778   arg1 = (Dali::Texture *)jarg1;
21779   {
21780     try {
21781       (arg1)->GenerateMipmaps();
21782     } catch (std::out_of_range& e) {
21783       {
21784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21785       };
21786     } catch (std::exception& e) {
21787       {
21788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21789       };
21790     } catch (...) {
21791       {
21792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21793       };
21794     }
21795   }
21796 }
21797
21798
21799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21800   unsigned int jresult ;
21801   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21802   unsigned int result;
21803
21804   arg1 = (Dali::Texture *)jarg1;
21805   {
21806     try {
21807       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21808     } catch (std::out_of_range& e) {
21809       {
21810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21811       };
21812     } catch (std::exception& e) {
21813       {
21814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21815       };
21816     } catch (...) {
21817       {
21818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21819       };
21820     }
21821   }
21822   jresult = result;
21823   return jresult;
21824 }
21825
21826
21827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21828   unsigned int jresult ;
21829   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21830   unsigned int result;
21831
21832   arg1 = (Dali::Texture *)jarg1;
21833   {
21834     try {
21835       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21836     } catch (std::out_of_range& e) {
21837       {
21838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21839       };
21840     } catch (std::exception& e) {
21841       {
21842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21843       };
21844     } catch (...) {
21845       {
21846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21847       };
21848     }
21849   }
21850   jresult = result;
21851   return jresult;
21852 }
21853
21854
21855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21856   void * jresult ;
21857   Dali::Sampler result;
21858
21859   {
21860     try {
21861       result = Dali::Sampler::New();
21862     } catch (std::out_of_range& e) {
21863       {
21864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21865       };
21866     } catch (std::exception& e) {
21867       {
21868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21869       };
21870     } catch (...) {
21871       {
21872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21873       };
21874     }
21875   }
21876   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21877   return jresult;
21878 }
21879
21880
21881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21882   void * jresult ;
21883   Dali::Sampler *result = 0 ;
21884
21885   {
21886     try {
21887       result = (Dali::Sampler *)new Dali::Sampler();
21888     } catch (std::out_of_range& e) {
21889       {
21890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21891       };
21892     } catch (std::exception& e) {
21893       {
21894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21895       };
21896     } catch (...) {
21897       {
21898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21899       };
21900     }
21901   }
21902   jresult = (void *)result;
21903   return jresult;
21904 }
21905
21906
21907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21908   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21909
21910   arg1 = (Dali::Sampler *)jarg1;
21911   {
21912     try {
21913       delete arg1;
21914     } catch (std::out_of_range& e) {
21915       {
21916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21917       };
21918     } catch (std::exception& e) {
21919       {
21920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21921       };
21922     } catch (...) {
21923       {
21924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21925       };
21926     }
21927   }
21928 }
21929
21930
21931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21932   void * jresult ;
21933   Dali::Sampler *arg1 = 0 ;
21934   Dali::Sampler *result = 0 ;
21935
21936   arg1 = (Dali::Sampler *)jarg1;
21937   if (!arg1) {
21938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21939     return 0;
21940   }
21941   {
21942     try {
21943       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21944     } catch (std::out_of_range& e) {
21945       {
21946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21947       };
21948     } catch (std::exception& e) {
21949       {
21950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21951       };
21952     } catch (...) {
21953       {
21954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21955       };
21956     }
21957   }
21958   jresult = (void *)result;
21959   return jresult;
21960 }
21961
21962
21963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21964   void * jresult ;
21965   Dali::BaseHandle arg1 ;
21966   Dali::BaseHandle *argp1 ;
21967   Dali::Sampler result;
21968
21969   argp1 = (Dali::BaseHandle *)jarg1;
21970   if (!argp1) {
21971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21972     return 0;
21973   }
21974   arg1 = *argp1;
21975   {
21976     try {
21977       result = Dali::Sampler::DownCast(arg1);
21978     } catch (std::out_of_range& e) {
21979       {
21980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21981       };
21982     } catch (std::exception& e) {
21983       {
21984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21985       };
21986     } catch (...) {
21987       {
21988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21989       };
21990     }
21991   }
21992   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21993   return jresult;
21994 }
21995
21996
21997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21998   void * jresult ;
21999   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22000   Dali::Sampler *arg2 = 0 ;
22001   Dali::Sampler *result = 0 ;
22002
22003   arg1 = (Dali::Sampler *)jarg1;
22004   arg2 = (Dali::Sampler *)jarg2;
22005   if (!arg2) {
22006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
22007     return 0;
22008   }
22009   {
22010     try {
22011       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
22012     } catch (std::out_of_range& e) {
22013       {
22014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22015       };
22016     } catch (std::exception& e) {
22017       {
22018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22019       };
22020     } catch (...) {
22021       {
22022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22023       };
22024     }
22025   }
22026   jresult = (void *)result;
22027   return jresult;
22028 }
22029
22030
22031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
22032   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22033   Dali::FilterMode::Type arg2 ;
22034   Dali::FilterMode::Type arg3 ;
22035
22036   arg1 = (Dali::Sampler *)jarg1;
22037   arg2 = (Dali::FilterMode::Type)jarg2;
22038   arg3 = (Dali::FilterMode::Type)jarg3;
22039   {
22040     try {
22041       (arg1)->SetFilterMode(arg2,arg3);
22042     } catch (std::out_of_range& e) {
22043       {
22044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22045       };
22046     } catch (std::exception& e) {
22047       {
22048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22049       };
22050     } catch (...) {
22051       {
22052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22053       };
22054     }
22055   }
22056 }
22057
22058
22059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
22060   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22061   Dali::WrapMode::Type arg2 ;
22062   Dali::WrapMode::Type arg3 ;
22063
22064   arg1 = (Dali::Sampler *)jarg1;
22065   arg2 = (Dali::WrapMode::Type)jarg2;
22066   arg3 = (Dali::WrapMode::Type)jarg3;
22067   {
22068     try {
22069       (arg1)->SetWrapMode(arg2,arg3);
22070     } catch (std::out_of_range& e) {
22071       {
22072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22073       };
22074     } catch (std::exception& e) {
22075       {
22076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22077       };
22078     } catch (...) {
22079       {
22080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22081       };
22082     }
22083   }
22084 }
22085
22086
22087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
22088   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22089   Dali::WrapMode::Type arg2 ;
22090   Dali::WrapMode::Type arg3 ;
22091   Dali::WrapMode::Type arg4 ;
22092
22093   arg1 = (Dali::Sampler *)jarg1;
22094   arg2 = (Dali::WrapMode::Type)jarg2;
22095   arg3 = (Dali::WrapMode::Type)jarg3;
22096   arg4 = (Dali::WrapMode::Type)jarg4;
22097   {
22098     try {
22099       (arg1)->SetWrapMode(arg2,arg3,arg4);
22100     } catch (std::out_of_range& e) {
22101       {
22102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22103       };
22104     } catch (std::exception& e) {
22105       {
22106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22107       };
22108     } catch (...) {
22109       {
22110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22111       };
22112     }
22113   }
22114 }
22115
22116
22117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22118   void * jresult ;
22119   Dali::TextureSet result;
22120
22121   {
22122     try {
22123       result = Dali::TextureSet::New();
22124     } catch (std::out_of_range& e) {
22125       {
22126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22127       };
22128     } catch (std::exception& e) {
22129       {
22130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22131       };
22132     } catch (...) {
22133       {
22134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22135       };
22136     }
22137   }
22138   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22139   return jresult;
22140 }
22141
22142
22143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22144   void * jresult ;
22145   Dali::TextureSet *result = 0 ;
22146
22147   {
22148     try {
22149       result = (Dali::TextureSet *)new Dali::TextureSet();
22150     } catch (std::out_of_range& e) {
22151       {
22152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22153       };
22154     } catch (std::exception& e) {
22155       {
22156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22157       };
22158     } catch (...) {
22159       {
22160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22161       };
22162     }
22163   }
22164   jresult = (void *)result;
22165   return jresult;
22166 }
22167
22168
22169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22170   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22171
22172   arg1 = (Dali::TextureSet *)jarg1;
22173   {
22174     try {
22175       delete arg1;
22176     } catch (std::out_of_range& e) {
22177       {
22178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22179       };
22180     } catch (std::exception& e) {
22181       {
22182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22183       };
22184     } catch (...) {
22185       {
22186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22187       };
22188     }
22189   }
22190 }
22191
22192
22193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22194   void * jresult ;
22195   Dali::TextureSet *arg1 = 0 ;
22196   Dali::TextureSet *result = 0 ;
22197
22198   arg1 = (Dali::TextureSet *)jarg1;
22199   if (!arg1) {
22200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22201     return 0;
22202   }
22203   {
22204     try {
22205       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22206     } catch (std::out_of_range& e) {
22207       {
22208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22209       };
22210     } catch (std::exception& e) {
22211       {
22212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22213       };
22214     } catch (...) {
22215       {
22216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22217       };
22218     }
22219   }
22220   jresult = (void *)result;
22221   return jresult;
22222 }
22223
22224
22225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22226   void * jresult ;
22227   Dali::BaseHandle arg1 ;
22228   Dali::BaseHandle *argp1 ;
22229   Dali::TextureSet result;
22230
22231   argp1 = (Dali::BaseHandle *)jarg1;
22232   if (!argp1) {
22233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22234     return 0;
22235   }
22236   arg1 = *argp1;
22237   {
22238     try {
22239       result = Dali::TextureSet::DownCast(arg1);
22240     } catch (std::out_of_range& e) {
22241       {
22242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22243       };
22244     } catch (std::exception& e) {
22245       {
22246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22247       };
22248     } catch (...) {
22249       {
22250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22251       };
22252     }
22253   }
22254   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22255   return jresult;
22256 }
22257
22258
22259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22260   void * jresult ;
22261   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22262   Dali::TextureSet *arg2 = 0 ;
22263   Dali::TextureSet *result = 0 ;
22264
22265   arg1 = (Dali::TextureSet *)jarg1;
22266   arg2 = (Dali::TextureSet *)jarg2;
22267   if (!arg2) {
22268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22269     return 0;
22270   }
22271   {
22272     try {
22273       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22274     } catch (std::out_of_range& e) {
22275       {
22276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22277       };
22278     } catch (std::exception& e) {
22279       {
22280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22281       };
22282     } catch (...) {
22283       {
22284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22285       };
22286     }
22287   }
22288   jresult = (void *)result;
22289   return jresult;
22290 }
22291
22292
22293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22294   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22295   size_t arg2 ;
22296   Dali::Texture arg3 ;
22297   Dali::Texture *argp3 ;
22298
22299   arg1 = (Dali::TextureSet *)jarg1;
22300   arg2 = (size_t)jarg2;
22301   argp3 = (Dali::Texture *)jarg3;
22302   if (!argp3) {
22303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22304     return ;
22305   }
22306   arg3 = *argp3;
22307   {
22308     try {
22309       (arg1)->SetTexture(arg2,arg3);
22310     } catch (std::out_of_range& e) {
22311       {
22312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22313       };
22314     } catch (std::exception& e) {
22315       {
22316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22317       };
22318     } catch (...) {
22319       {
22320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22321       };
22322     }
22323   }
22324 }
22325
22326
22327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22328   void * jresult ;
22329   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22330   size_t arg2 ;
22331   Dali::Texture result;
22332
22333   arg1 = (Dali::TextureSet *)jarg1;
22334   arg2 = (size_t)jarg2;
22335   {
22336     try {
22337       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22338     } catch (std::out_of_range& e) {
22339       {
22340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22341       };
22342     } catch (std::exception& e) {
22343       {
22344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22345       };
22346     } catch (...) {
22347       {
22348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22349       };
22350     }
22351   }
22352   jresult = new Dali::Texture((const Dali::Texture &)result);
22353   return jresult;
22354 }
22355
22356
22357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22358   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22359   size_t arg2 ;
22360   Dali::Sampler arg3 ;
22361   Dali::Sampler *argp3 ;
22362
22363   arg1 = (Dali::TextureSet *)jarg1;
22364   arg2 = (size_t)jarg2;
22365   argp3 = (Dali::Sampler *)jarg3;
22366   if (!argp3) {
22367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22368     return ;
22369   }
22370   arg3 = *argp3;
22371   {
22372     try {
22373       (arg1)->SetSampler(arg2,arg3);
22374     } catch (std::out_of_range& e) {
22375       {
22376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22377       };
22378     } catch (std::exception& e) {
22379       {
22380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22381       };
22382     } catch (...) {
22383       {
22384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22385       };
22386     }
22387   }
22388 }
22389
22390
22391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22392   void * jresult ;
22393   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22394   size_t arg2 ;
22395   Dali::Sampler result;
22396
22397   arg1 = (Dali::TextureSet *)jarg1;
22398   arg2 = (size_t)jarg2;
22399   {
22400     try {
22401       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22402     } catch (std::out_of_range& e) {
22403       {
22404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22405       };
22406     } catch (std::exception& e) {
22407       {
22408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22409       };
22410     } catch (...) {
22411       {
22412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22413       };
22414     }
22415   }
22416   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22417   return jresult;
22418 }
22419
22420
22421 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22422   unsigned long jresult ;
22423   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22424   size_t result;
22425
22426   arg1 = (Dali::TextureSet *)jarg1;
22427   {
22428     try {
22429       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22430     } catch (std::out_of_range& e) {
22431       {
22432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22433       };
22434     } catch (std::exception& e) {
22435       {
22436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22437       };
22438     } catch (...) {
22439       {
22440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22441       };
22442     }
22443   }
22444   jresult = (unsigned long)result;
22445   return jresult;
22446 }
22447
22448
22449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22450   void * jresult ;
22451   Dali::Property::Map *arg1 = 0 ;
22452   Dali::PropertyBuffer result;
22453
22454   arg1 = (Dali::Property::Map *)jarg1;
22455   if (!arg1) {
22456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22457     return 0;
22458   }
22459   {
22460     try {
22461       result = Dali::PropertyBuffer::New(*arg1);
22462     } catch (std::out_of_range& e) {
22463       {
22464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22465       };
22466     } catch (std::exception& e) {
22467       {
22468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22469       };
22470     } catch (...) {
22471       {
22472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22473       };
22474     }
22475   }
22476   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22477   return jresult;
22478 }
22479
22480
22481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22482   void * jresult ;
22483   Dali::PropertyBuffer *result = 0 ;
22484
22485   {
22486     try {
22487       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22488     } catch (std::out_of_range& e) {
22489       {
22490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22491       };
22492     } catch (std::exception& e) {
22493       {
22494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22495       };
22496     } catch (...) {
22497       {
22498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22499       };
22500     }
22501   }
22502   jresult = (void *)result;
22503   return jresult;
22504 }
22505
22506
22507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22508   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22509
22510   arg1 = (Dali::PropertyBuffer *)jarg1;
22511   {
22512     try {
22513       delete arg1;
22514     } catch (std::out_of_range& e) {
22515       {
22516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22517       };
22518     } catch (std::exception& e) {
22519       {
22520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22521       };
22522     } catch (...) {
22523       {
22524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22525       };
22526     }
22527   }
22528 }
22529
22530
22531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22532   void * jresult ;
22533   Dali::PropertyBuffer *arg1 = 0 ;
22534   Dali::PropertyBuffer *result = 0 ;
22535
22536   arg1 = (Dali::PropertyBuffer *)jarg1;
22537   if (!arg1) {
22538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22539     return 0;
22540   }
22541   {
22542     try {
22543       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22544     } catch (std::out_of_range& e) {
22545       {
22546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22547       };
22548     } catch (std::exception& e) {
22549       {
22550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22551       };
22552     } catch (...) {
22553       {
22554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22555       };
22556     }
22557   }
22558   jresult = (void *)result;
22559   return jresult;
22560 }
22561
22562
22563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22564   void * jresult ;
22565   Dali::BaseHandle arg1 ;
22566   Dali::BaseHandle *argp1 ;
22567   Dali::PropertyBuffer result;
22568
22569   argp1 = (Dali::BaseHandle *)jarg1;
22570   if (!argp1) {
22571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22572     return 0;
22573   }
22574   arg1 = *argp1;
22575   {
22576     try {
22577       result = Dali::PropertyBuffer::DownCast(arg1);
22578     } catch (std::out_of_range& e) {
22579       {
22580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22581       };
22582     } catch (std::exception& e) {
22583       {
22584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22585       };
22586     } catch (...) {
22587       {
22588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22589       };
22590     }
22591   }
22592   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22593   return jresult;
22594 }
22595
22596
22597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22598   void * jresult ;
22599   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22600   Dali::PropertyBuffer *arg2 = 0 ;
22601   Dali::PropertyBuffer *result = 0 ;
22602
22603   arg1 = (Dali::PropertyBuffer *)jarg1;
22604   arg2 = (Dali::PropertyBuffer *)jarg2;
22605   if (!arg2) {
22606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22607     return 0;
22608   }
22609   {
22610     try {
22611       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22612     } catch (std::out_of_range& e) {
22613       {
22614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22615       };
22616     } catch (std::exception& e) {
22617       {
22618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22619       };
22620     } catch (...) {
22621       {
22622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22623       };
22624     }
22625   }
22626   jresult = (void *)result;
22627   return jresult;
22628 }
22629
22630
22631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22632   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22633   void *arg2 = (void *) 0 ;
22634   std::size_t arg3 ;
22635
22636   arg1 = (Dali::PropertyBuffer *)jarg1;
22637   arg2 = jarg2;
22638   arg3 = (std::size_t)jarg3;
22639   {
22640     try {
22641       (arg1)->SetData((void const *)arg2,arg3);
22642     } catch (std::out_of_range& e) {
22643       {
22644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22645       };
22646     } catch (std::exception& e) {
22647       {
22648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22649       };
22650     } catch (...) {
22651       {
22652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22653       };
22654     }
22655   }
22656 }
22657
22658
22659 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22660   unsigned long jresult ;
22661   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22662   std::size_t result;
22663
22664   arg1 = (Dali::PropertyBuffer *)jarg1;
22665   {
22666     try {
22667       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22668     } catch (std::out_of_range& e) {
22669       {
22670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22671       };
22672     } catch (std::exception& e) {
22673       {
22674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22675       };
22676     } catch (...) {
22677       {
22678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22679       };
22680     }
22681   }
22682   jresult = (unsigned long)result;
22683   return jresult;
22684 }
22685
22686
22687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22688   void * jresult ;
22689   Dali::Geometry result;
22690
22691   {
22692     try {
22693       result = Dali::Geometry::New();
22694     } catch (std::out_of_range& e) {
22695       {
22696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22697       };
22698     } catch (std::exception& e) {
22699       {
22700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22701       };
22702     } catch (...) {
22703       {
22704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22705       };
22706     }
22707   }
22708   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22709   return jresult;
22710 }
22711
22712
22713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22714   void * jresult ;
22715   Dali::Geometry *result = 0 ;
22716
22717   {
22718     try {
22719       result = (Dali::Geometry *)new Dali::Geometry();
22720     } catch (std::out_of_range& e) {
22721       {
22722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22723       };
22724     } catch (std::exception& e) {
22725       {
22726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22727       };
22728     } catch (...) {
22729       {
22730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22731       };
22732     }
22733   }
22734   jresult = (void *)result;
22735   return jresult;
22736 }
22737
22738
22739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22740   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22741
22742   arg1 = (Dali::Geometry *)jarg1;
22743   {
22744     try {
22745       delete arg1;
22746     } catch (std::out_of_range& e) {
22747       {
22748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22749       };
22750     } catch (std::exception& e) {
22751       {
22752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22753       };
22754     } catch (...) {
22755       {
22756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22757       };
22758     }
22759   }
22760 }
22761
22762
22763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22764   void * jresult ;
22765   Dali::Geometry *arg1 = 0 ;
22766   Dali::Geometry *result = 0 ;
22767
22768   arg1 = (Dali::Geometry *)jarg1;
22769   if (!arg1) {
22770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22771     return 0;
22772   }
22773   {
22774     try {
22775       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22776     } catch (std::out_of_range& e) {
22777       {
22778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22779       };
22780     } catch (std::exception& e) {
22781       {
22782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22783       };
22784     } catch (...) {
22785       {
22786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22787       };
22788     }
22789   }
22790   jresult = (void *)result;
22791   return jresult;
22792 }
22793
22794
22795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22796   void * jresult ;
22797   Dali::BaseHandle arg1 ;
22798   Dali::BaseHandle *argp1 ;
22799   Dali::Geometry result;
22800
22801   argp1 = (Dali::BaseHandle *)jarg1;
22802   if (!argp1) {
22803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22804     return 0;
22805   }
22806   arg1 = *argp1;
22807   {
22808     try {
22809       result = Dali::Geometry::DownCast(arg1);
22810     } catch (std::out_of_range& e) {
22811       {
22812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22813       };
22814     } catch (std::exception& e) {
22815       {
22816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22817       };
22818     } catch (...) {
22819       {
22820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22821       };
22822     }
22823   }
22824   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22825   return jresult;
22826 }
22827
22828
22829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22830   void * jresult ;
22831   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22832   Dali::Geometry *arg2 = 0 ;
22833   Dali::Geometry *result = 0 ;
22834
22835   arg1 = (Dali::Geometry *)jarg1;
22836   arg2 = (Dali::Geometry *)jarg2;
22837   if (!arg2) {
22838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22839     return 0;
22840   }
22841   {
22842     try {
22843       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22844     } catch (std::out_of_range& e) {
22845       {
22846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22847       };
22848     } catch (std::exception& e) {
22849       {
22850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22851       };
22852     } catch (...) {
22853       {
22854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22855       };
22856     }
22857   }
22858   jresult = (void *)result;
22859   return jresult;
22860 }
22861
22862
22863 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22864   unsigned long jresult ;
22865   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22866   Dali::PropertyBuffer *arg2 = 0 ;
22867   std::size_t result;
22868
22869   arg1 = (Dali::Geometry *)jarg1;
22870   arg2 = (Dali::PropertyBuffer *)jarg2;
22871   if (!arg2) {
22872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22873     return 0;
22874   }
22875   {
22876     try {
22877       result = (arg1)->AddVertexBuffer(*arg2);
22878     } catch (std::out_of_range& e) {
22879       {
22880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22881       };
22882     } catch (std::exception& e) {
22883       {
22884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22885       };
22886     } catch (...) {
22887       {
22888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22889       };
22890     }
22891   }
22892   jresult = (unsigned long)result;
22893   return jresult;
22894 }
22895
22896
22897 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22898   unsigned long jresult ;
22899   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22900   std::size_t result;
22901
22902   arg1 = (Dali::Geometry *)jarg1;
22903   {
22904     try {
22905       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22906     } catch (std::out_of_range& e) {
22907       {
22908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22909       };
22910     } catch (std::exception& e) {
22911       {
22912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22913       };
22914     } catch (...) {
22915       {
22916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22917       };
22918     }
22919   }
22920   jresult = (unsigned long)result;
22921   return jresult;
22922 }
22923
22924
22925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22926   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22927   std::size_t arg2 ;
22928
22929   arg1 = (Dali::Geometry *)jarg1;
22930   arg2 = (std::size_t)jarg2;
22931   {
22932     try {
22933       (arg1)->RemoveVertexBuffer(arg2);
22934     } catch (std::out_of_range& e) {
22935       {
22936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22937       };
22938     } catch (std::exception& e) {
22939       {
22940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22941       };
22942     } catch (...) {
22943       {
22944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22945       };
22946     }
22947   }
22948 }
22949
22950
22951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22952   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22953   unsigned short *arg2 = (unsigned short *) 0 ;
22954   size_t arg3 ;
22955
22956   arg1 = (Dali::Geometry *)jarg1;
22957   arg2 = jarg2;
22958   arg3 = (size_t)jarg3;
22959   {
22960     try {
22961       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22962     } catch (std::out_of_range& e) {
22963       {
22964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22965       };
22966     } catch (std::exception& e) {
22967       {
22968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22969       };
22970     } catch (...) {
22971       {
22972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22973       };
22974     }
22975   }
22976
22977
22978 }
22979
22980
22981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22982   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22983   Dali::Geometry::Type arg2 ;
22984
22985   arg1 = (Dali::Geometry *)jarg1;
22986   arg2 = (Dali::Geometry::Type)jarg2;
22987   {
22988     try {
22989       (arg1)->SetType(arg2);
22990     } catch (std::out_of_range& e) {
22991       {
22992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22993       };
22994     } catch (std::exception& e) {
22995       {
22996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22997       };
22998     } catch (...) {
22999       {
23000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23001       };
23002     }
23003   }
23004 }
23005
23006
23007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
23008   int jresult ;
23009   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
23010   Dali::Geometry::Type result;
23011
23012   arg1 = (Dali::Geometry *)jarg1;
23013   {
23014     try {
23015       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
23016     } catch (std::out_of_range& e) {
23017       {
23018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23019       };
23020     } catch (std::exception& e) {
23021       {
23022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23023       };
23024     } catch (...) {
23025       {
23026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23027       };
23028     }
23029   }
23030   jresult = (int)result;
23031   return jresult;
23032 }
23033
23034
23035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
23036   void * jresult ;
23037   Dali::Shader::Hint *result = 0 ;
23038
23039   {
23040     try {
23041       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
23042     } catch (std::out_of_range& e) {
23043       {
23044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23045       };
23046     } catch (std::exception& e) {
23047       {
23048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23049       };
23050     } catch (...) {
23051       {
23052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23053       };
23054     }
23055   }
23056   jresult = (void *)result;
23057   return jresult;
23058 }
23059
23060
23061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
23062   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
23063
23064   arg1 = (Dali::Shader::Hint *)jarg1;
23065   {
23066     try {
23067       delete arg1;
23068     } catch (std::out_of_range& e) {
23069       {
23070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23071       };
23072     } catch (std::exception& e) {
23073       {
23074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23075       };
23076     } catch (...) {
23077       {
23078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23079       };
23080     }
23081   }
23082 }
23083
23084
23085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
23086   int jresult ;
23087   int result;
23088
23089   result = (int)Dali::Shader::Property::PROGRAM;
23090   jresult = (int)result;
23091   return jresult;
23092 }
23093
23094
23095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23096   void * jresult ;
23097   Dali::Shader::Property *result = 0 ;
23098
23099   {
23100     try {
23101       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23102     } catch (std::out_of_range& e) {
23103       {
23104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23105       };
23106     } catch (std::exception& e) {
23107       {
23108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23109       };
23110     } catch (...) {
23111       {
23112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23113       };
23114     }
23115   }
23116   jresult = (void *)result;
23117   return jresult;
23118 }
23119
23120
23121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23122   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23123
23124   arg1 = (Dali::Shader::Property *)jarg1;
23125   {
23126     try {
23127       delete arg1;
23128     } catch (std::out_of_range& e) {
23129       {
23130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23131       };
23132     } catch (std::exception& e) {
23133       {
23134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23135       };
23136     } catch (...) {
23137       {
23138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23139       };
23140     }
23141   }
23142 }
23143
23144
23145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23146   void * jresult ;
23147   std::string *arg1 = 0 ;
23148   std::string *arg2 = 0 ;
23149   Dali::Shader::Hint::Value arg3 ;
23150   Dali::Shader result;
23151
23152   if (!jarg1) {
23153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23154     return 0;
23155   }
23156   std::string arg1_str(jarg1);
23157   arg1 = &arg1_str;
23158   if (!jarg2) {
23159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23160     return 0;
23161   }
23162   std::string arg2_str(jarg2);
23163   arg2 = &arg2_str;
23164   arg3 = (Dali::Shader::Hint::Value)jarg3;
23165   {
23166     try {
23167       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23168     } catch (std::out_of_range& e) {
23169       {
23170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23171       };
23172     } catch (std::exception& e) {
23173       {
23174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23175       };
23176     } catch (...) {
23177       {
23178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23179       };
23180     }
23181   }
23182   jresult = new Dali::Shader((const Dali::Shader &)result);
23183
23184   //argout typemap for const std::string&
23185
23186
23187   //argout typemap for const std::string&
23188
23189   return jresult;
23190 }
23191
23192
23193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23194   void * jresult ;
23195   std::string *arg1 = 0 ;
23196   std::string *arg2 = 0 ;
23197   Dali::Shader result;
23198
23199   if (!jarg1) {
23200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23201     return 0;
23202   }
23203   std::string arg1_str(jarg1);
23204   arg1 = &arg1_str;
23205   if (!jarg2) {
23206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23207     return 0;
23208   }
23209   std::string arg2_str(jarg2);
23210   arg2 = &arg2_str;
23211   {
23212     try {
23213       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23214     } catch (std::out_of_range& e) {
23215       {
23216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23217       };
23218     } catch (std::exception& e) {
23219       {
23220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23221       };
23222     } catch (...) {
23223       {
23224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23225       };
23226     }
23227   }
23228   jresult = new Dali::Shader((const Dali::Shader &)result);
23229
23230   //argout typemap for const std::string&
23231
23232
23233   //argout typemap for const std::string&
23234
23235   return jresult;
23236 }
23237
23238
23239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23240   void * jresult ;
23241   Dali::Shader *result = 0 ;
23242
23243   {
23244     try {
23245       result = (Dali::Shader *)new Dali::Shader();
23246     } catch (std::out_of_range& e) {
23247       {
23248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23249       };
23250     } catch (std::exception& e) {
23251       {
23252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23253       };
23254     } catch (...) {
23255       {
23256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23257       };
23258     }
23259   }
23260   jresult = (void *)result;
23261   return jresult;
23262 }
23263
23264
23265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23266   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23267
23268   arg1 = (Dali::Shader *)jarg1;
23269   {
23270     try {
23271       delete arg1;
23272     } catch (std::out_of_range& e) {
23273       {
23274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23275       };
23276     } catch (std::exception& e) {
23277       {
23278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23279       };
23280     } catch (...) {
23281       {
23282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23283       };
23284     }
23285   }
23286 }
23287
23288
23289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23290   void * jresult ;
23291   Dali::Shader *arg1 = 0 ;
23292   Dali::Shader *result = 0 ;
23293
23294   arg1 = (Dali::Shader *)jarg1;
23295   if (!arg1) {
23296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23297     return 0;
23298   }
23299   {
23300     try {
23301       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23302     } catch (std::out_of_range& e) {
23303       {
23304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23305       };
23306     } catch (std::exception& e) {
23307       {
23308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23309       };
23310     } catch (...) {
23311       {
23312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23313       };
23314     }
23315   }
23316   jresult = (void *)result;
23317   return jresult;
23318 }
23319
23320
23321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23322   void * jresult ;
23323   Dali::BaseHandle arg1 ;
23324   Dali::BaseHandle *argp1 ;
23325   Dali::Shader result;
23326
23327   argp1 = (Dali::BaseHandle *)jarg1;
23328   if (!argp1) {
23329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23330     return 0;
23331   }
23332   arg1 = *argp1;
23333   {
23334     try {
23335       result = Dali::Shader::DownCast(arg1);
23336     } catch (std::out_of_range& e) {
23337       {
23338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23339       };
23340     } catch (std::exception& e) {
23341       {
23342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23343       };
23344     } catch (...) {
23345       {
23346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23347       };
23348     }
23349   }
23350   jresult = new Dali::Shader((const Dali::Shader &)result);
23351   return jresult;
23352 }
23353
23354
23355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23356   void * jresult ;
23357   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23358   Dali::Shader *arg2 = 0 ;
23359   Dali::Shader *result = 0 ;
23360
23361   arg1 = (Dali::Shader *)jarg1;
23362   arg2 = (Dali::Shader *)jarg2;
23363   if (!arg2) {
23364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23365     return 0;
23366   }
23367   {
23368     try {
23369       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23370     } catch (std::out_of_range& e) {
23371       {
23372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23373       };
23374     } catch (std::exception& e) {
23375       {
23376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23377       };
23378     } catch (...) {
23379       {
23380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23381       };
23382     }
23383   }
23384   jresult = (void *)result;
23385   return jresult;
23386 }
23387
23388
23389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23390   int jresult ;
23391   int result;
23392
23393   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23394   jresult = (int)result;
23395   return jresult;
23396 }
23397
23398
23399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23400   int jresult ;
23401   int result;
23402
23403   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23404   jresult = (int)result;
23405   return jresult;
23406 }
23407
23408
23409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23410   int jresult ;
23411   int result;
23412
23413   result = (int)Dali::Renderer::Property::BLEND_MODE;
23414   jresult = (int)result;
23415   return jresult;
23416 }
23417
23418
23419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23420   int jresult ;
23421   int result;
23422
23423   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23424   jresult = (int)result;
23425   return jresult;
23426 }
23427
23428
23429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23430   int jresult ;
23431   int result;
23432
23433   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23434   jresult = (int)result;
23435   return jresult;
23436 }
23437
23438
23439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23440   int jresult ;
23441   int result;
23442
23443   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23444   jresult = (int)result;
23445   return jresult;
23446 }
23447
23448
23449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23450   int jresult ;
23451   int result;
23452
23453   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23454   jresult = (int)result;
23455   return jresult;
23456 }
23457
23458
23459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23460   int jresult ;
23461   int result;
23462
23463   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23464   jresult = (int)result;
23465   return jresult;
23466 }
23467
23468
23469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23470   int jresult ;
23471   int result;
23472
23473   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23474   jresult = (int)result;
23475   return jresult;
23476 }
23477
23478
23479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23480   int jresult ;
23481   int result;
23482
23483   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23484   jresult = (int)result;
23485   return jresult;
23486 }
23487
23488
23489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23490   int jresult ;
23491   int result;
23492
23493   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23494   jresult = (int)result;
23495   return jresult;
23496 }
23497
23498
23499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23500   int jresult ;
23501   int result;
23502
23503   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23504   jresult = (int)result;
23505   return jresult;
23506 }
23507
23508
23509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23510   int jresult ;
23511   int result;
23512
23513   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23514   jresult = (int)result;
23515   return jresult;
23516 }
23517
23518
23519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23520   int jresult ;
23521   int result;
23522
23523   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23524   jresult = (int)result;
23525   return jresult;
23526 }
23527
23528
23529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23530   int jresult ;
23531   int result;
23532
23533   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23534   jresult = (int)result;
23535   return jresult;
23536 }
23537
23538
23539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23540   int jresult ;
23541   int result;
23542
23543   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23544   jresult = (int)result;
23545   return jresult;
23546 }
23547
23548
23549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23550   int jresult ;
23551   int result;
23552
23553   result = (int)Dali::Renderer::Property::RENDER_MODE;
23554   jresult = (int)result;
23555   return jresult;
23556 }
23557
23558
23559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23560   int jresult ;
23561   int result;
23562
23563   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23564   jresult = (int)result;
23565   return jresult;
23566 }
23567
23568
23569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23570   int jresult ;
23571   int result;
23572
23573   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23574   jresult = (int)result;
23575   return jresult;
23576 }
23577
23578
23579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23580   int jresult ;
23581   int result;
23582
23583   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23584   jresult = (int)result;
23585   return jresult;
23586 }
23587
23588
23589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23590   int jresult ;
23591   int result;
23592
23593   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23594   jresult = (int)result;
23595   return jresult;
23596 }
23597
23598
23599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23600   int jresult ;
23601   int result;
23602
23603   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23604   jresult = (int)result;
23605   return jresult;
23606 }
23607
23608
23609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23610   int jresult ;
23611   int result;
23612
23613   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23614   jresult = (int)result;
23615   return jresult;
23616 }
23617
23618
23619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23620   int jresult ;
23621   int result;
23622
23623   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23624   jresult = (int)result;
23625   return jresult;
23626 }
23627
23628
23629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23630   void * jresult ;
23631   Dali::Renderer::Property *result = 0 ;
23632
23633   {
23634     try {
23635       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23636     } catch (std::out_of_range& e) {
23637       {
23638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23639       };
23640     } catch (std::exception& e) {
23641       {
23642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23643       };
23644     } catch (...) {
23645       {
23646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23647       };
23648     }
23649   }
23650   jresult = (void *)result;
23651   return jresult;
23652 }
23653
23654
23655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23656   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23657
23658   arg1 = (Dali::Renderer::Property *)jarg1;
23659   {
23660     try {
23661       delete arg1;
23662     } catch (std::out_of_range& e) {
23663       {
23664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23665       };
23666     } catch (std::exception& e) {
23667       {
23668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23669       };
23670     } catch (...) {
23671       {
23672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23673       };
23674     }
23675   }
23676 }
23677
23678
23679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23680   void * jresult ;
23681   Dali::Geometry *arg1 = 0 ;
23682   Dali::Shader *arg2 = 0 ;
23683   Dali::Renderer result;
23684
23685   arg1 = (Dali::Geometry *)jarg1;
23686   if (!arg1) {
23687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23688     return 0;
23689   }
23690   arg2 = (Dali::Shader *)jarg2;
23691   if (!arg2) {
23692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23693     return 0;
23694   }
23695   {
23696     try {
23697       result = Dali::Renderer::New(*arg1,*arg2);
23698     } catch (std::out_of_range& e) {
23699       {
23700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23701       };
23702     } catch (std::exception& e) {
23703       {
23704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23705       };
23706     } catch (...) {
23707       {
23708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23709       };
23710     }
23711   }
23712   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23713   return jresult;
23714 }
23715
23716
23717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23718   void * jresult ;
23719   Dali::Renderer *result = 0 ;
23720
23721   {
23722     try {
23723       result = (Dali::Renderer *)new Dali::Renderer();
23724     } catch (std::out_of_range& e) {
23725       {
23726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23727       };
23728     } catch (std::exception& e) {
23729       {
23730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23731       };
23732     } catch (...) {
23733       {
23734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23735       };
23736     }
23737   }
23738   jresult = (void *)result;
23739   return jresult;
23740 }
23741
23742
23743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23744   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23745
23746   arg1 = (Dali::Renderer *)jarg1;
23747   {
23748     try {
23749       delete arg1;
23750     } catch (std::out_of_range& e) {
23751       {
23752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23753       };
23754     } catch (std::exception& e) {
23755       {
23756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23757       };
23758     } catch (...) {
23759       {
23760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23761       };
23762     }
23763   }
23764 }
23765
23766
23767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23768   void * jresult ;
23769   Dali::Renderer *arg1 = 0 ;
23770   Dali::Renderer *result = 0 ;
23771
23772   arg1 = (Dali::Renderer *)jarg1;
23773   if (!arg1) {
23774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23775     return 0;
23776   }
23777   {
23778     try {
23779       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23780     } catch (std::out_of_range& e) {
23781       {
23782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23783       };
23784     } catch (std::exception& e) {
23785       {
23786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23787       };
23788     } catch (...) {
23789       {
23790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23791       };
23792     }
23793   }
23794   jresult = (void *)result;
23795   return jresult;
23796 }
23797
23798
23799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23800   void * jresult ;
23801   Dali::BaseHandle arg1 ;
23802   Dali::BaseHandle *argp1 ;
23803   Dali::Renderer result;
23804
23805   argp1 = (Dali::BaseHandle *)jarg1;
23806   if (!argp1) {
23807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23808     return 0;
23809   }
23810   arg1 = *argp1;
23811   {
23812     try {
23813       result = Dali::Renderer::DownCast(arg1);
23814     } catch (std::out_of_range& e) {
23815       {
23816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23817       };
23818     } catch (std::exception& e) {
23819       {
23820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23821       };
23822     } catch (...) {
23823       {
23824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23825       };
23826     }
23827   }
23828   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23829   return jresult;
23830 }
23831
23832
23833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23834   void * jresult ;
23835   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23836   Dali::Renderer *arg2 = 0 ;
23837   Dali::Renderer *result = 0 ;
23838
23839   arg1 = (Dali::Renderer *)jarg1;
23840   arg2 = (Dali::Renderer *)jarg2;
23841   if (!arg2) {
23842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23843     return 0;
23844   }
23845   {
23846     try {
23847       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23848     } catch (std::out_of_range& e) {
23849       {
23850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23851       };
23852     } catch (std::exception& e) {
23853       {
23854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23855       };
23856     } catch (...) {
23857       {
23858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23859       };
23860     }
23861   }
23862   jresult = (void *)result;
23863   return jresult;
23864 }
23865
23866
23867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23868   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23869   Dali::Geometry *arg2 = 0 ;
23870
23871   arg1 = (Dali::Renderer *)jarg1;
23872   arg2 = (Dali::Geometry *)jarg2;
23873   if (!arg2) {
23874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23875     return ;
23876   }
23877   {
23878     try {
23879       (arg1)->SetGeometry(*arg2);
23880     } catch (std::out_of_range& e) {
23881       {
23882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23883       };
23884     } catch (std::exception& e) {
23885       {
23886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23887       };
23888     } catch (...) {
23889       {
23890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23891       };
23892     }
23893   }
23894 }
23895
23896
23897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23898   void * jresult ;
23899   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23900   Dali::Geometry result;
23901
23902   arg1 = (Dali::Renderer *)jarg1;
23903   {
23904     try {
23905       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23906     } catch (std::out_of_range& e) {
23907       {
23908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23909       };
23910     } catch (std::exception& e) {
23911       {
23912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23913       };
23914     } catch (...) {
23915       {
23916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23917       };
23918     }
23919   }
23920   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23921   return jresult;
23922 }
23923
23924
23925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23926   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23927   int arg2 ;
23928   int arg3 ;
23929
23930   arg1 = (Dali::Renderer *)jarg1;
23931   arg2 = (int)jarg2;
23932   arg3 = (int)jarg3;
23933   {
23934     try {
23935       (arg1)->SetIndexRange(arg2,arg3);
23936     } catch (std::out_of_range& e) {
23937       {
23938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23939       };
23940     } catch (std::exception& e) {
23941       {
23942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23943       };
23944     } catch (...) {
23945       {
23946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23947       };
23948     }
23949   }
23950 }
23951
23952
23953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23954   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23955   Dali::TextureSet *arg2 = 0 ;
23956
23957   arg1 = (Dali::Renderer *)jarg1;
23958   arg2 = (Dali::TextureSet *)jarg2;
23959   if (!arg2) {
23960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23961     return ;
23962   }
23963   {
23964     try {
23965       (arg1)->SetTextures(*arg2);
23966     } catch (std::out_of_range& e) {
23967       {
23968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23969       };
23970     } catch (std::exception& e) {
23971       {
23972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23973       };
23974     } catch (...) {
23975       {
23976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23977       };
23978     }
23979   }
23980 }
23981
23982
23983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23984   void * jresult ;
23985   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23986   Dali::TextureSet result;
23987
23988   arg1 = (Dali::Renderer *)jarg1;
23989   {
23990     try {
23991       result = ((Dali::Renderer const *)arg1)->GetTextures();
23992     } catch (std::out_of_range& e) {
23993       {
23994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23995       };
23996     } catch (std::exception& e) {
23997       {
23998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23999       };
24000     } catch (...) {
24001       {
24002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24003       };
24004     }
24005   }
24006   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24007   return jresult;
24008 }
24009
24010
24011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
24012   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24013   Dali::Shader *arg2 = 0 ;
24014
24015   arg1 = (Dali::Renderer *)jarg1;
24016   arg2 = (Dali::Shader *)jarg2;
24017   if (!arg2) {
24018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
24019     return ;
24020   }
24021   {
24022     try {
24023       (arg1)->SetShader(*arg2);
24024     } catch (std::out_of_range& e) {
24025       {
24026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24027       };
24028     } catch (std::exception& e) {
24029       {
24030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24031       };
24032     } catch (...) {
24033       {
24034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24035       };
24036     }
24037   }
24038 }
24039
24040
24041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
24042   void * jresult ;
24043   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24044   Dali::Shader result;
24045
24046   arg1 = (Dali::Renderer *)jarg1;
24047   {
24048     try {
24049       result = ((Dali::Renderer const *)arg1)->GetShader();
24050     } catch (std::out_of_range& e) {
24051       {
24052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24053       };
24054     } catch (std::exception& e) {
24055       {
24056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24057       };
24058     } catch (...) {
24059       {
24060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24061       };
24062     }
24063   }
24064   jresult = new Dali::Shader((const Dali::Shader &)result);
24065   return jresult;
24066 }
24067
24068
24069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
24070   void * jresult ;
24071   Dali::FrameBuffer::Attachment *result = 0 ;
24072
24073   {
24074     try {
24075       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
24076     } catch (std::out_of_range& e) {
24077       {
24078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24079       };
24080     } catch (std::exception& e) {
24081       {
24082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24083       };
24084     } catch (...) {
24085       {
24086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24087       };
24088     }
24089   }
24090   jresult = (void *)result;
24091   return jresult;
24092 }
24093
24094
24095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24096   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24097
24098   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24099   {
24100     try {
24101       delete arg1;
24102     } catch (std::out_of_range& e) {
24103       {
24104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24105       };
24106     } catch (std::exception& e) {
24107       {
24108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24109       };
24110     } catch (...) {
24111       {
24112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24113       };
24114     }
24115   }
24116 }
24117
24118
24119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24120   void * jresult ;
24121   unsigned int arg1 ;
24122   unsigned int arg2 ;
24123   unsigned int arg3 ;
24124   Dali::FrameBuffer result;
24125
24126   arg1 = (unsigned int)jarg1;
24127   arg2 = (unsigned int)jarg2;
24128   arg3 = (unsigned int)jarg3;
24129   {
24130     try {
24131       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24132     } catch (std::out_of_range& e) {
24133       {
24134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24135       };
24136     } catch (std::exception& e) {
24137       {
24138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24139       };
24140     } catch (...) {
24141       {
24142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24143       };
24144     }
24145   }
24146   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24147   return jresult;
24148 }
24149
24150
24151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24152   void * jresult ;
24153   Dali::FrameBuffer *result = 0 ;
24154
24155   {
24156     try {
24157       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24158     } catch (std::out_of_range& e) {
24159       {
24160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24161       };
24162     } catch (std::exception& e) {
24163       {
24164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24165       };
24166     } catch (...) {
24167       {
24168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24169       };
24170     }
24171   }
24172   jresult = (void *)result;
24173   return jresult;
24174 }
24175
24176
24177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24178   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24179
24180   arg1 = (Dali::FrameBuffer *)jarg1;
24181   {
24182     try {
24183       delete arg1;
24184     } catch (std::out_of_range& e) {
24185       {
24186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24187       };
24188     } catch (std::exception& e) {
24189       {
24190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24191       };
24192     } catch (...) {
24193       {
24194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24195       };
24196     }
24197   }
24198 }
24199
24200
24201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24202   void * jresult ;
24203   Dali::FrameBuffer *arg1 = 0 ;
24204   Dali::FrameBuffer *result = 0 ;
24205
24206   arg1 = (Dali::FrameBuffer *)jarg1;
24207   if (!arg1) {
24208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24209     return 0;
24210   }
24211   {
24212     try {
24213       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24214     } catch (std::out_of_range& e) {
24215       {
24216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24217       };
24218     } catch (std::exception& e) {
24219       {
24220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24221       };
24222     } catch (...) {
24223       {
24224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24225       };
24226     }
24227   }
24228   jresult = (void *)result;
24229   return jresult;
24230 }
24231
24232
24233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24234   void * jresult ;
24235   Dali::BaseHandle arg1 ;
24236   Dali::BaseHandle *argp1 ;
24237   Dali::FrameBuffer result;
24238
24239   argp1 = (Dali::BaseHandle *)jarg1;
24240   if (!argp1) {
24241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24242     return 0;
24243   }
24244   arg1 = *argp1;
24245   {
24246     try {
24247       result = Dali::FrameBuffer::DownCast(arg1);
24248     } catch (std::out_of_range& e) {
24249       {
24250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24251       };
24252     } catch (std::exception& e) {
24253       {
24254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24255       };
24256     } catch (...) {
24257       {
24258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24259       };
24260     }
24261   }
24262   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24263   return jresult;
24264 }
24265
24266
24267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24268   void * jresult ;
24269   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24270   Dali::FrameBuffer *arg2 = 0 ;
24271   Dali::FrameBuffer *result = 0 ;
24272
24273   arg1 = (Dali::FrameBuffer *)jarg1;
24274   arg2 = (Dali::FrameBuffer *)jarg2;
24275   if (!arg2) {
24276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24277     return 0;
24278   }
24279   {
24280     try {
24281       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24282     } catch (std::out_of_range& e) {
24283       {
24284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24285       };
24286     } catch (std::exception& e) {
24287       {
24288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24289       };
24290     } catch (...) {
24291       {
24292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24293       };
24294     }
24295   }
24296   jresult = (void *)result;
24297   return jresult;
24298 }
24299
24300
24301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24302   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24303   Dali::Texture *arg2 = 0 ;
24304
24305   arg1 = (Dali::FrameBuffer *)jarg1;
24306   arg2 = (Dali::Texture *)jarg2;
24307   if (!arg2) {
24308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24309     return ;
24310   }
24311   {
24312     try {
24313       (arg1)->AttachColorTexture(*arg2);
24314     } catch (std::out_of_range& e) {
24315       {
24316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24317       };
24318     } catch (std::exception& e) {
24319       {
24320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24321       };
24322     } catch (...) {
24323       {
24324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24325       };
24326     }
24327   }
24328 }
24329
24330
24331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24332   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24333   Dali::Texture *arg2 = 0 ;
24334   unsigned int arg3 ;
24335   unsigned int arg4 ;
24336
24337   arg1 = (Dali::FrameBuffer *)jarg1;
24338   arg2 = (Dali::Texture *)jarg2;
24339   if (!arg2) {
24340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24341     return ;
24342   }
24343   arg3 = (unsigned int)jarg3;
24344   arg4 = (unsigned int)jarg4;
24345   {
24346     try {
24347       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24348     } catch (std::out_of_range& e) {
24349       {
24350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24351       };
24352     } catch (std::exception& e) {
24353       {
24354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24355       };
24356     } catch (...) {
24357       {
24358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24359       };
24360     }
24361   }
24362 }
24363
24364
24365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24366   void * jresult ;
24367   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24368   Dali::Texture result;
24369
24370   arg1 = (Dali::FrameBuffer *)jarg1;
24371   {
24372     try {
24373       result = (arg1)->GetColorTexture();
24374     } catch (std::out_of_range& e) {
24375       {
24376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24377       };
24378     } catch (std::exception& e) {
24379       {
24380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24381       };
24382     } catch (...) {
24383       {
24384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24385       };
24386     }
24387   }
24388   jresult = new Dali::Texture((const Dali::Texture &)result);
24389   return jresult;
24390 }
24391
24392
24393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24394   void * jresult ;
24395   Dali::RenderTaskList *result = 0 ;
24396
24397   {
24398     try {
24399       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24400     } catch (std::out_of_range& e) {
24401       {
24402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24403       };
24404     } catch (std::exception& e) {
24405       {
24406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24407       };
24408     } catch (...) {
24409       {
24410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24411       };
24412     }
24413   }
24414   jresult = (void *)result;
24415   return jresult;
24416 }
24417
24418
24419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24420   void * jresult ;
24421   Dali::BaseHandle arg1 ;
24422   Dali::BaseHandle *argp1 ;
24423   Dali::RenderTaskList result;
24424
24425   argp1 = (Dali::BaseHandle *)jarg1;
24426   if (!argp1) {
24427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24428     return 0;
24429   }
24430   arg1 = *argp1;
24431   {
24432     try {
24433       result = Dali::RenderTaskList::DownCast(arg1);
24434     } catch (std::out_of_range& e) {
24435       {
24436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24437       };
24438     } catch (std::exception& e) {
24439       {
24440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24441       };
24442     } catch (...) {
24443       {
24444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24445       };
24446     }
24447   }
24448   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24449   return jresult;
24450 }
24451
24452
24453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24454   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24455
24456   arg1 = (Dali::RenderTaskList *)jarg1;
24457   {
24458     try {
24459       delete arg1;
24460     } catch (std::out_of_range& e) {
24461       {
24462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24463       };
24464     } catch (std::exception& e) {
24465       {
24466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24467       };
24468     } catch (...) {
24469       {
24470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24471       };
24472     }
24473   }
24474 }
24475
24476
24477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24478   void * jresult ;
24479   Dali::RenderTaskList *arg1 = 0 ;
24480   Dali::RenderTaskList *result = 0 ;
24481
24482   arg1 = (Dali::RenderTaskList *)jarg1;
24483   if (!arg1) {
24484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24485     return 0;
24486   }
24487   {
24488     try {
24489       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24490     } catch (std::out_of_range& e) {
24491       {
24492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24493       };
24494     } catch (std::exception& e) {
24495       {
24496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24497       };
24498     } catch (...) {
24499       {
24500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24501       };
24502     }
24503   }
24504   jresult = (void *)result;
24505   return jresult;
24506 }
24507
24508
24509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24510   void * jresult ;
24511   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24512   Dali::RenderTaskList *arg2 = 0 ;
24513   Dali::RenderTaskList *result = 0 ;
24514
24515   arg1 = (Dali::RenderTaskList *)jarg1;
24516   arg2 = (Dali::RenderTaskList *)jarg2;
24517   if (!arg2) {
24518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24519     return 0;
24520   }
24521   {
24522     try {
24523       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24524     } catch (std::out_of_range& e) {
24525       {
24526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24527       };
24528     } catch (std::exception& e) {
24529       {
24530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24531       };
24532     } catch (...) {
24533       {
24534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24535       };
24536     }
24537   }
24538   jresult = (void *)result;
24539   return jresult;
24540 }
24541
24542
24543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24544   void * jresult ;
24545   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24546   Dali::RenderTask result;
24547
24548   arg1 = (Dali::RenderTaskList *)jarg1;
24549   {
24550     try {
24551       result = (arg1)->CreateTask();
24552     } catch (std::out_of_range& e) {
24553       {
24554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24555       };
24556     } catch (std::exception& e) {
24557       {
24558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24559       };
24560     } catch (...) {
24561       {
24562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24563       };
24564     }
24565   }
24566   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24567   return jresult;
24568 }
24569
24570
24571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24572   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24573   Dali::RenderTask arg2 ;
24574   Dali::RenderTask *argp2 ;
24575
24576   arg1 = (Dali::RenderTaskList *)jarg1;
24577   argp2 = (Dali::RenderTask *)jarg2;
24578   if (!argp2) {
24579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24580     return ;
24581   }
24582   arg2 = *argp2;
24583   {
24584     try {
24585       (arg1)->RemoveTask(arg2);
24586     } catch (std::out_of_range& e) {
24587       {
24588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24589       };
24590     } catch (std::exception& e) {
24591       {
24592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24593       };
24594     } catch (...) {
24595       {
24596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24597       };
24598     }
24599   }
24600 }
24601
24602
24603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24604   unsigned int jresult ;
24605   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24606   unsigned int result;
24607
24608   arg1 = (Dali::RenderTaskList *)jarg1;
24609   {
24610     try {
24611       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24612     } catch (std::out_of_range& e) {
24613       {
24614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24615       };
24616     } catch (std::exception& e) {
24617       {
24618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24619       };
24620     } catch (...) {
24621       {
24622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24623       };
24624     }
24625   }
24626   jresult = result;
24627   return jresult;
24628 }
24629
24630
24631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24632   void * jresult ;
24633   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24634   unsigned int arg2 ;
24635   Dali::RenderTask result;
24636
24637   arg1 = (Dali::RenderTaskList *)jarg1;
24638   arg2 = (unsigned int)jarg2;
24639   {
24640     try {
24641       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24642     } catch (std::out_of_range& e) {
24643       {
24644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24645       };
24646     } catch (std::exception& e) {
24647       {
24648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24649       };
24650     } catch (...) {
24651       {
24652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24653       };
24654     }
24655   }
24656   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24657   return jresult;
24658 }
24659
24660
24661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24662   int jresult ;
24663   int result;
24664
24665   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24666   jresult = (int)result;
24667   return jresult;
24668 }
24669
24670
24671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24672   int jresult ;
24673   int result;
24674
24675   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24676   jresult = (int)result;
24677   return jresult;
24678 }
24679
24680
24681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24682   int jresult ;
24683   int result;
24684
24685   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24686   jresult = (int)result;
24687   return jresult;
24688 }
24689
24690
24691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24692   int jresult ;
24693   int result;
24694
24695   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24696   jresult = (int)result;
24697   return jresult;
24698 }
24699
24700
24701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24702   void * jresult ;
24703   Dali::RenderTask::Property *result = 0 ;
24704
24705   {
24706     try {
24707       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24708     } catch (std::out_of_range& e) {
24709       {
24710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24711       };
24712     } catch (std::exception& e) {
24713       {
24714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24715       };
24716     } catch (...) {
24717       {
24718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24719       };
24720     }
24721   }
24722   jresult = (void *)result;
24723   return jresult;
24724 }
24725
24726
24727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24728   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24729
24730   arg1 = (Dali::RenderTask::Property *)jarg1;
24731   {
24732     try {
24733       delete arg1;
24734     } catch (std::out_of_range& e) {
24735       {
24736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24737       };
24738     } catch (std::exception& e) {
24739       {
24740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24741       };
24742     } catch (...) {
24743       {
24744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24745       };
24746     }
24747   }
24748 }
24749
24750
24751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24752   void * jresult ;
24753   bool (*result)(Dali::Vector2 &) = 0 ;
24754
24755   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24756   jresult = (void *)result;
24757   return jresult;
24758 }
24759
24760
24761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24762   void * jresult ;
24763   bool (*result)(Dali::Vector2 &) = 0 ;
24764
24765   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24766   jresult = (void *)result;
24767   return jresult;
24768 }
24769
24770
24771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24772   unsigned int jresult ;
24773   bool result;
24774
24775   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24776   jresult = result;
24777   return jresult;
24778 }
24779
24780
24781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24782   unsigned int jresult ;
24783   bool result;
24784
24785   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24786   jresult = result;
24787   return jresult;
24788 }
24789
24790
24791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24792   void * jresult ;
24793   Dali::Vector4 *result = 0 ;
24794
24795   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24796   jresult = (void *)result;
24797   return jresult;
24798 }
24799
24800
24801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24802   unsigned int jresult ;
24803   bool result;
24804
24805   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24806   jresult = result;
24807   return jresult;
24808 }
24809
24810
24811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24812   unsigned int jresult ;
24813   bool result;
24814
24815   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24816   jresult = result;
24817   return jresult;
24818 }
24819
24820
24821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24822   unsigned int jresult ;
24823   unsigned int result;
24824
24825   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24826   jresult = result;
24827   return jresult;
24828 }
24829
24830
24831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24832   void * jresult ;
24833   Dali::RenderTask *result = 0 ;
24834
24835   {
24836     try {
24837       result = (Dali::RenderTask *)new Dali::RenderTask();
24838     } catch (std::out_of_range& e) {
24839       {
24840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24841       };
24842     } catch (std::exception& e) {
24843       {
24844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24845       };
24846     } catch (...) {
24847       {
24848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24849       };
24850     }
24851   }
24852   jresult = (void *)result;
24853   return jresult;
24854 }
24855
24856
24857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24858   void * jresult ;
24859   Dali::BaseHandle arg1 ;
24860   Dali::BaseHandle *argp1 ;
24861   Dali::RenderTask result;
24862
24863   argp1 = (Dali::BaseHandle *)jarg1;
24864   if (!argp1) {
24865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24866     return 0;
24867   }
24868   arg1 = *argp1;
24869   {
24870     try {
24871       result = Dali::RenderTask::DownCast(arg1);
24872     } catch (std::out_of_range& e) {
24873       {
24874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24875       };
24876     } catch (std::exception& e) {
24877       {
24878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24879       };
24880     } catch (...) {
24881       {
24882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24883       };
24884     }
24885   }
24886   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24887   return jresult;
24888 }
24889
24890
24891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24892   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24893
24894   arg1 = (Dali::RenderTask *)jarg1;
24895   {
24896     try {
24897       delete arg1;
24898     } catch (std::out_of_range& e) {
24899       {
24900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24901       };
24902     } catch (std::exception& e) {
24903       {
24904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24905       };
24906     } catch (...) {
24907       {
24908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24909       };
24910     }
24911   }
24912 }
24913
24914
24915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24916   void * jresult ;
24917   Dali::RenderTask *arg1 = 0 ;
24918   Dali::RenderTask *result = 0 ;
24919
24920   arg1 = (Dali::RenderTask *)jarg1;
24921   if (!arg1) {
24922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24923     return 0;
24924   }
24925   {
24926     try {
24927       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24928     } catch (std::out_of_range& e) {
24929       {
24930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24931       };
24932     } catch (std::exception& e) {
24933       {
24934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24935       };
24936     } catch (...) {
24937       {
24938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24939       };
24940     }
24941   }
24942   jresult = (void *)result;
24943   return jresult;
24944 }
24945
24946
24947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24948   void * jresult ;
24949   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24950   Dali::RenderTask *arg2 = 0 ;
24951   Dali::RenderTask *result = 0 ;
24952
24953   arg1 = (Dali::RenderTask *)jarg1;
24954   arg2 = (Dali::RenderTask *)jarg2;
24955   if (!arg2) {
24956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24957     return 0;
24958   }
24959   {
24960     try {
24961       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24962     } catch (std::out_of_range& e) {
24963       {
24964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24965       };
24966     } catch (std::exception& e) {
24967       {
24968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24969       };
24970     } catch (...) {
24971       {
24972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24973       };
24974     }
24975   }
24976   jresult = (void *)result;
24977   return jresult;
24978 }
24979
24980
24981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24982   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24983   Dali::Actor arg2 ;
24984   Dali::Actor *argp2 ;
24985
24986   arg1 = (Dali::RenderTask *)jarg1;
24987   argp2 = (Dali::Actor *)jarg2;
24988   if (!argp2) {
24989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24990     return ;
24991   }
24992   arg2 = *argp2;
24993   {
24994     try {
24995       (arg1)->SetSourceActor(arg2);
24996     } catch (std::out_of_range& e) {
24997       {
24998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24999       };
25000     } catch (std::exception& e) {
25001       {
25002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25003       };
25004     } catch (...) {
25005       {
25006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25007       };
25008     }
25009   }
25010 }
25011
25012
25013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
25014   void * jresult ;
25015   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25016   Dali::Actor result;
25017
25018   arg1 = (Dali::RenderTask *)jarg1;
25019   {
25020     try {
25021       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
25022     } catch (std::out_of_range& e) {
25023       {
25024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25025       };
25026     } catch (std::exception& e) {
25027       {
25028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25029       };
25030     } catch (...) {
25031       {
25032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25033       };
25034     }
25035   }
25036   jresult = new Dali::Actor((const Dali::Actor &)result);
25037   return jresult;
25038 }
25039
25040
25041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
25042   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25043   bool arg2 ;
25044
25045   arg1 = (Dali::RenderTask *)jarg1;
25046   arg2 = jarg2 ? true : false;
25047   {
25048     try {
25049       (arg1)->SetExclusive(arg2);
25050     } catch (std::out_of_range& e) {
25051       {
25052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25053       };
25054     } catch (std::exception& e) {
25055       {
25056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25057       };
25058     } catch (...) {
25059       {
25060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25061       };
25062     }
25063   }
25064 }
25065
25066
25067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
25068   unsigned int jresult ;
25069   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25070   bool result;
25071
25072   arg1 = (Dali::RenderTask *)jarg1;
25073   {
25074     try {
25075       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
25076     } catch (std::out_of_range& e) {
25077       {
25078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25079       };
25080     } catch (std::exception& e) {
25081       {
25082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25083       };
25084     } catch (...) {
25085       {
25086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25087       };
25088     }
25089   }
25090   jresult = result;
25091   return jresult;
25092 }
25093
25094
25095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25096   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25097   bool arg2 ;
25098
25099   arg1 = (Dali::RenderTask *)jarg1;
25100   arg2 = jarg2 ? true : false;
25101   {
25102     try {
25103       (arg1)->SetInputEnabled(arg2);
25104     } catch (std::out_of_range& e) {
25105       {
25106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25107       };
25108     } catch (std::exception& e) {
25109       {
25110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25111       };
25112     } catch (...) {
25113       {
25114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25115       };
25116     }
25117   }
25118 }
25119
25120
25121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25122   unsigned int jresult ;
25123   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25124   bool result;
25125
25126   arg1 = (Dali::RenderTask *)jarg1;
25127   {
25128     try {
25129       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25130     } catch (std::out_of_range& e) {
25131       {
25132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25133       };
25134     } catch (std::exception& e) {
25135       {
25136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25137       };
25138     } catch (...) {
25139       {
25140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25141       };
25142     }
25143   }
25144   jresult = result;
25145   return jresult;
25146 }
25147
25148
25149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25150   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25151   Dali::CameraActor arg2 ;
25152   Dali::CameraActor *argp2 ;
25153
25154   arg1 = (Dali::RenderTask *)jarg1;
25155   argp2 = (Dali::CameraActor *)jarg2;
25156   if (!argp2) {
25157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25158     return ;
25159   }
25160   arg2 = *argp2;
25161   {
25162     try {
25163       (arg1)->SetCameraActor(arg2);
25164     } catch (std::out_of_range& e) {
25165       {
25166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25167       };
25168     } catch (std::exception& e) {
25169       {
25170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25171       };
25172     } catch (...) {
25173       {
25174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25175       };
25176     }
25177   }
25178 }
25179
25180
25181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25182   void * jresult ;
25183   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25184   Dali::CameraActor result;
25185
25186   arg1 = (Dali::RenderTask *)jarg1;
25187   {
25188     try {
25189       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25190     } catch (std::out_of_range& e) {
25191       {
25192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25193       };
25194     } catch (std::exception& e) {
25195       {
25196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25197       };
25198     } catch (...) {
25199       {
25200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25201       };
25202     }
25203   }
25204   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25205   return jresult;
25206 }
25207
25208
25209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25210   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25211   Dali::FrameBufferImage arg2 ;
25212   Dali::FrameBufferImage *argp2 ;
25213
25214   arg1 = (Dali::RenderTask *)jarg1;
25215   argp2 = (Dali::FrameBufferImage *)jarg2;
25216   if (!argp2) {
25217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25218     return ;
25219   }
25220   arg2 = *argp2;
25221   {
25222     try {
25223       (arg1)->SetTargetFrameBuffer(arg2);
25224     } catch (std::out_of_range& e) {
25225       {
25226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25227       };
25228     } catch (std::exception& e) {
25229       {
25230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25231       };
25232     } catch (...) {
25233       {
25234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25235       };
25236     }
25237   }
25238 }
25239
25240
25241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25242   void * jresult ;
25243   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25244   Dali::FrameBufferImage result;
25245
25246   arg1 = (Dali::RenderTask *)jarg1;
25247   {
25248     try {
25249       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25250     } catch (std::out_of_range& e) {
25251       {
25252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25253       };
25254     } catch (std::exception& e) {
25255       {
25256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25257       };
25258     } catch (...) {
25259       {
25260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25261       };
25262     }
25263   }
25264   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25265   return jresult;
25266 }
25267
25268
25269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25270   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25271   Dali::FrameBuffer arg2 ;
25272   Dali::FrameBuffer *argp2 ;
25273
25274   arg1 = (Dali::RenderTask *)jarg1;
25275   argp2 = (Dali::FrameBuffer *)jarg2;
25276   if (!argp2) {
25277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25278     return ;
25279   }
25280   arg2 = *argp2;
25281   {
25282     try {
25283       (arg1)->SetFrameBuffer(arg2);
25284     } catch (std::out_of_range& e) {
25285       {
25286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25287       };
25288     } catch (std::exception& e) {
25289       {
25290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25291       };
25292     } catch (...) {
25293       {
25294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25295       };
25296     }
25297   }
25298 }
25299
25300
25301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25302   void * jresult ;
25303   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25304   Dali::FrameBuffer result;
25305
25306   arg1 = (Dali::RenderTask *)jarg1;
25307   {
25308     try {
25309       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25310     } catch (std::out_of_range& e) {
25311       {
25312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25313       };
25314     } catch (std::exception& e) {
25315       {
25316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25317       };
25318     } catch (...) {
25319       {
25320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25321       };
25322     }
25323   }
25324   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25325   return jresult;
25326 }
25327
25328
25329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25330   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25331   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25332
25333   arg1 = (Dali::RenderTask *)jarg1;
25334   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25335   {
25336     try {
25337       (arg1)->SetScreenToFrameBufferFunction(arg2);
25338     } catch (std::out_of_range& e) {
25339       {
25340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25341       };
25342     } catch (std::exception& e) {
25343       {
25344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25345       };
25346     } catch (...) {
25347       {
25348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25349       };
25350     }
25351   }
25352 }
25353
25354
25355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25356   void * jresult ;
25357   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25358   Dali::RenderTask::ScreenToFrameBufferFunction result;
25359
25360   arg1 = (Dali::RenderTask *)jarg1;
25361   {
25362     try {
25363       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25364     } catch (std::out_of_range& e) {
25365       {
25366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25367       };
25368     } catch (std::exception& e) {
25369       {
25370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25371       };
25372     } catch (...) {
25373       {
25374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25375       };
25376     }
25377   }
25378   jresult = (void *)result;
25379   return jresult;
25380 }
25381
25382
25383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25384   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25385   Dali::Actor arg2 ;
25386   Dali::Actor *argp2 ;
25387
25388   arg1 = (Dali::RenderTask *)jarg1;
25389   argp2 = (Dali::Actor *)jarg2;
25390   if (!argp2) {
25391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25392     return ;
25393   }
25394   arg2 = *argp2;
25395   {
25396     try {
25397       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25398     } catch (std::out_of_range& e) {
25399       {
25400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25401       };
25402     } catch (std::exception& e) {
25403       {
25404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25405       };
25406     } catch (...) {
25407       {
25408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25409       };
25410     }
25411   }
25412 }
25413
25414
25415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25416   void * jresult ;
25417   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25418   Dali::Actor result;
25419
25420   arg1 = (Dali::RenderTask *)jarg1;
25421   {
25422     try {
25423       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25424     } catch (std::out_of_range& e) {
25425       {
25426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25427       };
25428     } catch (std::exception& e) {
25429       {
25430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25431       };
25432     } catch (...) {
25433       {
25434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25435       };
25436     }
25437   }
25438   jresult = new Dali::Actor((const Dali::Actor &)result);
25439   return jresult;
25440 }
25441
25442
25443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25444   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25445   Dali::Vector2 arg2 ;
25446   Dali::Vector2 *argp2 ;
25447
25448   arg1 = (Dali::RenderTask *)jarg1;
25449   argp2 = (Dali::Vector2 *)jarg2;
25450   if (!argp2) {
25451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25452     return ;
25453   }
25454   arg2 = *argp2;
25455   {
25456     try {
25457       (arg1)->SetViewportPosition(arg2);
25458     } catch (std::out_of_range& e) {
25459       {
25460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25461       };
25462     } catch (std::exception& e) {
25463       {
25464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25465       };
25466     } catch (...) {
25467       {
25468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25469       };
25470     }
25471   }
25472 }
25473
25474
25475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25476   void * jresult ;
25477   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25478   Dali::Vector2 result;
25479
25480   arg1 = (Dali::RenderTask *)jarg1;
25481   {
25482     try {
25483       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25484     } catch (std::out_of_range& e) {
25485       {
25486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25487       };
25488     } catch (std::exception& e) {
25489       {
25490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25491       };
25492     } catch (...) {
25493       {
25494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25495       };
25496     }
25497   }
25498   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25499   return jresult;
25500 }
25501
25502
25503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25504   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25505   Dali::Vector2 arg2 ;
25506   Dali::Vector2 *argp2 ;
25507
25508   arg1 = (Dali::RenderTask *)jarg1;
25509   argp2 = (Dali::Vector2 *)jarg2;
25510   if (!argp2) {
25511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25512     return ;
25513   }
25514   arg2 = *argp2;
25515   {
25516     try {
25517       (arg1)->SetViewportSize(arg2);
25518     } catch (std::out_of_range& e) {
25519       {
25520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25521       };
25522     } catch (std::exception& e) {
25523       {
25524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25525       };
25526     } catch (...) {
25527       {
25528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25529       };
25530     }
25531   }
25532 }
25533
25534
25535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25536   void * jresult ;
25537   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25538   Dali::Vector2 result;
25539
25540   arg1 = (Dali::RenderTask *)jarg1;
25541   {
25542     try {
25543       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25544     } catch (std::out_of_range& e) {
25545       {
25546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25547       };
25548     } catch (std::exception& e) {
25549       {
25550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25551       };
25552     } catch (...) {
25553       {
25554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25555       };
25556     }
25557   }
25558   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25559   return jresult;
25560 }
25561
25562
25563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25564   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25565   Dali::Viewport arg2 ;
25566   Dali::Viewport *argp2 ;
25567
25568   arg1 = (Dali::RenderTask *)jarg1;
25569   argp2 = (Dali::Viewport *)jarg2;
25570   if (!argp2) {
25571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25572     return ;
25573   }
25574   arg2 = *argp2;
25575   {
25576     try {
25577       (arg1)->SetViewport(arg2);
25578     } catch (std::out_of_range& e) {
25579       {
25580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25581       };
25582     } catch (std::exception& e) {
25583       {
25584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25585       };
25586     } catch (...) {
25587       {
25588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25589       };
25590     }
25591   }
25592 }
25593
25594
25595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25596   void * jresult ;
25597   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25598   Dali::Viewport result;
25599
25600   arg1 = (Dali::RenderTask *)jarg1;
25601   {
25602     try {
25603       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25604     } catch (std::out_of_range& e) {
25605       {
25606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25607       };
25608     } catch (std::exception& e) {
25609       {
25610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25611       };
25612     } catch (...) {
25613       {
25614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25615       };
25616     }
25617   }
25618   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25619   return jresult;
25620 }
25621
25622
25623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25624   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25625   Dali::Vector4 *arg2 = 0 ;
25626
25627   arg1 = (Dali::RenderTask *)jarg1;
25628   arg2 = (Dali::Vector4 *)jarg2;
25629   if (!arg2) {
25630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25631     return ;
25632   }
25633   {
25634     try {
25635       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25636     } catch (std::out_of_range& e) {
25637       {
25638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25639       };
25640     } catch (std::exception& e) {
25641       {
25642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25643       };
25644     } catch (...) {
25645       {
25646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25647       };
25648     }
25649   }
25650 }
25651
25652
25653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25654   void * jresult ;
25655   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25656   Dali::Vector4 result;
25657
25658   arg1 = (Dali::RenderTask *)jarg1;
25659   {
25660     try {
25661       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25662     } catch (std::out_of_range& e) {
25663       {
25664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25665       };
25666     } catch (std::exception& e) {
25667       {
25668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25669       };
25670     } catch (...) {
25671       {
25672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25673       };
25674     }
25675   }
25676   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25677   return jresult;
25678 }
25679
25680
25681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25682   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25683   bool arg2 ;
25684
25685   arg1 = (Dali::RenderTask *)jarg1;
25686   arg2 = jarg2 ? true : false;
25687   {
25688     try {
25689       (arg1)->SetClearEnabled(arg2);
25690     } catch (std::out_of_range& e) {
25691       {
25692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25693       };
25694     } catch (std::exception& e) {
25695       {
25696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25697       };
25698     } catch (...) {
25699       {
25700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25701       };
25702     }
25703   }
25704 }
25705
25706
25707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25708   unsigned int jresult ;
25709   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25710   bool result;
25711
25712   arg1 = (Dali::RenderTask *)jarg1;
25713   {
25714     try {
25715       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25716     } catch (std::out_of_range& e) {
25717       {
25718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25719       };
25720     } catch (std::exception& e) {
25721       {
25722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25723       };
25724     } catch (...) {
25725       {
25726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25727       };
25728     }
25729   }
25730   jresult = result;
25731   return jresult;
25732 }
25733
25734
25735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25736   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25737   bool arg2 ;
25738
25739   arg1 = (Dali::RenderTask *)jarg1;
25740   arg2 = jarg2 ? true : false;
25741   {
25742     try {
25743       (arg1)->SetCullMode(arg2);
25744     } catch (std::out_of_range& e) {
25745       {
25746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25747       };
25748     } catch (std::exception& e) {
25749       {
25750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25751       };
25752     } catch (...) {
25753       {
25754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25755       };
25756     }
25757   }
25758 }
25759
25760
25761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25762   unsigned int jresult ;
25763   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25764   bool result;
25765
25766   arg1 = (Dali::RenderTask *)jarg1;
25767   {
25768     try {
25769       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25770     } catch (std::out_of_range& e) {
25771       {
25772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25773       };
25774     } catch (std::exception& e) {
25775       {
25776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25777       };
25778     } catch (...) {
25779       {
25780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25781       };
25782     }
25783   }
25784   jresult = result;
25785   return jresult;
25786 }
25787
25788
25789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25790   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25791   unsigned int arg2 ;
25792
25793   arg1 = (Dali::RenderTask *)jarg1;
25794   arg2 = (unsigned int)jarg2;
25795   {
25796     try {
25797       (arg1)->SetRefreshRate(arg2);
25798     } catch (std::out_of_range& e) {
25799       {
25800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25801       };
25802     } catch (std::exception& e) {
25803       {
25804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25805       };
25806     } catch (...) {
25807       {
25808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25809       };
25810     }
25811   }
25812 }
25813
25814
25815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25816   unsigned int jresult ;
25817   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25818   unsigned int result;
25819
25820   arg1 = (Dali::RenderTask *)jarg1;
25821   {
25822     try {
25823       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25824     } catch (std::out_of_range& e) {
25825       {
25826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25827       };
25828     } catch (std::exception& e) {
25829       {
25830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25831       };
25832     } catch (...) {
25833       {
25834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25835       };
25836     }
25837   }
25838   jresult = result;
25839   return jresult;
25840 }
25841
25842
25843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25844   unsigned int jresult ;
25845   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25846   Dali::Vector3 *arg2 = 0 ;
25847   float *arg3 = 0 ;
25848   float *arg4 = 0 ;
25849   bool result;
25850
25851   arg1 = (Dali::RenderTask *)jarg1;
25852   arg2 = (Dali::Vector3 *)jarg2;
25853   if (!arg2) {
25854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25855     return 0;
25856   }
25857   arg3 = (float *)jarg3;
25858   arg4 = (float *)jarg4;
25859   {
25860     try {
25861       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25862     } catch (std::out_of_range& e) {
25863       {
25864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25865       };
25866     } catch (std::exception& e) {
25867       {
25868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25869       };
25870     } catch (...) {
25871       {
25872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25873       };
25874     }
25875   }
25876   jresult = result;
25877   return jresult;
25878 }
25879
25880
25881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25882   unsigned int jresult ;
25883   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25884   Dali::Actor arg2 ;
25885   float arg3 ;
25886   float arg4 ;
25887   float *arg5 = 0 ;
25888   float *arg6 = 0 ;
25889   Dali::Actor *argp2 ;
25890   bool result;
25891
25892   arg1 = (Dali::RenderTask *)jarg1;
25893   argp2 = (Dali::Actor *)jarg2;
25894   if (!argp2) {
25895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25896     return 0;
25897   }
25898   arg2 = *argp2;
25899   arg3 = (float)jarg3;
25900   arg4 = (float)jarg4;
25901   arg5 = (float *)jarg5;
25902   arg6 = (float *)jarg6;
25903   {
25904     try {
25905       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25906     } catch (std::out_of_range& e) {
25907       {
25908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25909       };
25910     } catch (std::exception& e) {
25911       {
25912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25913       };
25914     } catch (...) {
25915       {
25916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25917       };
25918     }
25919   }
25920   jresult = result;
25921   return jresult;
25922 }
25923
25924
25925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25926   void * jresult ;
25927   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25928   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25929
25930   arg1 = (Dali::RenderTask *)jarg1;
25931   {
25932     try {
25933       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25934     } catch (std::out_of_range& e) {
25935       {
25936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25937       };
25938     } catch (std::exception& e) {
25939       {
25940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25941       };
25942     } catch (...) {
25943       {
25944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25945       };
25946     }
25947   }
25948   jresult = (void *)result;
25949   return jresult;
25950 }
25951
25952
25953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25954   void * jresult ;
25955   int arg1 ;
25956   Dali::TouchPoint::State arg2 ;
25957   float arg3 ;
25958   float arg4 ;
25959   Dali::TouchPoint *result = 0 ;
25960
25961   arg1 = (int)jarg1;
25962   arg2 = (Dali::TouchPoint::State)jarg2;
25963   arg3 = (float)jarg3;
25964   arg4 = (float)jarg4;
25965   {
25966     try {
25967       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25968     } catch (std::out_of_range& e) {
25969       {
25970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25971       };
25972     } catch (std::exception& e) {
25973       {
25974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25975       };
25976     } catch (...) {
25977       {
25978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25979       };
25980     }
25981   }
25982   jresult = (void *)result;
25983   return jresult;
25984 }
25985
25986
25987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25988   void * jresult ;
25989   int arg1 ;
25990   Dali::TouchPoint::State arg2 ;
25991   float arg3 ;
25992   float arg4 ;
25993   float arg5 ;
25994   float arg6 ;
25995   Dali::TouchPoint *result = 0 ;
25996
25997   arg1 = (int)jarg1;
25998   arg2 = (Dali::TouchPoint::State)jarg2;
25999   arg3 = (float)jarg3;
26000   arg4 = (float)jarg4;
26001   arg5 = (float)jarg5;
26002   arg6 = (float)jarg6;
26003   {
26004     try {
26005       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
26006     } catch (std::out_of_range& e) {
26007       {
26008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26009       };
26010     } catch (std::exception& e) {
26011       {
26012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26013       };
26014     } catch (...) {
26015       {
26016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26017       };
26018     }
26019   }
26020   jresult = (void *)result;
26021   return jresult;
26022 }
26023
26024
26025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
26026   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26027
26028   arg1 = (Dali::TouchPoint *)jarg1;
26029   {
26030     try {
26031       delete arg1;
26032     } catch (std::out_of_range& e) {
26033       {
26034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26035       };
26036     } catch (std::exception& e) {
26037       {
26038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26039       };
26040     } catch (...) {
26041       {
26042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26043       };
26044     }
26045   }
26046 }
26047
26048
26049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
26050   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26051   int arg2 ;
26052
26053   arg1 = (Dali::TouchPoint *)jarg1;
26054   arg2 = (int)jarg2;
26055   if (arg1) (arg1)->deviceId = arg2;
26056 }
26057
26058
26059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
26060   int jresult ;
26061   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26062   int result;
26063
26064   arg1 = (Dali::TouchPoint *)jarg1;
26065   result = (int) ((arg1)->deviceId);
26066   jresult = result;
26067   return jresult;
26068 }
26069
26070
26071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
26072   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26073   Dali::TouchPoint::State arg2 ;
26074
26075   arg1 = (Dali::TouchPoint *)jarg1;
26076   arg2 = (Dali::TouchPoint::State)jarg2;
26077   if (arg1) (arg1)->state = arg2;
26078 }
26079
26080
26081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
26082   int jresult ;
26083   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26084   Dali::TouchPoint::State result;
26085
26086   arg1 = (Dali::TouchPoint *)jarg1;
26087   result = (Dali::TouchPoint::State) ((arg1)->state);
26088   jresult = (int)result;
26089   return jresult;
26090 }
26091
26092
26093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26094   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26095   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26096
26097   arg1 = (Dali::TouchPoint *)jarg1;
26098   arg2 = (Dali::Actor *)jarg2;
26099   if (arg1) (arg1)->hitActor = *arg2;
26100 }
26101
26102
26103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26104   void * jresult ;
26105   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26106   Dali::Actor *result = 0 ;
26107
26108   arg1 = (Dali::TouchPoint *)jarg1;
26109   result = (Dali::Actor *)& ((arg1)->hitActor);
26110   jresult = (void *)result;
26111   return jresult;
26112 }
26113
26114
26115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26116   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26117   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26118
26119   arg1 = (Dali::TouchPoint *)jarg1;
26120   arg2 = (Dali::Vector2 *)jarg2;
26121   if (arg1) (arg1)->local = *arg2;
26122 }
26123
26124
26125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26126   void * jresult ;
26127   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26128   Dali::Vector2 *result = 0 ;
26129
26130   arg1 = (Dali::TouchPoint *)jarg1;
26131   result = (Dali::Vector2 *)& ((arg1)->local);
26132   jresult = (void *)result;
26133   return jresult;
26134 }
26135
26136
26137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26138   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26139   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26140
26141   arg1 = (Dali::TouchPoint *)jarg1;
26142   arg2 = (Dali::Vector2 *)jarg2;
26143   if (arg1) (arg1)->screen = *arg2;
26144 }
26145
26146
26147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26148   void * jresult ;
26149   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26150   Dali::Vector2 *result = 0 ;
26151
26152   arg1 = (Dali::TouchPoint *)jarg1;
26153   result = (Dali::Vector2 *)& ((arg1)->screen);
26154   jresult = (void *)result;
26155   return jresult;
26156 }
26157
26158
26159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26160   void * jresult ;
26161   Dali::TouchData *result = 0 ;
26162
26163   {
26164     try {
26165       result = (Dali::TouchData *)new Dali::TouchData();
26166     } catch (std::out_of_range& e) {
26167       {
26168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26169       };
26170     } catch (std::exception& e) {
26171       {
26172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26173       };
26174     } catch (...) {
26175       {
26176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26177       };
26178     }
26179   }
26180   jresult = (void *)result;
26181   return jresult;
26182 }
26183
26184
26185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26186   void * jresult ;
26187   Dali::TouchData *arg1 = 0 ;
26188   Dali::TouchData *result = 0 ;
26189
26190   arg1 = (Dali::TouchData *)jarg1;
26191   if (!arg1) {
26192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26193     return 0;
26194   }
26195   {
26196     try {
26197       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26198     } catch (std::out_of_range& e) {
26199       {
26200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26201       };
26202     } catch (std::exception& e) {
26203       {
26204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26205       };
26206     } catch (...) {
26207       {
26208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26209       };
26210     }
26211   }
26212   jresult = (void *)result;
26213   return jresult;
26214 }
26215
26216
26217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26218   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26219
26220   arg1 = (Dali::TouchData *)jarg1;
26221   {
26222     try {
26223       delete arg1;
26224     } catch (std::out_of_range& e) {
26225       {
26226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26227       };
26228     } catch (std::exception& e) {
26229       {
26230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26231       };
26232     } catch (...) {
26233       {
26234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26235       };
26236     }
26237   }
26238 }
26239
26240
26241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26242   void * jresult ;
26243   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26244   Dali::TouchData *arg2 = 0 ;
26245   Dali::TouchData *result = 0 ;
26246
26247   arg1 = (Dali::TouchData *)jarg1;
26248   arg2 = (Dali::TouchData *)jarg2;
26249   if (!arg2) {
26250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26251     return 0;
26252   }
26253   {
26254     try {
26255       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26256     } catch (std::out_of_range& e) {
26257       {
26258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26259       };
26260     } catch (std::exception& e) {
26261       {
26262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26263       };
26264     } catch (...) {
26265       {
26266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26267       };
26268     }
26269   }
26270   jresult = (void *)result;
26271   return jresult;
26272 }
26273
26274
26275 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26276   unsigned long jresult ;
26277   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26278   unsigned long result;
26279
26280   arg1 = (Dali::TouchData *)jarg1;
26281   {
26282     try {
26283       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26284     } catch (std::out_of_range& e) {
26285       {
26286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26287       };
26288     } catch (std::exception& e) {
26289       {
26290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26291       };
26292     } catch (...) {
26293       {
26294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26295       };
26296     }
26297   }
26298   jresult = (unsigned long)result;
26299   return jresult;
26300 }
26301
26302
26303 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26304   unsigned long jresult ;
26305   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26306   std::size_t result;
26307
26308   arg1 = (Dali::TouchData *)jarg1;
26309   {
26310     try {
26311       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26312     } catch (std::out_of_range& e) {
26313       {
26314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26315       };
26316     } catch (std::exception& e) {
26317       {
26318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26319       };
26320     } catch (...) {
26321       {
26322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26323       };
26324     }
26325   }
26326   jresult = (unsigned long)result;
26327   return jresult;
26328 }
26329
26330
26331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26332   int jresult ;
26333   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26334   std::size_t arg2 ;
26335   int32_t result;
26336
26337   arg1 = (Dali::TouchData *)jarg1;
26338   arg2 = (std::size_t)jarg2;
26339   {
26340     try {
26341       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26342     } catch (std::out_of_range& e) {
26343       {
26344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26345       };
26346     } catch (std::exception& e) {
26347       {
26348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26349       };
26350     } catch (...) {
26351       {
26352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26353       };
26354     }
26355   }
26356   jresult = result;
26357   return jresult;
26358 }
26359
26360
26361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26362   int jresult ;
26363   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26364   std::size_t arg2 ;
26365   Dali::PointState::Type result;
26366
26367   arg1 = (Dali::TouchData *)jarg1;
26368   arg2 = (std::size_t)jarg2;
26369   {
26370     try {
26371       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26372     } catch (std::out_of_range& e) {
26373       {
26374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26375       };
26376     } catch (std::exception& e) {
26377       {
26378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26379       };
26380     } catch (...) {
26381       {
26382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26383       };
26384     }
26385   }
26386   jresult = (int)result;
26387   return jresult;
26388 }
26389
26390
26391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26392   void * jresult ;
26393   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26394   std::size_t arg2 ;
26395   Dali::Actor result;
26396
26397   arg1 = (Dali::TouchData *)jarg1;
26398   arg2 = (std::size_t)jarg2;
26399   {
26400     try {
26401       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26402     } catch (std::out_of_range& e) {
26403       {
26404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26405       };
26406     } catch (std::exception& e) {
26407       {
26408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26409       };
26410     } catch (...) {
26411       {
26412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26413       };
26414     }
26415   }
26416   jresult = new Dali::Actor((const Dali::Actor &)result);
26417   return jresult;
26418 }
26419
26420
26421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26422   void * jresult ;
26423   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26424   std::size_t arg2 ;
26425   Dali::Vector2 *result = 0 ;
26426
26427   arg1 = (Dali::TouchData *)jarg1;
26428   arg2 = (std::size_t)jarg2;
26429   {
26430     try {
26431       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26432     } catch (std::out_of_range& e) {
26433       {
26434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26435       };
26436     } catch (std::exception& e) {
26437       {
26438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26439       };
26440     } catch (...) {
26441       {
26442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26443       };
26444     }
26445   }
26446   jresult = (void *)result;
26447   return jresult;
26448 }
26449
26450
26451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26452   void * jresult ;
26453   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26454   std::size_t arg2 ;
26455   Dali::Vector2 *result = 0 ;
26456
26457   arg1 = (Dali::TouchData *)jarg1;
26458   arg2 = (std::size_t)jarg2;
26459   {
26460     try {
26461       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26462     } catch (std::out_of_range& e) {
26463       {
26464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26465       };
26466     } catch (std::exception& e) {
26467       {
26468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26469       };
26470     } catch (...) {
26471       {
26472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26473       };
26474     }
26475   }
26476   jresult = (void *)result;
26477   return jresult;
26478 }
26479
26480
26481 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26482   float jresult ;
26483   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26484   std::size_t arg2 ;
26485   float result;
26486
26487   arg1 = (Dali::TouchData *)jarg1;
26488   arg2 = (std::size_t)jarg2;
26489   {
26490     try {
26491       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26492     } catch (std::out_of_range& e) {
26493       {
26494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26495       };
26496     } catch (std::exception& e) {
26497       {
26498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26499       };
26500     } catch (...) {
26501       {
26502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26503       };
26504     }
26505   }
26506   jresult = result;
26507   return jresult;
26508 }
26509
26510
26511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26512   void * jresult ;
26513   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26514   std::size_t arg2 ;
26515   Dali::Vector2 *result = 0 ;
26516
26517   arg1 = (Dali::TouchData *)jarg1;
26518   arg2 = (std::size_t)jarg2;
26519   {
26520     try {
26521       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26522     } catch (std::out_of_range& e) {
26523       {
26524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26525       };
26526     } catch (std::exception& e) {
26527       {
26528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26529       };
26530     } catch (...) {
26531       {
26532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26533       };
26534     }
26535   }
26536   jresult = (void *)result;
26537   return jresult;
26538 }
26539
26540
26541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26542   float jresult ;
26543   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26544   std::size_t arg2 ;
26545   float result;
26546
26547   arg1 = (Dali::TouchData *)jarg1;
26548   arg2 = (std::size_t)jarg2;
26549   {
26550     try {
26551       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26552     } catch (std::out_of_range& e) {
26553       {
26554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26555       };
26556     } catch (std::exception& e) {
26557       {
26558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26559       };
26560     } catch (...) {
26561       {
26562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26563       };
26564     }
26565   }
26566   jresult = result;
26567   return jresult;
26568 }
26569
26570
26571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26572   void * jresult ;
26573   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26574   std::size_t arg2 ;
26575   Dali::Degree result;
26576
26577   arg1 = (Dali::TouchData *)jarg1;
26578   arg2 = (std::size_t)jarg2;
26579   {
26580     try {
26581       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26582     } catch (std::out_of_range& e) {
26583       {
26584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26585       };
26586     } catch (std::exception& e) {
26587       {
26588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26589       };
26590     } catch (...) {
26591       {
26592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26593       };
26594     }
26595   }
26596   jresult = new Dali::Degree((const Dali::Degree &)result);
26597   return jresult;
26598 }
26599
26600
26601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26602   void * jresult ;
26603   Dali::GestureDetector *result = 0 ;
26604
26605   {
26606     try {
26607       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26608     } catch (std::out_of_range& e) {
26609       {
26610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26611       };
26612     } catch (std::exception& e) {
26613       {
26614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26615       };
26616     } catch (...) {
26617       {
26618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26619       };
26620     }
26621   }
26622   jresult = (void *)result;
26623   return jresult;
26624 }
26625
26626
26627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26628   void * jresult ;
26629   Dali::BaseHandle arg1 ;
26630   Dali::BaseHandle *argp1 ;
26631   Dali::GestureDetector result;
26632
26633   argp1 = (Dali::BaseHandle *)jarg1;
26634   if (!argp1) {
26635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26636     return 0;
26637   }
26638   arg1 = *argp1;
26639   {
26640     try {
26641       result = Dali::GestureDetector::DownCast(arg1);
26642     } catch (std::out_of_range& e) {
26643       {
26644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26645       };
26646     } catch (std::exception& e) {
26647       {
26648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26649       };
26650     } catch (...) {
26651       {
26652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26653       };
26654     }
26655   }
26656   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26657   return jresult;
26658 }
26659
26660
26661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26662   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26663
26664   arg1 = (Dali::GestureDetector *)jarg1;
26665   {
26666     try {
26667       delete arg1;
26668     } catch (std::out_of_range& e) {
26669       {
26670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26671       };
26672     } catch (std::exception& e) {
26673       {
26674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26675       };
26676     } catch (...) {
26677       {
26678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26679       };
26680     }
26681   }
26682 }
26683
26684
26685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26686   void * jresult ;
26687   Dali::GestureDetector *arg1 = 0 ;
26688   Dali::GestureDetector *result = 0 ;
26689
26690   arg1 = (Dali::GestureDetector *)jarg1;
26691   if (!arg1) {
26692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26693     return 0;
26694   }
26695   {
26696     try {
26697       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26698     } catch (std::out_of_range& e) {
26699       {
26700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26701       };
26702     } catch (std::exception& e) {
26703       {
26704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26705       };
26706     } catch (...) {
26707       {
26708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26709       };
26710     }
26711   }
26712   jresult = (void *)result;
26713   return jresult;
26714 }
26715
26716
26717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26718   void * jresult ;
26719   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26720   Dali::GestureDetector *arg2 = 0 ;
26721   Dali::GestureDetector *result = 0 ;
26722
26723   arg1 = (Dali::GestureDetector *)jarg1;
26724   arg2 = (Dali::GestureDetector *)jarg2;
26725   if (!arg2) {
26726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26727     return 0;
26728   }
26729   {
26730     try {
26731       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26732     } catch (std::out_of_range& e) {
26733       {
26734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26735       };
26736     } catch (std::exception& e) {
26737       {
26738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26739       };
26740     } catch (...) {
26741       {
26742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26743       };
26744     }
26745   }
26746   jresult = (void *)result;
26747   return jresult;
26748 }
26749
26750
26751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26752   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26753   Dali::Actor arg2 ;
26754   Dali::Actor *argp2 ;
26755
26756   arg1 = (Dali::GestureDetector *)jarg1;
26757   argp2 = (Dali::Actor *)jarg2;
26758   if (!argp2) {
26759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26760     return ;
26761   }
26762   arg2 = *argp2;
26763   {
26764     try {
26765       (arg1)->Attach(arg2);
26766     } catch (std::out_of_range& e) {
26767       {
26768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26769       };
26770     } catch (std::exception& e) {
26771       {
26772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26773       };
26774     } catch (...) {
26775       {
26776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26777       };
26778     }
26779   }
26780 }
26781
26782
26783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26784   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26785   Dali::Actor arg2 ;
26786   Dali::Actor *argp2 ;
26787
26788   arg1 = (Dali::GestureDetector *)jarg1;
26789   argp2 = (Dali::Actor *)jarg2;
26790   if (!argp2) {
26791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26792     return ;
26793   }
26794   arg2 = *argp2;
26795   {
26796     try {
26797       (arg1)->Detach(arg2);
26798     } catch (std::out_of_range& e) {
26799       {
26800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26801       };
26802     } catch (std::exception& e) {
26803       {
26804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26805       };
26806     } catch (...) {
26807       {
26808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26809       };
26810     }
26811   }
26812 }
26813
26814
26815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26816   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26817
26818   arg1 = (Dali::GestureDetector *)jarg1;
26819   {
26820     try {
26821       (arg1)->DetachAll();
26822     } catch (std::out_of_range& e) {
26823       {
26824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26825       };
26826     } catch (std::exception& e) {
26827       {
26828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26829       };
26830     } catch (...) {
26831       {
26832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26833       };
26834     }
26835   }
26836 }
26837
26838
26839 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26840   unsigned long jresult ;
26841   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26842   size_t result;
26843
26844   arg1 = (Dali::GestureDetector *)jarg1;
26845   {
26846     try {
26847       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26848     } catch (std::out_of_range& e) {
26849       {
26850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26851       };
26852     } catch (std::exception& e) {
26853       {
26854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26855       };
26856     } catch (...) {
26857       {
26858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26859       };
26860     }
26861   }
26862   jresult = (unsigned long)result;
26863   return jresult;
26864 }
26865
26866
26867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26868   void * jresult ;
26869   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26870   size_t arg2 ;
26871   Dali::Actor result;
26872
26873   arg1 = (Dali::GestureDetector *)jarg1;
26874   arg2 = (size_t)jarg2;
26875   {
26876     try {
26877       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26878     } catch (std::out_of_range& e) {
26879       {
26880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26881       };
26882     } catch (std::exception& e) {
26883       {
26884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26885       };
26886     } catch (...) {
26887       {
26888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26889       };
26890     }
26891   }
26892   jresult = new Dali::Actor((const Dali::Actor &)result);
26893   return jresult;
26894 }
26895
26896
26897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26898   void * jresult ;
26899   Dali::Gesture *arg1 = 0 ;
26900   Dali::Gesture *result = 0 ;
26901
26902   arg1 = (Dali::Gesture *)jarg1;
26903   if (!arg1) {
26904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26905     return 0;
26906   }
26907   {
26908     try {
26909       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26910     } catch (std::out_of_range& e) {
26911       {
26912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26913       };
26914     } catch (std::exception& e) {
26915       {
26916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26917       };
26918     } catch (...) {
26919       {
26920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26921       };
26922     }
26923   }
26924   jresult = (void *)result;
26925   return jresult;
26926 }
26927
26928
26929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26930   void * jresult ;
26931   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26932   Dali::Gesture *arg2 = 0 ;
26933   Dali::Gesture *result = 0 ;
26934
26935   arg1 = (Dali::Gesture *)jarg1;
26936   arg2 = (Dali::Gesture *)jarg2;
26937   if (!arg2) {
26938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26939     return 0;
26940   }
26941   {
26942     try {
26943       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26944     } catch (std::out_of_range& e) {
26945       {
26946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26947       };
26948     } catch (std::exception& e) {
26949       {
26950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26951       };
26952     } catch (...) {
26953       {
26954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26955       };
26956     }
26957   }
26958   jresult = (void *)result;
26959   return jresult;
26960 }
26961
26962
26963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26964   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26965
26966   arg1 = (Dali::Gesture *)jarg1;
26967   {
26968     try {
26969       delete arg1;
26970     } catch (std::out_of_range& e) {
26971       {
26972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26973       };
26974     } catch (std::exception& e) {
26975       {
26976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26977       };
26978     } catch (...) {
26979       {
26980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26981       };
26982     }
26983   }
26984 }
26985
26986
26987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26988   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26989   Dali::Gesture::Type arg2 ;
26990
26991   arg1 = (Dali::Gesture *)jarg1;
26992   arg2 = (Dali::Gesture::Type)jarg2;
26993   if (arg1) (arg1)->type = arg2;
26994 }
26995
26996
26997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26998   int jresult ;
26999   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27000   Dali::Gesture::Type result;
27001
27002   arg1 = (Dali::Gesture *)jarg1;
27003   result = (Dali::Gesture::Type) ((arg1)->type);
27004   jresult = (int)result;
27005   return jresult;
27006 }
27007
27008
27009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
27010   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27011   Dali::Gesture::State arg2 ;
27012
27013   arg1 = (Dali::Gesture *)jarg1;
27014   arg2 = (Dali::Gesture::State)jarg2;
27015   if (arg1) (arg1)->state = arg2;
27016 }
27017
27018
27019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
27020   int jresult ;
27021   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27022   Dali::Gesture::State result;
27023
27024   arg1 = (Dali::Gesture *)jarg1;
27025   result = (Dali::Gesture::State) ((arg1)->state);
27026   jresult = (int)result;
27027   return jresult;
27028 }
27029
27030
27031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
27032   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27033   unsigned int arg2 ;
27034
27035   arg1 = (Dali::Gesture *)jarg1;
27036   arg2 = (unsigned int)jarg2;
27037   if (arg1) (arg1)->time = arg2;
27038 }
27039
27040
27041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
27042   unsigned int jresult ;
27043   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27044   unsigned int result;
27045
27046   arg1 = (Dali::Gesture *)jarg1;
27047   result = (unsigned int) ((arg1)->time);
27048   jresult = result;
27049   return jresult;
27050 }
27051
27052
27053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
27054   void * jresult ;
27055   Dali::HoverEvent *result = 0 ;
27056
27057   {
27058     try {
27059       result = (Dali::HoverEvent *)new Dali::HoverEvent();
27060     } catch (std::out_of_range& e) {
27061       {
27062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27063       };
27064     } catch (std::exception& e) {
27065       {
27066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27067       };
27068     } catch (...) {
27069       {
27070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27071       };
27072     }
27073   }
27074   jresult = (void *)result;
27075   return jresult;
27076 }
27077
27078
27079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
27080   void * jresult ;
27081   unsigned long arg1 ;
27082   Dali::HoverEvent *result = 0 ;
27083
27084   arg1 = (unsigned long)jarg1;
27085   {
27086     try {
27087       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
27088     } catch (std::out_of_range& e) {
27089       {
27090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27091       };
27092     } catch (std::exception& e) {
27093       {
27094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27095       };
27096     } catch (...) {
27097       {
27098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27099       };
27100     }
27101   }
27102   jresult = (void *)result;
27103   return jresult;
27104 }
27105
27106
27107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27108   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27109
27110   arg1 = (Dali::HoverEvent *)jarg1;
27111   {
27112     try {
27113       delete arg1;
27114     } catch (std::out_of_range& e) {
27115       {
27116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27117       };
27118     } catch (std::exception& e) {
27119       {
27120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27121       };
27122     } catch (...) {
27123       {
27124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27125       };
27126     }
27127   }
27128 }
27129
27130
27131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27132   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27133   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27134
27135   arg1 = (Dali::HoverEvent *)jarg1;
27136   arg2 = (Dali::TouchPointContainer *)jarg2;
27137   if (arg1) (arg1)->points = *arg2;
27138 }
27139
27140
27141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27142   void * jresult ;
27143   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27144   Dali::TouchPointContainer *result = 0 ;
27145
27146   arg1 = (Dali::HoverEvent *)jarg1;
27147   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27148   jresult = (void *)result;
27149   return jresult;
27150 }
27151
27152
27153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27154   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27155   unsigned long arg2 ;
27156
27157   arg1 = (Dali::HoverEvent *)jarg1;
27158   arg2 = (unsigned long)jarg2;
27159   if (arg1) (arg1)->time = arg2;
27160 }
27161
27162
27163 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27164   unsigned long jresult ;
27165   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27166   unsigned long result;
27167
27168   arg1 = (Dali::HoverEvent *)jarg1;
27169   result = (unsigned long) ((arg1)->time);
27170   jresult = (unsigned long)result;
27171   return jresult;
27172 }
27173
27174
27175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27176   unsigned int jresult ;
27177   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27178   unsigned int result;
27179
27180   arg1 = (Dali::HoverEvent *)jarg1;
27181   {
27182     try {
27183       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27184     } catch (std::out_of_range& e) {
27185       {
27186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27187       };
27188     } catch (std::exception& e) {
27189       {
27190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27191       };
27192     } catch (...) {
27193       {
27194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27195       };
27196     }
27197   }
27198   jresult = result;
27199   return jresult;
27200 }
27201
27202
27203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27204   void * jresult ;
27205   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27206   unsigned int arg2 ;
27207   Dali::TouchPoint *result = 0 ;
27208
27209   arg1 = (Dali::HoverEvent *)jarg1;
27210   arg2 = (unsigned int)jarg2;
27211   {
27212     try {
27213       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27214     } catch (std::out_of_range& e) {
27215       {
27216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27217       };
27218     } catch (std::exception& e) {
27219       {
27220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27221       };
27222     } catch (...) {
27223       {
27224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27225       };
27226     }
27227   }
27228   jresult = (void *)result;
27229   return jresult;
27230 }
27231
27232
27233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27234   void * jresult ;
27235   Dali::KeyEvent *result = 0 ;
27236
27237   {
27238     try {
27239       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27240     } catch (std::out_of_range& e) {
27241       {
27242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27243       };
27244     } catch (std::exception& e) {
27245       {
27246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27247       };
27248     } catch (...) {
27249       {
27250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27251       };
27252     }
27253   }
27254   jresult = (void *)result;
27255   return jresult;
27256 }
27257
27258
27259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27260   void * jresult ;
27261   std::string *arg1 = 0 ;
27262   std::string *arg2 = 0 ;
27263   int arg3 ;
27264   int arg4 ;
27265   unsigned long arg5 ;
27266   Dali::KeyEvent::State *arg6 = 0 ;
27267   Dali::KeyEvent::State temp6 ;
27268   Dali::KeyEvent *result = 0 ;
27269
27270   if (!jarg1) {
27271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27272     return 0;
27273   }
27274   std::string arg1_str(jarg1);
27275   arg1 = &arg1_str;
27276   if (!jarg2) {
27277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27278     return 0;
27279   }
27280   std::string arg2_str(jarg2);
27281   arg2 = &arg2_str;
27282   arg3 = (int)jarg3;
27283   arg4 = (int)jarg4;
27284   arg5 = (unsigned long)jarg5;
27285   temp6 = (Dali::KeyEvent::State)jarg6;
27286   arg6 = &temp6;
27287   {
27288     try {
27289       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27290     } catch (std::out_of_range& e) {
27291       {
27292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27293       };
27294     } catch (std::exception& e) {
27295       {
27296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27297       };
27298     } catch (...) {
27299       {
27300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27301       };
27302     }
27303   }
27304   jresult = (void *)result;
27305
27306   //argout typemap for const std::string&
27307
27308
27309   //argout typemap for const std::string&
27310
27311   return jresult;
27312 }
27313
27314
27315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27316   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27317
27318   arg1 = (Dali::KeyEvent *)jarg1;
27319   {
27320     try {
27321       delete arg1;
27322     } catch (std::out_of_range& e) {
27323       {
27324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27325       };
27326     } catch (std::exception& e) {
27327       {
27328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27329       };
27330     } catch (...) {
27331       {
27332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27333       };
27334     }
27335   }
27336 }
27337
27338
27339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27340   unsigned int jresult ;
27341   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27342   bool result;
27343
27344   arg1 = (Dali::KeyEvent *)jarg1;
27345   {
27346     try {
27347       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27348     } catch (std::out_of_range& e) {
27349       {
27350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27351       };
27352     } catch (std::exception& e) {
27353       {
27354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27355       };
27356     } catch (...) {
27357       {
27358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27359       };
27360     }
27361   }
27362   jresult = result;
27363   return jresult;
27364 }
27365
27366
27367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27368   unsigned int jresult ;
27369   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27370   bool result;
27371
27372   arg1 = (Dali::KeyEvent *)jarg1;
27373   {
27374     try {
27375       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27376     } catch (std::out_of_range& e) {
27377       {
27378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27379       };
27380     } catch (std::exception& e) {
27381       {
27382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27383       };
27384     } catch (...) {
27385       {
27386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27387       };
27388     }
27389   }
27390   jresult = result;
27391   return jresult;
27392 }
27393
27394
27395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27396   unsigned int jresult ;
27397   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27398   bool result;
27399
27400   arg1 = (Dali::KeyEvent *)jarg1;
27401   {
27402     try {
27403       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27404     } catch (std::out_of_range& e) {
27405       {
27406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27407       };
27408     } catch (std::exception& e) {
27409       {
27410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27411       };
27412     } catch (...) {
27413       {
27414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27415       };
27416     }
27417   }
27418   jresult = result;
27419   return jresult;
27420 }
27421
27422
27423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27424   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27425   std::string *arg2 = 0 ;
27426
27427   arg1 = (Dali::KeyEvent *)jarg1;
27428   if (!jarg2) {
27429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27430     return ;
27431   }
27432   std::string arg2_str(jarg2);
27433   arg2 = &arg2_str;
27434   if (arg1) (arg1)->keyPressedName = *arg2;
27435
27436   //argout typemap for const std::string&
27437
27438 }
27439
27440
27441 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27442   char * jresult ;
27443   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27444   std::string *result = 0 ;
27445
27446   arg1 = (Dali::KeyEvent *)jarg1;
27447   result = (std::string *) & ((arg1)->keyPressedName);
27448   jresult = SWIG_csharp_string_callback(result->c_str());
27449   return jresult;
27450 }
27451
27452
27453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27454   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27455   std::string *arg2 = 0 ;
27456
27457   arg1 = (Dali::KeyEvent *)jarg1;
27458   if (!jarg2) {
27459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27460     return ;
27461   }
27462   std::string arg2_str(jarg2);
27463   arg2 = &arg2_str;
27464   if (arg1) (arg1)->keyPressed = *arg2;
27465
27466   //argout typemap for const std::string&
27467
27468 }
27469
27470
27471 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27472   char * jresult ;
27473   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27474   std::string *result = 0 ;
27475
27476   arg1 = (Dali::KeyEvent *)jarg1;
27477   result = (std::string *) & ((arg1)->keyPressed);
27478   jresult = SWIG_csharp_string_callback(result->c_str());
27479   return jresult;
27480 }
27481
27482
27483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27484   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27485   int arg2 ;
27486
27487   arg1 = (Dali::KeyEvent *)jarg1;
27488   arg2 = (int)jarg2;
27489   if (arg1) (arg1)->keyCode = arg2;
27490 }
27491
27492
27493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27494   int jresult ;
27495   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27496   int result;
27497
27498   arg1 = (Dali::KeyEvent *)jarg1;
27499   result = (int) ((arg1)->keyCode);
27500   jresult = result;
27501   return jresult;
27502 }
27503
27504
27505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27506   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27507   int arg2 ;
27508
27509   arg1 = (Dali::KeyEvent *)jarg1;
27510   arg2 = (int)jarg2;
27511   if (arg1) (arg1)->keyModifier = arg2;
27512 }
27513
27514
27515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27516   int jresult ;
27517   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27518   int result;
27519
27520   arg1 = (Dali::KeyEvent *)jarg1;
27521   result = (int) ((arg1)->keyModifier);
27522   jresult = result;
27523   return jresult;
27524 }
27525
27526
27527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27528   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27529   unsigned long arg2 ;
27530
27531   arg1 = (Dali::KeyEvent *)jarg1;
27532   arg2 = (unsigned long)jarg2;
27533   if (arg1) (arg1)->time = arg2;
27534 }
27535
27536
27537 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27538   unsigned long jresult ;
27539   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27540   unsigned long result;
27541
27542   arg1 = (Dali::KeyEvent *)jarg1;
27543   result = (unsigned long) ((arg1)->time);
27544   jresult = (unsigned long)result;
27545   return jresult;
27546 }
27547
27548
27549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27550   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27551   Dali::KeyEvent::State arg2 ;
27552
27553   arg1 = (Dali::KeyEvent *)jarg1;
27554   arg2 = (Dali::KeyEvent::State)jarg2;
27555   if (arg1) (arg1)->state = arg2;
27556 }
27557
27558
27559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27560   int jresult ;
27561   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27562   Dali::KeyEvent::State result;
27563
27564   arg1 = (Dali::KeyEvent *)jarg1;
27565   result = (Dali::KeyEvent::State) ((arg1)->state);
27566   jresult = (int)result;
27567   return jresult;
27568 }
27569
27570
27571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27572   void * jresult ;
27573   Dali::LongPressGestureDetector *result = 0 ;
27574
27575   {
27576     try {
27577       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27578     } catch (std::out_of_range& e) {
27579       {
27580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27581       };
27582     } catch (std::exception& e) {
27583       {
27584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27585       };
27586     } catch (...) {
27587       {
27588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27589       };
27590     }
27591   }
27592   jresult = (void *)result;
27593   return jresult;
27594 }
27595
27596
27597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27598   void * jresult ;
27599   Dali::LongPressGestureDetector result;
27600
27601   {
27602     try {
27603       result = Dali::LongPressGestureDetector::New();
27604     } catch (std::out_of_range& e) {
27605       {
27606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27607       };
27608     } catch (std::exception& e) {
27609       {
27610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27611       };
27612     } catch (...) {
27613       {
27614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27615       };
27616     }
27617   }
27618   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27619   return jresult;
27620 }
27621
27622
27623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27624   void * jresult ;
27625   unsigned int arg1 ;
27626   Dali::LongPressGestureDetector result;
27627
27628   arg1 = (unsigned int)jarg1;
27629   {
27630     try {
27631       result = Dali::LongPressGestureDetector::New(arg1);
27632     } catch (std::out_of_range& e) {
27633       {
27634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27635       };
27636     } catch (std::exception& e) {
27637       {
27638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27639       };
27640     } catch (...) {
27641       {
27642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27643       };
27644     }
27645   }
27646   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27647   return jresult;
27648 }
27649
27650
27651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27652   void * jresult ;
27653   unsigned int arg1 ;
27654   unsigned int arg2 ;
27655   Dali::LongPressGestureDetector result;
27656
27657   arg1 = (unsigned int)jarg1;
27658   arg2 = (unsigned int)jarg2;
27659   {
27660     try {
27661       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27662     } catch (std::out_of_range& e) {
27663       {
27664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27665       };
27666     } catch (std::exception& e) {
27667       {
27668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27669       };
27670     } catch (...) {
27671       {
27672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27673       };
27674     }
27675   }
27676   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27677   return jresult;
27678 }
27679
27680
27681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27682   void * jresult ;
27683   Dali::BaseHandle arg1 ;
27684   Dali::BaseHandle *argp1 ;
27685   Dali::LongPressGestureDetector result;
27686
27687   argp1 = (Dali::BaseHandle *)jarg1;
27688   if (!argp1) {
27689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27690     return 0;
27691   }
27692   arg1 = *argp1;
27693   {
27694     try {
27695       result = Dali::LongPressGestureDetector::DownCast(arg1);
27696     } catch (std::out_of_range& e) {
27697       {
27698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27699       };
27700     } catch (std::exception& e) {
27701       {
27702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27703       };
27704     } catch (...) {
27705       {
27706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27707       };
27708     }
27709   }
27710   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27711   return jresult;
27712 }
27713
27714
27715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27716   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27717
27718   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27719   {
27720     try {
27721       delete arg1;
27722     } catch (std::out_of_range& e) {
27723       {
27724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27725       };
27726     } catch (std::exception& e) {
27727       {
27728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27729       };
27730     } catch (...) {
27731       {
27732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27733       };
27734     }
27735   }
27736 }
27737
27738
27739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27740   void * jresult ;
27741   Dali::LongPressGestureDetector *arg1 = 0 ;
27742   Dali::LongPressGestureDetector *result = 0 ;
27743
27744   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27745   if (!arg1) {
27746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27747     return 0;
27748   }
27749   {
27750     try {
27751       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27752     } catch (std::out_of_range& e) {
27753       {
27754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27755       };
27756     } catch (std::exception& e) {
27757       {
27758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27759       };
27760     } catch (...) {
27761       {
27762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27763       };
27764     }
27765   }
27766   jresult = (void *)result;
27767   return jresult;
27768 }
27769
27770
27771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27772   void * jresult ;
27773   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27774   Dali::LongPressGestureDetector *arg2 = 0 ;
27775   Dali::LongPressGestureDetector *result = 0 ;
27776
27777   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27778   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27779   if (!arg2) {
27780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27781     return 0;
27782   }
27783   {
27784     try {
27785       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27786     } catch (std::out_of_range& e) {
27787       {
27788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27789       };
27790     } catch (std::exception& e) {
27791       {
27792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27793       };
27794     } catch (...) {
27795       {
27796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27797       };
27798     }
27799   }
27800   jresult = (void *)result;
27801   return jresult;
27802 }
27803
27804
27805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27806   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27807   unsigned int arg2 ;
27808
27809   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27810   arg2 = (unsigned int)jarg2;
27811   {
27812     try {
27813       (arg1)->SetTouchesRequired(arg2);
27814     } catch (std::out_of_range& e) {
27815       {
27816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27817       };
27818     } catch (std::exception& e) {
27819       {
27820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27821       };
27822     } catch (...) {
27823       {
27824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27825       };
27826     }
27827   }
27828 }
27829
27830
27831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27832   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27833   unsigned int arg2 ;
27834   unsigned int arg3 ;
27835
27836   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27837   arg2 = (unsigned int)jarg2;
27838   arg3 = (unsigned int)jarg3;
27839   {
27840     try {
27841       (arg1)->SetTouchesRequired(arg2,arg3);
27842     } catch (std::out_of_range& e) {
27843       {
27844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27845       };
27846     } catch (std::exception& e) {
27847       {
27848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27849       };
27850     } catch (...) {
27851       {
27852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27853       };
27854     }
27855   }
27856 }
27857
27858
27859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27860   unsigned int jresult ;
27861   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27862   unsigned int result;
27863
27864   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27865   {
27866     try {
27867       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27868     } catch (std::out_of_range& e) {
27869       {
27870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27871       };
27872     } catch (std::exception& e) {
27873       {
27874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27875       };
27876     } catch (...) {
27877       {
27878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27879       };
27880     }
27881   }
27882   jresult = result;
27883   return jresult;
27884 }
27885
27886
27887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27888   unsigned int jresult ;
27889   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27890   unsigned int result;
27891
27892   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27893   {
27894     try {
27895       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27896     } catch (std::out_of_range& e) {
27897       {
27898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27899       };
27900     } catch (std::exception& e) {
27901       {
27902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27903       };
27904     } catch (...) {
27905       {
27906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27907       };
27908     }
27909   }
27910   jresult = result;
27911   return jresult;
27912 }
27913
27914
27915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27916   void * jresult ;
27917   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27918   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27919
27920   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27921   {
27922     try {
27923       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27924     } catch (std::out_of_range& e) {
27925       {
27926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27927       };
27928     } catch (std::exception& e) {
27929       {
27930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27931       };
27932     } catch (...) {
27933       {
27934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27935       };
27936     }
27937   }
27938   jresult = (void *)result;
27939   return jresult;
27940 }
27941
27942
27943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27944   void * jresult ;
27945   Dali::Gesture::State arg1 ;
27946   Dali::LongPressGesture *result = 0 ;
27947
27948   arg1 = (Dali::Gesture::State)jarg1;
27949   {
27950     try {
27951       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27952     } catch (std::out_of_range& e) {
27953       {
27954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27955       };
27956     } catch (std::exception& e) {
27957       {
27958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27959       };
27960     } catch (...) {
27961       {
27962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27963       };
27964     }
27965   }
27966   jresult = (void *)result;
27967   return jresult;
27968 }
27969
27970
27971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27972   void * jresult ;
27973   Dali::LongPressGesture *arg1 = 0 ;
27974   Dali::LongPressGesture *result = 0 ;
27975
27976   arg1 = (Dali::LongPressGesture *)jarg1;
27977   if (!arg1) {
27978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27979     return 0;
27980   }
27981   {
27982     try {
27983       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27984     } catch (std::out_of_range& e) {
27985       {
27986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27987       };
27988     } catch (std::exception& e) {
27989       {
27990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27991       };
27992     } catch (...) {
27993       {
27994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27995       };
27996     }
27997   }
27998   jresult = (void *)result;
27999   return jresult;
28000 }
28001
28002
28003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
28004   void * jresult ;
28005   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28006   Dali::LongPressGesture *arg2 = 0 ;
28007   Dali::LongPressGesture *result = 0 ;
28008
28009   arg1 = (Dali::LongPressGesture *)jarg1;
28010   arg2 = (Dali::LongPressGesture *)jarg2;
28011   if (!arg2) {
28012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28013     return 0;
28014   }
28015   {
28016     try {
28017       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
28018     } catch (std::out_of_range& e) {
28019       {
28020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28021       };
28022     } catch (std::exception& e) {
28023       {
28024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28025       };
28026     } catch (...) {
28027       {
28028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28029       };
28030     }
28031   }
28032   jresult = (void *)result;
28033   return jresult;
28034 }
28035
28036
28037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28038   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28039
28040   arg1 = (Dali::LongPressGesture *)jarg1;
28041   {
28042     try {
28043       delete arg1;
28044     } catch (std::out_of_range& e) {
28045       {
28046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28047       };
28048     } catch (std::exception& e) {
28049       {
28050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28051       };
28052     } catch (...) {
28053       {
28054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28055       };
28056     }
28057   }
28058 }
28059
28060
28061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28062   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28063   unsigned int arg2 ;
28064
28065   arg1 = (Dali::LongPressGesture *)jarg1;
28066   arg2 = (unsigned int)jarg2;
28067   if (arg1) (arg1)->numberOfTouches = arg2;
28068 }
28069
28070
28071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28072   unsigned int jresult ;
28073   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28074   unsigned int result;
28075
28076   arg1 = (Dali::LongPressGesture *)jarg1;
28077   result = (unsigned int) ((arg1)->numberOfTouches);
28078   jresult = result;
28079   return jresult;
28080 }
28081
28082
28083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28084   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28085   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28086
28087   arg1 = (Dali::LongPressGesture *)jarg1;
28088   arg2 = (Dali::Vector2 *)jarg2;
28089   if (arg1) (arg1)->screenPoint = *arg2;
28090 }
28091
28092
28093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28094   void * jresult ;
28095   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28096   Dali::Vector2 *result = 0 ;
28097
28098   arg1 = (Dali::LongPressGesture *)jarg1;
28099   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28100   jresult = (void *)result;
28101   return jresult;
28102 }
28103
28104
28105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28106   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28107   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28108
28109   arg1 = (Dali::LongPressGesture *)jarg1;
28110   arg2 = (Dali::Vector2 *)jarg2;
28111   if (arg1) (arg1)->localPoint = *arg2;
28112 }
28113
28114
28115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28116   void * jresult ;
28117   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28118   Dali::Vector2 *result = 0 ;
28119
28120   arg1 = (Dali::LongPressGesture *)jarg1;
28121   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28122   jresult = (void *)result;
28123   return jresult;
28124 }
28125
28126
28127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28128   void * jresult ;
28129   Dali::WheelEvent *result = 0 ;
28130
28131   {
28132     try {
28133       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28134     } catch (std::out_of_range& e) {
28135       {
28136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28137       };
28138     } catch (std::exception& e) {
28139       {
28140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28141       };
28142     } catch (...) {
28143       {
28144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28145       };
28146     }
28147   }
28148   jresult = (void *)result;
28149   return jresult;
28150 }
28151
28152
28153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28154   void * jresult ;
28155   Dali::WheelEvent::Type arg1 ;
28156   int arg2 ;
28157   unsigned int arg3 ;
28158   Dali::Vector2 arg4 ;
28159   int arg5 ;
28160   unsigned int arg6 ;
28161   Dali::Vector2 *argp4 ;
28162   Dali::WheelEvent *result = 0 ;
28163
28164   arg1 = (Dali::WheelEvent::Type)jarg1;
28165   arg2 = (int)jarg2;
28166   arg3 = (unsigned int)jarg3;
28167   argp4 = (Dali::Vector2 *)jarg4;
28168   if (!argp4) {
28169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28170     return 0;
28171   }
28172   arg4 = *argp4;
28173   arg5 = (int)jarg5;
28174   arg6 = (unsigned int)jarg6;
28175   {
28176     try {
28177       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28178     } catch (std::out_of_range& e) {
28179       {
28180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28181       };
28182     } catch (std::exception& e) {
28183       {
28184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28185       };
28186     } catch (...) {
28187       {
28188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28189       };
28190     }
28191   }
28192   jresult = (void *)result;
28193   return jresult;
28194 }
28195
28196
28197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28198   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28199
28200   arg1 = (Dali::WheelEvent *)jarg1;
28201   {
28202     try {
28203       delete arg1;
28204     } catch (std::out_of_range& e) {
28205       {
28206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28207       };
28208     } catch (std::exception& e) {
28209       {
28210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28211       };
28212     } catch (...) {
28213       {
28214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28215       };
28216     }
28217   }
28218 }
28219
28220
28221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28222   unsigned int jresult ;
28223   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28224   bool result;
28225
28226   arg1 = (Dali::WheelEvent *)jarg1;
28227   {
28228     try {
28229       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28230     } catch (std::out_of_range& e) {
28231       {
28232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28233       };
28234     } catch (std::exception& e) {
28235       {
28236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28237       };
28238     } catch (...) {
28239       {
28240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28241       };
28242     }
28243   }
28244   jresult = result;
28245   return jresult;
28246 }
28247
28248
28249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28250   unsigned int jresult ;
28251   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28252   bool result;
28253
28254   arg1 = (Dali::WheelEvent *)jarg1;
28255   {
28256     try {
28257       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28258     } catch (std::out_of_range& e) {
28259       {
28260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28261       };
28262     } catch (std::exception& e) {
28263       {
28264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28265       };
28266     } catch (...) {
28267       {
28268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28269       };
28270     }
28271   }
28272   jresult = result;
28273   return jresult;
28274 }
28275
28276
28277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28278   unsigned int jresult ;
28279   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28280   bool result;
28281
28282   arg1 = (Dali::WheelEvent *)jarg1;
28283   {
28284     try {
28285       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28286     } catch (std::out_of_range& e) {
28287       {
28288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28289       };
28290     } catch (std::exception& e) {
28291       {
28292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28293       };
28294     } catch (...) {
28295       {
28296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28297       };
28298     }
28299   }
28300   jresult = result;
28301   return jresult;
28302 }
28303
28304
28305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28306   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28307   Dali::WheelEvent::Type arg2 ;
28308
28309   arg1 = (Dali::WheelEvent *)jarg1;
28310   arg2 = (Dali::WheelEvent::Type)jarg2;
28311   if (arg1) (arg1)->type = arg2;
28312 }
28313
28314
28315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28316   int jresult ;
28317   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28318   Dali::WheelEvent::Type result;
28319
28320   arg1 = (Dali::WheelEvent *)jarg1;
28321   result = (Dali::WheelEvent::Type) ((arg1)->type);
28322   jresult = (int)result;
28323   return jresult;
28324 }
28325
28326
28327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28328   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28329   int arg2 ;
28330
28331   arg1 = (Dali::WheelEvent *)jarg1;
28332   arg2 = (int)jarg2;
28333   if (arg1) (arg1)->direction = arg2;
28334 }
28335
28336
28337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28338   int jresult ;
28339   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28340   int result;
28341
28342   arg1 = (Dali::WheelEvent *)jarg1;
28343   result = (int) ((arg1)->direction);
28344   jresult = result;
28345   return jresult;
28346 }
28347
28348
28349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28350   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28351   unsigned int arg2 ;
28352
28353   arg1 = (Dali::WheelEvent *)jarg1;
28354   arg2 = (unsigned int)jarg2;
28355   if (arg1) (arg1)->modifiers = arg2;
28356 }
28357
28358
28359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28360   unsigned int jresult ;
28361   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28362   unsigned int result;
28363
28364   arg1 = (Dali::WheelEvent *)jarg1;
28365   result = (unsigned int) ((arg1)->modifiers);
28366   jresult = result;
28367   return jresult;
28368 }
28369
28370
28371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28372   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28373   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28374
28375   arg1 = (Dali::WheelEvent *)jarg1;
28376   arg2 = (Dali::Vector2 *)jarg2;
28377   if (arg1) (arg1)->point = *arg2;
28378 }
28379
28380
28381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28382   void * jresult ;
28383   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28384   Dali::Vector2 *result = 0 ;
28385
28386   arg1 = (Dali::WheelEvent *)jarg1;
28387   result = (Dali::Vector2 *)& ((arg1)->point);
28388   jresult = (void *)result;
28389   return jresult;
28390 }
28391
28392
28393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28394   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28395   int arg2 ;
28396
28397   arg1 = (Dali::WheelEvent *)jarg1;
28398   arg2 = (int)jarg2;
28399   if (arg1) (arg1)->z = arg2;
28400 }
28401
28402
28403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28404   int jresult ;
28405   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28406   int result;
28407
28408   arg1 = (Dali::WheelEvent *)jarg1;
28409   result = (int) ((arg1)->z);
28410   jresult = result;
28411   return jresult;
28412 }
28413
28414
28415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28416   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28417   unsigned int arg2 ;
28418
28419   arg1 = (Dali::WheelEvent *)jarg1;
28420   arg2 = (unsigned int)jarg2;
28421   if (arg1) (arg1)->timeStamp = arg2;
28422 }
28423
28424
28425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28426   unsigned int jresult ;
28427   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28428   unsigned int result;
28429
28430   arg1 = (Dali::WheelEvent *)jarg1;
28431   result = (unsigned int) ((arg1)->timeStamp);
28432   jresult = result;
28433   return jresult;
28434 }
28435
28436
28437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28438   int jresult ;
28439   int result;
28440
28441   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28442   jresult = (int)result;
28443   return jresult;
28444 }
28445
28446
28447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28448   int jresult ;
28449   int result;
28450
28451   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28452   jresult = (int)result;
28453   return jresult;
28454 }
28455
28456
28457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28458   int jresult ;
28459   int result;
28460
28461   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28462   jresult = (int)result;
28463   return jresult;
28464 }
28465
28466
28467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28468   int jresult ;
28469   int result;
28470
28471   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28472   jresult = (int)result;
28473   return jresult;
28474 }
28475
28476
28477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28478   int jresult ;
28479   int result;
28480
28481   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28482   jresult = (int)result;
28483   return jresult;
28484 }
28485
28486
28487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28488   int jresult ;
28489   int result;
28490
28491   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28492   jresult = (int)result;
28493   return jresult;
28494 }
28495
28496
28497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28498   int jresult ;
28499   int result;
28500
28501   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28502   jresult = (int)result;
28503   return jresult;
28504 }
28505
28506
28507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28508   int jresult ;
28509   int result;
28510
28511   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28512   jresult = (int)result;
28513   return jresult;
28514 }
28515
28516
28517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28518   int jresult ;
28519   int result;
28520
28521   result = (int)Dali::Actor::Property::SIZE;
28522   jresult = (int)result;
28523   return jresult;
28524 }
28525
28526
28527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28528   int jresult ;
28529   int result;
28530
28531   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28532   jresult = (int)result;
28533   return jresult;
28534 }
28535
28536
28537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28538   int jresult ;
28539   int result;
28540
28541   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28542   jresult = (int)result;
28543   return jresult;
28544 }
28545
28546
28547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28548   int jresult ;
28549   int result;
28550
28551   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28552   jresult = (int)result;
28553   return jresult;
28554 }
28555
28556
28557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28558   int jresult ;
28559   int result;
28560
28561   result = (int)Dali::Actor::Property::POSITION;
28562   jresult = (int)result;
28563   return jresult;
28564 }
28565
28566
28567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28568   int jresult ;
28569   int result;
28570
28571   result = (int)Dali::Actor::Property::POSITION_X;
28572   jresult = (int)result;
28573   return jresult;
28574 }
28575
28576
28577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28578   int jresult ;
28579   int result;
28580
28581   result = (int)Dali::Actor::Property::POSITION_Y;
28582   jresult = (int)result;
28583   return jresult;
28584 }
28585
28586
28587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28588   int jresult ;
28589   int result;
28590
28591   result = (int)Dali::Actor::Property::POSITION_Z;
28592   jresult = (int)result;
28593   return jresult;
28594 }
28595
28596
28597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28598   int jresult ;
28599   int result;
28600
28601   result = (int)Dali::Actor::Property::WORLD_POSITION;
28602   jresult = (int)result;
28603   return jresult;
28604 }
28605
28606
28607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28608   int jresult ;
28609   int result;
28610
28611   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28612   jresult = (int)result;
28613   return jresult;
28614 }
28615
28616
28617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28618   int jresult ;
28619   int result;
28620
28621   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28622   jresult = (int)result;
28623   return jresult;
28624 }
28625
28626
28627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28628   int jresult ;
28629   int result;
28630
28631   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28632   jresult = (int)result;
28633   return jresult;
28634 }
28635
28636
28637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28638   int jresult ;
28639   int result;
28640
28641   result = (int)Dali::Actor::Property::ORIENTATION;
28642   jresult = (int)result;
28643   return jresult;
28644 }
28645
28646
28647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28648   int jresult ;
28649   int result;
28650
28651   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28652   jresult = (int)result;
28653   return jresult;
28654 }
28655
28656
28657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28658   int jresult ;
28659   int result;
28660
28661   result = (int)Dali::Actor::Property::SCALE;
28662   jresult = (int)result;
28663   return jresult;
28664 }
28665
28666
28667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28668   int jresult ;
28669   int result;
28670
28671   result = (int)Dali::Actor::Property::SCALE_X;
28672   jresult = (int)result;
28673   return jresult;
28674 }
28675
28676
28677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28678   int jresult ;
28679   int result;
28680
28681   result = (int)Dali::Actor::Property::SCALE_Y;
28682   jresult = (int)result;
28683   return jresult;
28684 }
28685
28686
28687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28688   int jresult ;
28689   int result;
28690
28691   result = (int)Dali::Actor::Property::SCALE_Z;
28692   jresult = (int)result;
28693   return jresult;
28694 }
28695
28696
28697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28698   int jresult ;
28699   int result;
28700
28701   result = (int)Dali::Actor::Property::WORLD_SCALE;
28702   jresult = (int)result;
28703   return jresult;
28704 }
28705
28706
28707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28708   int jresult ;
28709   int result;
28710
28711   result = (int)Dali::Actor::Property::VISIBLE;
28712   jresult = (int)result;
28713   return jresult;
28714 }
28715
28716
28717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28718   int jresult ;
28719   int result;
28720
28721   result = (int)Dali::Actor::Property::COLOR;
28722   jresult = (int)result;
28723   return jresult;
28724 }
28725
28726
28727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28728   int jresult ;
28729   int result;
28730
28731   result = (int)Dali::Actor::Property::COLOR_RED;
28732   jresult = (int)result;
28733   return jresult;
28734 }
28735
28736
28737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28738   int jresult ;
28739   int result;
28740
28741   result = (int)Dali::Actor::Property::COLOR_GREEN;
28742   jresult = (int)result;
28743   return jresult;
28744 }
28745
28746
28747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28748   int jresult ;
28749   int result;
28750
28751   result = (int)Dali::Actor::Property::COLOR_BLUE;
28752   jresult = (int)result;
28753   return jresult;
28754 }
28755
28756
28757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
28758   int jresult ;
28759   int result;
28760
28761   result = (int)Dali::Actor::Property::COLOR_ALPHA;
28762   jresult = (int)result;
28763   return jresult;
28764 }
28765
28766
28767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
28768   int jresult ;
28769   int result;
28770
28771   result = (int)Dali::Actor::Property::WORLD_COLOR;
28772   jresult = (int)result;
28773   return jresult;
28774 }
28775
28776
28777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
28778   int jresult ;
28779   int result;
28780
28781   result = (int)Dali::Actor::Property::WORLD_MATRIX;
28782   jresult = (int)result;
28783   return jresult;
28784 }
28785
28786
28787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
28788   int jresult ;
28789   int result;
28790
28791   result = (int)Dali::Actor::Property::NAME;
28792   jresult = (int)result;
28793   return jresult;
28794 }
28795
28796
28797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
28798   int jresult ;
28799   int result;
28800
28801   result = (int)Dali::Actor::Property::SENSITIVE;
28802   jresult = (int)result;
28803   return jresult;
28804 }
28805
28806
28807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
28808   int jresult ;
28809   int result;
28810
28811   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
28812   jresult = (int)result;
28813   return jresult;
28814 }
28815
28816
28817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
28818   int jresult ;
28819   int result;
28820
28821   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
28822   jresult = (int)result;
28823   return jresult;
28824 }
28825
28826
28827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
28828   int jresult ;
28829   int result;
28830
28831   result = (int)Dali::Actor::Property::INHERIT_SCALE;
28832   jresult = (int)result;
28833   return jresult;
28834 }
28835
28836
28837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
28838   int jresult ;
28839   int result;
28840
28841   result = (int)Dali::Actor::Property::COLOR_MODE;
28842   jresult = (int)result;
28843   return jresult;
28844 }
28845
28846
28847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
28848   int jresult ;
28849   int result;
28850
28851   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
28852   jresult = (int)result;
28853   return jresult;
28854 }
28855
28856
28857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
28858   int jresult ;
28859   int result;
28860
28861   result = (int)Dali::Actor::Property::DRAW_MODE;
28862   jresult = (int)result;
28863   return jresult;
28864 }
28865
28866
28867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
28868   int jresult ;
28869   int result;
28870
28871   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
28872   jresult = (int)result;
28873   return jresult;
28874 }
28875
28876
28877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
28878   int jresult ;
28879   int result;
28880
28881   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
28882   jresult = (int)result;
28883   return jresult;
28884 }
28885
28886
28887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
28888   int jresult ;
28889   int result;
28890
28891   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
28892   jresult = (int)result;
28893   return jresult;
28894 }
28895
28896
28897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
28898   int jresult ;
28899   int result;
28900
28901   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
28902   jresult = (int)result;
28903   return jresult;
28904 }
28905
28906
28907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
28908   int jresult ;
28909   int result;
28910
28911   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
28912   jresult = (int)result;
28913   return jresult;
28914 }
28915
28916
28917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
28918   int jresult ;
28919   int result;
28920
28921   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
28922   jresult = (int)result;
28923   return jresult;
28924 }
28925
28926
28927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
28928   int jresult ;
28929   int result;
28930
28931   result = (int)Dali::Actor::Property::PADDING;
28932   jresult = (int)result;
28933   return jresult;
28934 }
28935
28936
28937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
28938   int jresult ;
28939   int result;
28940
28941   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
28942   jresult = (int)result;
28943   return jresult;
28944 }
28945
28946
28947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
28948   int jresult ;
28949   int result;
28950
28951   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
28952   jresult = (int)result;
28953   return jresult;
28954 }
28955
28956
28957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
28958   int jresult ;
28959   int result;
28960
28961   result = (int)Dali::Actor::Property::INHERIT_POSITION;
28962   jresult = (int)result;
28963   return jresult;
28964 }
28965
28966
28967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
28968   int jresult ;
28969   int result;
28970
28971   result = (int)Dali::Actor::Property::CLIPPING_MODE;
28972   jresult = (int)result;
28973   return jresult;
28974 }
28975
28976
28977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
28978   void * jresult ;
28979   Dali::Actor::Property *result = 0 ;
28980
28981   {
28982     try {
28983       result = (Dali::Actor::Property *)new Dali::Actor::Property();
28984     } catch (std::out_of_range& e) {
28985       {
28986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28987       };
28988     } catch (std::exception& e) {
28989       {
28990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28991       };
28992     } catch (...) {
28993       {
28994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28995       };
28996     }
28997   }
28998   jresult = (void *)result;
28999   return jresult;
29000 }
29001
29002
29003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29004   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29005
29006   arg1 = (Dali::Actor::Property *)jarg1;
29007   {
29008     try {
29009       delete arg1;
29010     } catch (std::out_of_range& e) {
29011       {
29012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29013       };
29014     } catch (std::exception& e) {
29015       {
29016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29017       };
29018     } catch (...) {
29019       {
29020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29021       };
29022     }
29023   }
29024 }
29025
29026
29027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29028   void * jresult ;
29029   Dali::Actor *result = 0 ;
29030
29031   {
29032     try {
29033       result = (Dali::Actor *)new Dali::Actor();
29034     } catch (std::out_of_range& e) {
29035       {
29036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29037       };
29038     } catch (std::exception& e) {
29039       {
29040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29041       };
29042     } catch (...) {
29043       {
29044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29045       };
29046     }
29047   }
29048   jresult = (void *)result;
29049   return jresult;
29050 }
29051
29052
29053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29054   void * jresult ;
29055   Dali::Actor result;
29056
29057   {
29058     try {
29059       result = Dali::Actor::New();
29060     } catch (std::out_of_range& e) {
29061       {
29062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29063       };
29064     } catch (std::exception& e) {
29065       {
29066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29067       };
29068     } catch (...) {
29069       {
29070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29071       };
29072     }
29073   }
29074   jresult = new Dali::Actor((const Dali::Actor &)result);
29075   return jresult;
29076 }
29077
29078
29079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29080   void * jresult ;
29081   Dali::BaseHandle arg1 ;
29082   Dali::BaseHandle *argp1 ;
29083   Dali::Actor result;
29084
29085   argp1 = (Dali::BaseHandle *)jarg1;
29086   if (!argp1) {
29087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29088     return 0;
29089   }
29090   arg1 = *argp1;
29091   {
29092     try {
29093       result = Dali::Actor::DownCast(arg1);
29094     } catch (std::out_of_range& e) {
29095       {
29096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29097       };
29098     } catch (std::exception& e) {
29099       {
29100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29101       };
29102     } catch (...) {
29103       {
29104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29105       };
29106     }
29107   }
29108   jresult = new Dali::Actor((const Dali::Actor &)result);
29109   return jresult;
29110 }
29111
29112
29113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29114   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29115
29116   arg1 = (Dali::Actor *)jarg1;
29117   {
29118     try {
29119       delete arg1;
29120     } catch (std::out_of_range& e) {
29121       {
29122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29123       };
29124     } catch (std::exception& e) {
29125       {
29126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29127       };
29128     } catch (...) {
29129       {
29130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29131       };
29132     }
29133   }
29134 }
29135
29136
29137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29138   void * jresult ;
29139   Dali::Actor *arg1 = 0 ;
29140   Dali::Actor *result = 0 ;
29141
29142   arg1 = (Dali::Actor *)jarg1;
29143   if (!arg1) {
29144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29145     return 0;
29146   }
29147   {
29148     try {
29149       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29150     } catch (std::out_of_range& e) {
29151       {
29152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29153       };
29154     } catch (std::exception& e) {
29155       {
29156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29157       };
29158     } catch (...) {
29159       {
29160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29161       };
29162     }
29163   }
29164   jresult = (void *)result;
29165   return jresult;
29166 }
29167
29168
29169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29170   void * jresult ;
29171   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29172   Dali::Actor *arg2 = 0 ;
29173   Dali::Actor *result = 0 ;
29174
29175   arg1 = (Dali::Actor *)jarg1;
29176   arg2 = (Dali::Actor *)jarg2;
29177   if (!arg2) {
29178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29179     return 0;
29180   }
29181   {
29182     try {
29183       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29184     } catch (std::out_of_range& e) {
29185       {
29186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29187       };
29188     } catch (std::exception& e) {
29189       {
29190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29191       };
29192     } catch (...) {
29193       {
29194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29195       };
29196     }
29197   }
29198   jresult = (void *)result;
29199   return jresult;
29200 }
29201
29202
29203 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29204   char * jresult ;
29205   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29206   std::string *result = 0 ;
29207
29208   arg1 = (Dali::Actor *)jarg1;
29209   {
29210     try {
29211       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29212     } catch (std::out_of_range& e) {
29213       {
29214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29215       };
29216     } catch (std::exception& e) {
29217       {
29218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29219       };
29220     } catch (...) {
29221       {
29222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29223       };
29224     }
29225   }
29226   jresult = SWIG_csharp_string_callback(result->c_str());
29227   return jresult;
29228 }
29229
29230
29231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29232   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29233   std::string *arg2 = 0 ;
29234
29235   arg1 = (Dali::Actor *)jarg1;
29236   if (!jarg2) {
29237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29238     return ;
29239   }
29240   std::string arg2_str(jarg2);
29241   arg2 = &arg2_str;
29242   {
29243     try {
29244       (arg1)->SetName((std::string const &)*arg2);
29245     } catch (std::out_of_range& e) {
29246       {
29247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29248       };
29249     } catch (std::exception& e) {
29250       {
29251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29252       };
29253     } catch (...) {
29254       {
29255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29256       };
29257     }
29258   }
29259
29260   //argout typemap for const std::string&
29261
29262 }
29263
29264
29265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29266   unsigned int jresult ;
29267   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29268   unsigned int result;
29269
29270   arg1 = (Dali::Actor *)jarg1;
29271   {
29272     try {
29273       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29274     } catch (std::out_of_range& e) {
29275       {
29276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29277       };
29278     } catch (std::exception& e) {
29279       {
29280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29281       };
29282     } catch (...) {
29283       {
29284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29285       };
29286     }
29287   }
29288   jresult = result;
29289   return jresult;
29290 }
29291
29292
29293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29294   unsigned int jresult ;
29295   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29296   bool result;
29297
29298   arg1 = (Dali::Actor *)jarg1;
29299   {
29300     try {
29301       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29302     } catch (std::out_of_range& e) {
29303       {
29304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29305       };
29306     } catch (std::exception& e) {
29307       {
29308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29309       };
29310     } catch (...) {
29311       {
29312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29313       };
29314     }
29315   }
29316   jresult = result;
29317   return jresult;
29318 }
29319
29320
29321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29322   unsigned int jresult ;
29323   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29324   bool result;
29325
29326   arg1 = (Dali::Actor *)jarg1;
29327   {
29328     try {
29329       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29330     } catch (std::out_of_range& e) {
29331       {
29332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29333       };
29334     } catch (std::exception& e) {
29335       {
29336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29337       };
29338     } catch (...) {
29339       {
29340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29341       };
29342     }
29343   }
29344   jresult = result;
29345   return jresult;
29346 }
29347
29348
29349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29350   unsigned int jresult ;
29351   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29352   bool result;
29353
29354   arg1 = (Dali::Actor *)jarg1;
29355   {
29356     try {
29357       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29358     } catch (std::out_of_range& e) {
29359       {
29360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29361       };
29362     } catch (std::exception& e) {
29363       {
29364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29365       };
29366     } catch (...) {
29367       {
29368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29369       };
29370     }
29371   }
29372   jresult = result;
29373   return jresult;
29374 }
29375
29376
29377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29378   void * jresult ;
29379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29380   Dali::Layer result;
29381
29382   arg1 = (Dali::Actor *)jarg1;
29383   {
29384     try {
29385       result = (arg1)->GetLayer();
29386     } catch (std::out_of_range& e) {
29387       {
29388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29389       };
29390     } catch (std::exception& e) {
29391       {
29392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29393       };
29394     } catch (...) {
29395       {
29396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29397       };
29398     }
29399   }
29400   jresult = new Dali::Layer((const Dali::Layer &)result);
29401   return jresult;
29402 }
29403
29404
29405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29406   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29407   Dali::Actor arg2 ;
29408   Dali::Actor *argp2 ;
29409
29410   arg1 = (Dali::Actor *)jarg1;
29411   argp2 = (Dali::Actor *)jarg2;
29412   if (!argp2) {
29413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29414     return ;
29415   }
29416   arg2 = *argp2;
29417   {
29418     try {
29419       (arg1)->Add(arg2);
29420     } catch (std::out_of_range& e) {
29421       {
29422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29423       };
29424     } catch (std::exception& e) {
29425       {
29426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29427       };
29428     } catch (...) {
29429       {
29430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29431       };
29432     }
29433   }
29434 }
29435
29436
29437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29438   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29439   Dali::Actor arg2 ;
29440   Dali::Actor *argp2 ;
29441
29442   arg1 = (Dali::Actor *)jarg1;
29443   argp2 = (Dali::Actor *)jarg2;
29444   if (!argp2) {
29445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29446     return ;
29447   }
29448   arg2 = *argp2;
29449   {
29450     try {
29451       (arg1)->Remove(arg2);
29452     } catch (std::out_of_range& e) {
29453       {
29454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29455       };
29456     } catch (std::exception& e) {
29457       {
29458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29459       };
29460     } catch (...) {
29461       {
29462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29463       };
29464     }
29465   }
29466 }
29467
29468
29469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29470   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29471
29472   arg1 = (Dali::Actor *)jarg1;
29473   {
29474     try {
29475       (arg1)->Unparent();
29476     } catch (std::out_of_range& e) {
29477       {
29478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29479       };
29480     } catch (std::exception& e) {
29481       {
29482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29483       };
29484     } catch (...) {
29485       {
29486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29487       };
29488     }
29489   }
29490 }
29491
29492
29493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29494   unsigned int jresult ;
29495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29496   unsigned int result;
29497
29498   arg1 = (Dali::Actor *)jarg1;
29499   {
29500     try {
29501       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29502     } catch (std::out_of_range& e) {
29503       {
29504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29505       };
29506     } catch (std::exception& e) {
29507       {
29508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29509       };
29510     } catch (...) {
29511       {
29512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29513       };
29514     }
29515   }
29516   jresult = result;
29517   return jresult;
29518 }
29519
29520
29521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29522   void * jresult ;
29523   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29524   unsigned int arg2 ;
29525   Dali::Actor result;
29526
29527   arg1 = (Dali::Actor *)jarg1;
29528   arg2 = (unsigned int)jarg2;
29529   {
29530     try {
29531       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29532     } catch (std::out_of_range& e) {
29533       {
29534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29535       };
29536     } catch (std::exception& e) {
29537       {
29538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29539       };
29540     } catch (...) {
29541       {
29542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29543       };
29544     }
29545   }
29546   jresult = new Dali::Actor((const Dali::Actor &)result);
29547   return jresult;
29548 }
29549
29550
29551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29552   void * jresult ;
29553   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29554   std::string *arg2 = 0 ;
29555   Dali::Actor result;
29556
29557   arg1 = (Dali::Actor *)jarg1;
29558   if (!jarg2) {
29559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29560     return 0;
29561   }
29562   std::string arg2_str(jarg2);
29563   arg2 = &arg2_str;
29564   {
29565     try {
29566       result = (arg1)->FindChildByName((std::string const &)*arg2);
29567     } catch (std::out_of_range& e) {
29568       {
29569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29570       };
29571     } catch (std::exception& e) {
29572       {
29573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29574       };
29575     } catch (...) {
29576       {
29577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29578       };
29579     }
29580   }
29581   jresult = new Dali::Actor((const Dali::Actor &)result);
29582
29583   //argout typemap for const std::string&
29584
29585   return jresult;
29586 }
29587
29588
29589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29590   void * jresult ;
29591   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29592   unsigned int arg2 ;
29593   Dali::Actor result;
29594
29595   arg1 = (Dali::Actor *)jarg1;
29596   arg2 = (unsigned int)jarg2;
29597   {
29598     try {
29599       result = (arg1)->FindChildById(arg2);
29600     } catch (std::out_of_range& e) {
29601       {
29602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29603       };
29604     } catch (std::exception& e) {
29605       {
29606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29607       };
29608     } catch (...) {
29609       {
29610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29611       };
29612     }
29613   }
29614   jresult = new Dali::Actor((const Dali::Actor &)result);
29615   return jresult;
29616 }
29617
29618
29619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29620   void * jresult ;
29621   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29622   Dali::Actor result;
29623
29624   arg1 = (Dali::Actor *)jarg1;
29625   {
29626     try {
29627       result = ((Dali::Actor const *)arg1)->GetParent();
29628     } catch (std::out_of_range& e) {
29629       {
29630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29631       };
29632     } catch (std::exception& e) {
29633       {
29634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29635       };
29636     } catch (...) {
29637       {
29638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29639       };
29640     }
29641   }
29642   jresult = new Dali::Actor((const Dali::Actor &)result);
29643   return jresult;
29644 }
29645
29646
29647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29648   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29649   Dali::Vector3 *arg2 = 0 ;
29650
29651   arg1 = (Dali::Actor *)jarg1;
29652   arg2 = (Dali::Vector3 *)jarg2;
29653   if (!arg2) {
29654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29655     return ;
29656   }
29657   {
29658     try {
29659       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29660     } catch (std::out_of_range& e) {
29661       {
29662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29663       };
29664     } catch (std::exception& e) {
29665       {
29666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29667       };
29668     } catch (...) {
29669       {
29670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29671       };
29672     }
29673   }
29674 }
29675
29676
29677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29678   void * jresult ;
29679   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29680   Dali::Vector3 result;
29681
29682   arg1 = (Dali::Actor *)jarg1;
29683   {
29684     try {
29685       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29686     } catch (std::out_of_range& e) {
29687       {
29688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29689       };
29690     } catch (std::exception& e) {
29691       {
29692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29693       };
29694     } catch (...) {
29695       {
29696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29697       };
29698     }
29699   }
29700   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29701   return jresult;
29702 }
29703
29704
29705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29706   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29707   Dali::Vector3 *arg2 = 0 ;
29708
29709   arg1 = (Dali::Actor *)jarg1;
29710   arg2 = (Dali::Vector3 *)jarg2;
29711   if (!arg2) {
29712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29713     return ;
29714   }
29715   {
29716     try {
29717       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29718     } catch (std::out_of_range& e) {
29719       {
29720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29721       };
29722     } catch (std::exception& e) {
29723       {
29724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29725       };
29726     } catch (...) {
29727       {
29728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29729       };
29730     }
29731   }
29732 }
29733
29734
29735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29736   void * jresult ;
29737   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29738   Dali::Vector3 result;
29739
29740   arg1 = (Dali::Actor *)jarg1;
29741   {
29742     try {
29743       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29744     } catch (std::out_of_range& e) {
29745       {
29746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29747       };
29748     } catch (std::exception& e) {
29749       {
29750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29751       };
29752     } catch (...) {
29753       {
29754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29755       };
29756     }
29757   }
29758   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29759   return jresult;
29760 }
29761
29762
29763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29764   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29765   float arg2 ;
29766   float arg3 ;
29767
29768   arg1 = (Dali::Actor *)jarg1;
29769   arg2 = (float)jarg2;
29770   arg3 = (float)jarg3;
29771   {
29772     try {
29773       (arg1)->SetSize(arg2,arg3);
29774     } catch (std::out_of_range& e) {
29775       {
29776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29777       };
29778     } catch (std::exception& e) {
29779       {
29780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29781       };
29782     } catch (...) {
29783       {
29784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29785       };
29786     }
29787   }
29788 }
29789
29790
29791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29792   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29793   float arg2 ;
29794   float arg3 ;
29795   float arg4 ;
29796
29797   arg1 = (Dali::Actor *)jarg1;
29798   arg2 = (float)jarg2;
29799   arg3 = (float)jarg3;
29800   arg4 = (float)jarg4;
29801   {
29802     try {
29803       (arg1)->SetSize(arg2,arg3,arg4);
29804     } catch (std::out_of_range& e) {
29805       {
29806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29807       };
29808     } catch (std::exception& e) {
29809       {
29810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29811       };
29812     } catch (...) {
29813       {
29814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29815       };
29816     }
29817   }
29818 }
29819
29820
29821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
29822   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29823   Dali::Vector2 *arg2 = 0 ;
29824
29825   arg1 = (Dali::Actor *)jarg1;
29826   arg2 = (Dali::Vector2 *)jarg2;
29827   if (!arg2) {
29828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29829     return ;
29830   }
29831   {
29832     try {
29833       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
29834     } catch (std::out_of_range& e) {
29835       {
29836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29837       };
29838     } catch (std::exception& e) {
29839       {
29840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29841       };
29842     } catch (...) {
29843       {
29844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29845       };
29846     }
29847   }
29848 }
29849
29850
29851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
29852   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29853   Dali::Vector3 *arg2 = 0 ;
29854
29855   arg1 = (Dali::Actor *)jarg1;
29856   arg2 = (Dali::Vector3 *)jarg2;
29857   if (!arg2) {
29858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29859     return ;
29860   }
29861   {
29862     try {
29863       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
29864     } catch (std::out_of_range& e) {
29865       {
29866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29867       };
29868     } catch (std::exception& e) {
29869       {
29870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29871       };
29872     } catch (...) {
29873       {
29874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29875       };
29876     }
29877   }
29878 }
29879
29880
29881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
29882   void * jresult ;
29883   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29884   Dali::Vector3 result;
29885
29886   arg1 = (Dali::Actor *)jarg1;
29887   {
29888     try {
29889       result = ((Dali::Actor const *)arg1)->GetTargetSize();
29890     } catch (std::out_of_range& e) {
29891       {
29892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29893       };
29894     } catch (std::exception& e) {
29895       {
29896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29897       };
29898     } catch (...) {
29899       {
29900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29901       };
29902     }
29903   }
29904   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29905   return jresult;
29906 }
29907
29908
29909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
29910   void * jresult ;
29911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29912   Dali::Vector3 result;
29913
29914   arg1 = (Dali::Actor *)jarg1;
29915   {
29916     try {
29917       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
29918     } catch (std::out_of_range& e) {
29919       {
29920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29921       };
29922     } catch (std::exception& e) {
29923       {
29924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29925       };
29926     } catch (...) {
29927       {
29928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29929       };
29930     }
29931   }
29932   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29933   return jresult;
29934 }
29935
29936
29937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
29938   void * jresult ;
29939   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29940   Dali::Vector3 result;
29941
29942   arg1 = (Dali::Actor *)jarg1;
29943   {
29944     try {
29945       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
29946     } catch (std::out_of_range& e) {
29947       {
29948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29949       };
29950     } catch (std::exception& e) {
29951       {
29952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29953       };
29954     } catch (...) {
29955       {
29956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29957       };
29958     }
29959   }
29960   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29961   return jresult;
29962 }
29963
29964
29965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29966   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29967   float arg2 ;
29968   float arg3 ;
29969
29970   arg1 = (Dali::Actor *)jarg1;
29971   arg2 = (float)jarg2;
29972   arg3 = (float)jarg3;
29973   {
29974     try {
29975       (arg1)->SetPosition(arg2,arg3);
29976     } catch (std::out_of_range& e) {
29977       {
29978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29979       };
29980     } catch (std::exception& e) {
29981       {
29982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29983       };
29984     } catch (...) {
29985       {
29986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29987       };
29988     }
29989   }
29990 }
29991
29992
29993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29994   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29995   float arg2 ;
29996   float arg3 ;
29997   float arg4 ;
29998
29999   arg1 = (Dali::Actor *)jarg1;
30000   arg2 = (float)jarg2;
30001   arg3 = (float)jarg3;
30002   arg4 = (float)jarg4;
30003   {
30004     try {
30005       (arg1)->SetPosition(arg2,arg3,arg4);
30006     } catch (std::out_of_range& e) {
30007       {
30008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30009       };
30010     } catch (std::exception& e) {
30011       {
30012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30013       };
30014     } catch (...) {
30015       {
30016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30017       };
30018     }
30019   }
30020 }
30021
30022
30023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30024   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30025   Dali::Vector3 *arg2 = 0 ;
30026
30027   arg1 = (Dali::Actor *)jarg1;
30028   arg2 = (Dali::Vector3 *)jarg2;
30029   if (!arg2) {
30030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30031     return ;
30032   }
30033   {
30034     try {
30035       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30036     } catch (std::out_of_range& e) {
30037       {
30038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30039       };
30040     } catch (std::exception& e) {
30041       {
30042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30043       };
30044     } catch (...) {
30045       {
30046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30047       };
30048     }
30049   }
30050 }
30051
30052
30053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30054   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30055   float arg2 ;
30056
30057   arg1 = (Dali::Actor *)jarg1;
30058   arg2 = (float)jarg2;
30059   {
30060     try {
30061       (arg1)->SetX(arg2);
30062     } catch (std::out_of_range& e) {
30063       {
30064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30065       };
30066     } catch (std::exception& e) {
30067       {
30068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30069       };
30070     } catch (...) {
30071       {
30072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30073       };
30074     }
30075   }
30076 }
30077
30078
30079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30080   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30081   float arg2 ;
30082
30083   arg1 = (Dali::Actor *)jarg1;
30084   arg2 = (float)jarg2;
30085   {
30086     try {
30087       (arg1)->SetY(arg2);
30088     } catch (std::out_of_range& e) {
30089       {
30090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30091       };
30092     } catch (std::exception& e) {
30093       {
30094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30095       };
30096     } catch (...) {
30097       {
30098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30099       };
30100     }
30101   }
30102 }
30103
30104
30105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30106   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30107   float arg2 ;
30108
30109   arg1 = (Dali::Actor *)jarg1;
30110   arg2 = (float)jarg2;
30111   {
30112     try {
30113       (arg1)->SetZ(arg2);
30114     } catch (std::out_of_range& e) {
30115       {
30116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30117       };
30118     } catch (std::exception& e) {
30119       {
30120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30121       };
30122     } catch (...) {
30123       {
30124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30125       };
30126     }
30127   }
30128 }
30129
30130
30131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30132   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30133   Dali::Vector3 *arg2 = 0 ;
30134
30135   arg1 = (Dali::Actor *)jarg1;
30136   arg2 = (Dali::Vector3 *)jarg2;
30137   if (!arg2) {
30138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30139     return ;
30140   }
30141   {
30142     try {
30143       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30144     } catch (std::out_of_range& e) {
30145       {
30146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30147       };
30148     } catch (std::exception& e) {
30149       {
30150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30151       };
30152     } catch (...) {
30153       {
30154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30155       };
30156     }
30157   }
30158 }
30159
30160
30161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30162   void * jresult ;
30163   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30164   Dali::Vector3 result;
30165
30166   arg1 = (Dali::Actor *)jarg1;
30167   {
30168     try {
30169       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30170     } catch (std::out_of_range& e) {
30171       {
30172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30173       };
30174     } catch (std::exception& e) {
30175       {
30176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30177       };
30178     } catch (...) {
30179       {
30180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30181       };
30182     }
30183   }
30184   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30185   return jresult;
30186 }
30187
30188
30189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30190   void * jresult ;
30191   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30192   Dali::Vector3 result;
30193
30194   arg1 = (Dali::Actor *)jarg1;
30195   {
30196     try {
30197       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30198     } catch (std::out_of_range& e) {
30199       {
30200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30201       };
30202     } catch (std::exception& e) {
30203       {
30204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30205       };
30206     } catch (...) {
30207       {
30208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30209       };
30210     }
30211   }
30212   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30213   return jresult;
30214 }
30215
30216
30217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30219   bool arg2 ;
30220
30221   arg1 = (Dali::Actor *)jarg1;
30222   arg2 = jarg2 ? true : false;
30223   {
30224     try {
30225       (arg1)->SetInheritPosition(arg2);
30226     } catch (std::out_of_range& e) {
30227       {
30228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30229       };
30230     } catch (std::exception& e) {
30231       {
30232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30233       };
30234     } catch (...) {
30235       {
30236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30237       };
30238     }
30239   }
30240 }
30241
30242
30243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30244   int jresult ;
30245   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30246   Dali::PositionInheritanceMode result;
30247
30248   arg1 = (Dali::Actor *)jarg1;
30249   {
30250     try {
30251       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30252     } catch (std::out_of_range& e) {
30253       {
30254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30255       };
30256     } catch (std::exception& e) {
30257       {
30258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30259       };
30260     } catch (...) {
30261       {
30262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30263       };
30264     }
30265   }
30266   jresult = (int)result;
30267   return jresult;
30268 }
30269
30270
30271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30272   unsigned int jresult ;
30273   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30274   bool result;
30275
30276   arg1 = (Dali::Actor *)jarg1;
30277   {
30278     try {
30279       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30280     } catch (std::out_of_range& e) {
30281       {
30282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30283       };
30284     } catch (std::exception& e) {
30285       {
30286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30287       };
30288     } catch (...) {
30289       {
30290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30291       };
30292     }
30293   }
30294   jresult = result;
30295   return jresult;
30296 }
30297
30298
30299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30300   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30301   Dali::Degree *arg2 = 0 ;
30302   Dali::Vector3 *arg3 = 0 ;
30303
30304   arg1 = (Dali::Actor *)jarg1;
30305   arg2 = (Dali::Degree *)jarg2;
30306   if (!arg2) {
30307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30308     return ;
30309   }
30310   arg3 = (Dali::Vector3 *)jarg3;
30311   if (!arg3) {
30312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30313     return ;
30314   }
30315   {
30316     try {
30317       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30318     } catch (std::out_of_range& e) {
30319       {
30320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30321       };
30322     } catch (std::exception& e) {
30323       {
30324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30325       };
30326     } catch (...) {
30327       {
30328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30329       };
30330     }
30331   }
30332 }
30333
30334
30335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30336   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30337   Dali::Radian *arg2 = 0 ;
30338   Dali::Vector3 *arg3 = 0 ;
30339
30340   arg1 = (Dali::Actor *)jarg1;
30341   arg2 = (Dali::Radian *)jarg2;
30342   if (!arg2) {
30343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30344     return ;
30345   }
30346   arg3 = (Dali::Vector3 *)jarg3;
30347   if (!arg3) {
30348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30349     return ;
30350   }
30351   {
30352     try {
30353       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30354     } catch (std::out_of_range& e) {
30355       {
30356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30357       };
30358     } catch (std::exception& e) {
30359       {
30360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30361       };
30362     } catch (...) {
30363       {
30364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30365       };
30366     }
30367   }
30368 }
30369
30370
30371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30372   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30373   Dali::Quaternion *arg2 = 0 ;
30374
30375   arg1 = (Dali::Actor *)jarg1;
30376   arg2 = (Dali::Quaternion *)jarg2;
30377   if (!arg2) {
30378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30379     return ;
30380   }
30381   {
30382     try {
30383       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30384     } catch (std::out_of_range& e) {
30385       {
30386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30387       };
30388     } catch (std::exception& e) {
30389       {
30390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30391       };
30392     } catch (...) {
30393       {
30394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30395       };
30396     }
30397   }
30398 }
30399
30400
30401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30402   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30403   Dali::Degree *arg2 = 0 ;
30404   Dali::Vector3 *arg3 = 0 ;
30405
30406   arg1 = (Dali::Actor *)jarg1;
30407   arg2 = (Dali::Degree *)jarg2;
30408   if (!arg2) {
30409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30410     return ;
30411   }
30412   arg3 = (Dali::Vector3 *)jarg3;
30413   if (!arg3) {
30414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30415     return ;
30416   }
30417   {
30418     try {
30419       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30420     } catch (std::out_of_range& e) {
30421       {
30422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30423       };
30424     } catch (std::exception& e) {
30425       {
30426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30427       };
30428     } catch (...) {
30429       {
30430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30431       };
30432     }
30433   }
30434 }
30435
30436
30437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30438   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30439   Dali::Radian *arg2 = 0 ;
30440   Dali::Vector3 *arg3 = 0 ;
30441
30442   arg1 = (Dali::Actor *)jarg1;
30443   arg2 = (Dali::Radian *)jarg2;
30444   if (!arg2) {
30445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30446     return ;
30447   }
30448   arg3 = (Dali::Vector3 *)jarg3;
30449   if (!arg3) {
30450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30451     return ;
30452   }
30453   {
30454     try {
30455       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30456     } catch (std::out_of_range& e) {
30457       {
30458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30459       };
30460     } catch (std::exception& e) {
30461       {
30462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30463       };
30464     } catch (...) {
30465       {
30466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30467       };
30468     }
30469   }
30470 }
30471
30472
30473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30474   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30475   Dali::Quaternion *arg2 = 0 ;
30476
30477   arg1 = (Dali::Actor *)jarg1;
30478   arg2 = (Dali::Quaternion *)jarg2;
30479   if (!arg2) {
30480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30481     return ;
30482   }
30483   {
30484     try {
30485       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30486     } catch (std::out_of_range& e) {
30487       {
30488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30489       };
30490     } catch (std::exception& e) {
30491       {
30492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30493       };
30494     } catch (...) {
30495       {
30496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30497       };
30498     }
30499   }
30500 }
30501
30502
30503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30504   void * jresult ;
30505   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30506   Dali::Quaternion result;
30507
30508   arg1 = (Dali::Actor *)jarg1;
30509   {
30510     try {
30511       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30512     } catch (std::out_of_range& e) {
30513       {
30514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30515       };
30516     } catch (std::exception& e) {
30517       {
30518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30519       };
30520     } catch (...) {
30521       {
30522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30523       };
30524     }
30525   }
30526   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30527   return jresult;
30528 }
30529
30530
30531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30532   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30533   bool arg2 ;
30534
30535   arg1 = (Dali::Actor *)jarg1;
30536   arg2 = jarg2 ? true : false;
30537   {
30538     try {
30539       (arg1)->SetInheritOrientation(arg2);
30540     } catch (std::out_of_range& e) {
30541       {
30542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30543       };
30544     } catch (std::exception& e) {
30545       {
30546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30547       };
30548     } catch (...) {
30549       {
30550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30551       };
30552     }
30553   }
30554 }
30555
30556
30557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30558   unsigned int jresult ;
30559   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30560   bool result;
30561
30562   arg1 = (Dali::Actor *)jarg1;
30563   {
30564     try {
30565       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30566     } catch (std::out_of_range& e) {
30567       {
30568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30569       };
30570     } catch (std::exception& e) {
30571       {
30572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30573       };
30574     } catch (...) {
30575       {
30576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30577       };
30578     }
30579   }
30580   jresult = result;
30581   return jresult;
30582 }
30583
30584
30585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30586   void * jresult ;
30587   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30588   Dali::Quaternion result;
30589
30590   arg1 = (Dali::Actor *)jarg1;
30591   {
30592     try {
30593       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30594     } catch (std::out_of_range& e) {
30595       {
30596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30597       };
30598     } catch (std::exception& e) {
30599       {
30600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30601       };
30602     } catch (...) {
30603       {
30604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30605       };
30606     }
30607   }
30608   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30609   return jresult;
30610 }
30611
30612
30613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30614   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30615   float arg2 ;
30616
30617   arg1 = (Dali::Actor *)jarg1;
30618   arg2 = (float)jarg2;
30619   {
30620     try {
30621       (arg1)->SetScale(arg2);
30622     } catch (std::out_of_range& e) {
30623       {
30624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30625       };
30626     } catch (std::exception& e) {
30627       {
30628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30629       };
30630     } catch (...) {
30631       {
30632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30633       };
30634     }
30635   }
30636 }
30637
30638
30639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30640   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30641   float arg2 ;
30642   float arg3 ;
30643   float arg4 ;
30644
30645   arg1 = (Dali::Actor *)jarg1;
30646   arg2 = (float)jarg2;
30647   arg3 = (float)jarg3;
30648   arg4 = (float)jarg4;
30649   {
30650     try {
30651       (arg1)->SetScale(arg2,arg3,arg4);
30652     } catch (std::out_of_range& e) {
30653       {
30654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30655       };
30656     } catch (std::exception& e) {
30657       {
30658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30659       };
30660     } catch (...) {
30661       {
30662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30663       };
30664     }
30665   }
30666 }
30667
30668
30669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30671   Dali::Vector3 *arg2 = 0 ;
30672
30673   arg1 = (Dali::Actor *)jarg1;
30674   arg2 = (Dali::Vector3 *)jarg2;
30675   if (!arg2) {
30676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30677     return ;
30678   }
30679   {
30680     try {
30681       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30682     } catch (std::out_of_range& e) {
30683       {
30684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30685       };
30686     } catch (std::exception& e) {
30687       {
30688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30689       };
30690     } catch (...) {
30691       {
30692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30693       };
30694     }
30695   }
30696 }
30697
30698
30699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30700   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30701   Dali::Vector3 *arg2 = 0 ;
30702
30703   arg1 = (Dali::Actor *)jarg1;
30704   arg2 = (Dali::Vector3 *)jarg2;
30705   if (!arg2) {
30706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30707     return ;
30708   }
30709   {
30710     try {
30711       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30712     } catch (std::out_of_range& e) {
30713       {
30714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30715       };
30716     } catch (std::exception& e) {
30717       {
30718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30719       };
30720     } catch (...) {
30721       {
30722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30723       };
30724     }
30725   }
30726 }
30727
30728
30729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30730   void * jresult ;
30731   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30732   Dali::Vector3 result;
30733
30734   arg1 = (Dali::Actor *)jarg1;
30735   {
30736     try {
30737       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30738     } catch (std::out_of_range& e) {
30739       {
30740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30741       };
30742     } catch (std::exception& e) {
30743       {
30744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30745       };
30746     } catch (...) {
30747       {
30748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30749       };
30750     }
30751   }
30752   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30753   return jresult;
30754 }
30755
30756
30757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
30758   void * jresult ;
30759   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30760   Dali::Vector3 result;
30761
30762   arg1 = (Dali::Actor *)jarg1;
30763   {
30764     try {
30765       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
30766     } catch (std::out_of_range& e) {
30767       {
30768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30769       };
30770     } catch (std::exception& e) {
30771       {
30772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30773       };
30774     } catch (...) {
30775       {
30776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30777       };
30778     }
30779   }
30780   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30781   return jresult;
30782 }
30783
30784
30785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
30786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30787   bool arg2 ;
30788
30789   arg1 = (Dali::Actor *)jarg1;
30790   arg2 = jarg2 ? true : false;
30791   {
30792     try {
30793       (arg1)->SetInheritScale(arg2);
30794     } catch (std::out_of_range& e) {
30795       {
30796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30797       };
30798     } catch (std::exception& e) {
30799       {
30800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30801       };
30802     } catch (...) {
30803       {
30804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30805       };
30806     }
30807   }
30808 }
30809
30810
30811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
30812   unsigned int jresult ;
30813   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30814   bool result;
30815
30816   arg1 = (Dali::Actor *)jarg1;
30817   {
30818     try {
30819       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
30820     } catch (std::out_of_range& e) {
30821       {
30822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30823       };
30824     } catch (std::exception& e) {
30825       {
30826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30827       };
30828     } catch (...) {
30829       {
30830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30831       };
30832     }
30833   }
30834   jresult = result;
30835   return jresult;
30836 }
30837
30838
30839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
30840   void * jresult ;
30841   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30842   Dali::Matrix result;
30843
30844   arg1 = (Dali::Actor *)jarg1;
30845   {
30846     try {
30847       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
30848     } catch (std::out_of_range& e) {
30849       {
30850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30851       };
30852     } catch (std::exception& e) {
30853       {
30854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30855       };
30856     } catch (...) {
30857       {
30858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30859       };
30860     }
30861   }
30862   jresult = new Dali::Matrix((const Dali::Matrix &)result);
30863   return jresult;
30864 }
30865
30866
30867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
30868   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30869   bool arg2 ;
30870
30871   arg1 = (Dali::Actor *)jarg1;
30872   arg2 = jarg2 ? true : false;
30873   {
30874     try {
30875       (arg1)->SetVisible(arg2);
30876     } catch (std::out_of_range& e) {
30877       {
30878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30879       };
30880     } catch (std::exception& e) {
30881       {
30882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30883       };
30884     } catch (...) {
30885       {
30886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30887       };
30888     }
30889   }
30890 }
30891
30892
30893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
30894   unsigned int jresult ;
30895   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30896   bool result;
30897
30898   arg1 = (Dali::Actor *)jarg1;
30899   {
30900     try {
30901       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
30902     } catch (std::out_of_range& e) {
30903       {
30904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30905       };
30906     } catch (std::exception& e) {
30907       {
30908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30909       };
30910     } catch (...) {
30911       {
30912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30913       };
30914     }
30915   }
30916   jresult = result;
30917   return jresult;
30918 }
30919
30920
30921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
30922   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30923   float arg2 ;
30924
30925   arg1 = (Dali::Actor *)jarg1;
30926   arg2 = (float)jarg2;
30927   {
30928     try {
30929       (arg1)->SetOpacity(arg2);
30930     } catch (std::out_of_range& e) {
30931       {
30932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30933       };
30934     } catch (std::exception& e) {
30935       {
30936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30937       };
30938     } catch (...) {
30939       {
30940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30941       };
30942     }
30943   }
30944 }
30945
30946
30947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
30948   float jresult ;
30949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30950   float result;
30951
30952   arg1 = (Dali::Actor *)jarg1;
30953   {
30954     try {
30955       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
30956     } catch (std::out_of_range& e) {
30957       {
30958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30959       };
30960     } catch (std::exception& e) {
30961       {
30962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30963       };
30964     } catch (...) {
30965       {
30966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30967       };
30968     }
30969   }
30970   jresult = result;
30971   return jresult;
30972 }
30973
30974
30975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
30976   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30977   Dali::Vector4 *arg2 = 0 ;
30978
30979   arg1 = (Dali::Actor *)jarg1;
30980   arg2 = (Dali::Vector4 *)jarg2;
30981   if (!arg2) {
30982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
30983     return ;
30984   }
30985   {
30986     try {
30987       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
30988     } catch (std::out_of_range& e) {
30989       {
30990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30991       };
30992     } catch (std::exception& e) {
30993       {
30994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30995       };
30996     } catch (...) {
30997       {
30998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30999       };
31000     }
31001   }
31002 }
31003
31004
31005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31006   void * jresult ;
31007   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31008   Dali::Vector4 result;
31009
31010   arg1 = (Dali::Actor *)jarg1;
31011   {
31012     try {
31013       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31014     } catch (std::out_of_range& e) {
31015       {
31016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31017       };
31018     } catch (std::exception& e) {
31019       {
31020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31021       };
31022     } catch (...) {
31023       {
31024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31025       };
31026     }
31027   }
31028   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31029   return jresult;
31030 }
31031
31032
31033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31034   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31035   Dali::ColorMode arg2 ;
31036
31037   arg1 = (Dali::Actor *)jarg1;
31038   arg2 = (Dali::ColorMode)jarg2;
31039   {
31040     try {
31041       (arg1)->SetColorMode(arg2);
31042     } catch (std::out_of_range& e) {
31043       {
31044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31045       };
31046     } catch (std::exception& e) {
31047       {
31048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31049       };
31050     } catch (...) {
31051       {
31052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31053       };
31054     }
31055   }
31056 }
31057
31058
31059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31060   int jresult ;
31061   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31062   Dali::ColorMode result;
31063
31064   arg1 = (Dali::Actor *)jarg1;
31065   {
31066     try {
31067       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31068     } catch (std::out_of_range& e) {
31069       {
31070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31071       };
31072     } catch (std::exception& e) {
31073       {
31074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31075       };
31076     } catch (...) {
31077       {
31078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31079       };
31080     }
31081   }
31082   jresult = (int)result;
31083   return jresult;
31084 }
31085
31086
31087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31088   void * jresult ;
31089   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31090   Dali::Vector4 result;
31091
31092   arg1 = (Dali::Actor *)jarg1;
31093   {
31094     try {
31095       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31096     } catch (std::out_of_range& e) {
31097       {
31098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31099       };
31100     } catch (std::exception& e) {
31101       {
31102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31103       };
31104     } catch (...) {
31105       {
31106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31107       };
31108     }
31109   }
31110   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31111   return jresult;
31112 }
31113
31114
31115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31116   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31117   Dali::DrawMode::Type arg2 ;
31118
31119   arg1 = (Dali::Actor *)jarg1;
31120   arg2 = (Dali::DrawMode::Type)jarg2;
31121   {
31122     try {
31123       (arg1)->SetDrawMode(arg2);
31124     } catch (std::out_of_range& e) {
31125       {
31126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31127       };
31128     } catch (std::exception& e) {
31129       {
31130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31131       };
31132     } catch (...) {
31133       {
31134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31135       };
31136     }
31137   }
31138 }
31139
31140
31141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31142   int jresult ;
31143   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31144   Dali::DrawMode::Type result;
31145
31146   arg1 = (Dali::Actor *)jarg1;
31147   {
31148     try {
31149       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31150     } catch (std::out_of_range& e) {
31151       {
31152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31153       };
31154     } catch (std::exception& e) {
31155       {
31156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31157       };
31158     } catch (...) {
31159       {
31160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31161       };
31162     }
31163   }
31164   jresult = (int)result;
31165   return jresult;
31166 }
31167
31168
31169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31170   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31171   bool arg2 ;
31172
31173   arg1 = (Dali::Actor *)jarg1;
31174   arg2 = jarg2 ? true : false;
31175   {
31176     try {
31177       (arg1)->SetSensitive(arg2);
31178     } catch (std::out_of_range& e) {
31179       {
31180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31181       };
31182     } catch (std::exception& e) {
31183       {
31184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31185       };
31186     } catch (...) {
31187       {
31188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31189       };
31190     }
31191   }
31192 }
31193
31194
31195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31196   unsigned int jresult ;
31197   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31198   bool result;
31199
31200   arg1 = (Dali::Actor *)jarg1;
31201   {
31202     try {
31203       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31204     } catch (std::out_of_range& e) {
31205       {
31206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31207       };
31208     } catch (std::exception& e) {
31209       {
31210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31211       };
31212     } catch (...) {
31213       {
31214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31215       };
31216     }
31217   }
31218   jresult = result;
31219   return jresult;
31220 }
31221
31222
31223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31224   unsigned int jresult ;
31225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31226   float *arg2 = 0 ;
31227   float *arg3 = 0 ;
31228   float arg4 ;
31229   float arg5 ;
31230   bool result;
31231
31232   arg1 = (Dali::Actor *)jarg1;
31233   arg2 = (float *)jarg2;
31234   arg3 = (float *)jarg3;
31235   arg4 = (float)jarg4;
31236   arg5 = (float)jarg5;
31237   {
31238     try {
31239       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31240     } catch (std::out_of_range& e) {
31241       {
31242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31243       };
31244     } catch (std::exception& e) {
31245       {
31246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31247       };
31248     } catch (...) {
31249       {
31250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31251       };
31252     }
31253   }
31254   jresult = result;
31255   return jresult;
31256 }
31257
31258
31259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31260   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31261   bool arg2 ;
31262
31263   arg1 = (Dali::Actor *)jarg1;
31264   arg2 = jarg2 ? true : false;
31265   {
31266     try {
31267       (arg1)->SetLeaveRequired(arg2);
31268     } catch (std::out_of_range& e) {
31269       {
31270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31271       };
31272     } catch (std::exception& e) {
31273       {
31274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31275       };
31276     } catch (...) {
31277       {
31278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31279       };
31280     }
31281   }
31282 }
31283
31284
31285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31286   unsigned int jresult ;
31287   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31288   bool result;
31289
31290   arg1 = (Dali::Actor *)jarg1;
31291   {
31292     try {
31293       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31294     } catch (std::out_of_range& e) {
31295       {
31296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31297       };
31298     } catch (std::exception& e) {
31299       {
31300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31301       };
31302     } catch (...) {
31303       {
31304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31305       };
31306     }
31307   }
31308   jresult = result;
31309   return jresult;
31310 }
31311
31312
31313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31314   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31315   bool arg2 ;
31316
31317   arg1 = (Dali::Actor *)jarg1;
31318   arg2 = jarg2 ? true : false;
31319   {
31320     try {
31321       (arg1)->SetKeyboardFocusable(arg2);
31322     } catch (std::out_of_range& e) {
31323       {
31324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31325       };
31326     } catch (std::exception& e) {
31327       {
31328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31329       };
31330     } catch (...) {
31331       {
31332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31333       };
31334     }
31335   }
31336 }
31337
31338
31339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31340   unsigned int jresult ;
31341   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31342   bool result;
31343
31344   arg1 = (Dali::Actor *)jarg1;
31345   {
31346     try {
31347       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31348     } catch (std::out_of_range& e) {
31349       {
31350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31351       };
31352     } catch (std::exception& e) {
31353       {
31354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31355       };
31356     } catch (...) {
31357       {
31358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31359       };
31360     }
31361   }
31362   jresult = result;
31363   return jresult;
31364 }
31365
31366
31367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31368   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31369   Dali::ResizePolicy::Type arg2 ;
31370   Dali::Dimension::Type arg3 ;
31371
31372   arg1 = (Dali::Actor *)jarg1;
31373   arg2 = (Dali::ResizePolicy::Type)jarg2;
31374   arg3 = (Dali::Dimension::Type)jarg3;
31375   {
31376     try {
31377       (arg1)->SetResizePolicy(arg2,arg3);
31378     } catch (std::out_of_range& e) {
31379       {
31380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31381       };
31382     } catch (std::exception& e) {
31383       {
31384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31385       };
31386     } catch (...) {
31387       {
31388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31389       };
31390     }
31391   }
31392 }
31393
31394
31395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31396   int jresult ;
31397   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31398   Dali::Dimension::Type arg2 ;
31399   Dali::ResizePolicy::Type result;
31400
31401   arg1 = (Dali::Actor *)jarg1;
31402   arg2 = (Dali::Dimension::Type)jarg2;
31403   {
31404     try {
31405       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31406     } catch (std::out_of_range& e) {
31407       {
31408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31409       };
31410     } catch (std::exception& e) {
31411       {
31412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31413       };
31414     } catch (...) {
31415       {
31416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31417       };
31418     }
31419   }
31420   jresult = (int)result;
31421   return jresult;
31422 }
31423
31424
31425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31426   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31427   Dali::SizeScalePolicy::Type arg2 ;
31428
31429   arg1 = (Dali::Actor *)jarg1;
31430   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31431   {
31432     try {
31433       (arg1)->SetSizeScalePolicy(arg2);
31434     } catch (std::out_of_range& e) {
31435       {
31436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31437       };
31438     } catch (std::exception& e) {
31439       {
31440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31441       };
31442     } catch (...) {
31443       {
31444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31445       };
31446     }
31447   }
31448 }
31449
31450
31451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31452   int jresult ;
31453   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31454   Dali::SizeScalePolicy::Type result;
31455
31456   arg1 = (Dali::Actor *)jarg1;
31457   {
31458     try {
31459       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31460     } catch (std::out_of_range& e) {
31461       {
31462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31463       };
31464     } catch (std::exception& e) {
31465       {
31466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31467       };
31468     } catch (...) {
31469       {
31470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31471       };
31472     }
31473   }
31474   jresult = (int)result;
31475   return jresult;
31476 }
31477
31478
31479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31480   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31481   Dali::Vector3 *arg2 = 0 ;
31482
31483   arg1 = (Dali::Actor *)jarg1;
31484   arg2 = (Dali::Vector3 *)jarg2;
31485   if (!arg2) {
31486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31487     return ;
31488   }
31489   {
31490     try {
31491       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31492     } catch (std::out_of_range& e) {
31493       {
31494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31495       };
31496     } catch (std::exception& e) {
31497       {
31498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31499       };
31500     } catch (...) {
31501       {
31502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31503       };
31504     }
31505   }
31506 }
31507
31508
31509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31510   void * jresult ;
31511   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31512   Dali::Vector3 result;
31513
31514   arg1 = (Dali::Actor *)jarg1;
31515   {
31516     try {
31517       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31518     } catch (std::out_of_range& e) {
31519       {
31520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31521       };
31522     } catch (std::exception& e) {
31523       {
31524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31525       };
31526     } catch (...) {
31527       {
31528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31529       };
31530     }
31531   }
31532   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31533   return jresult;
31534 }
31535
31536
31537 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31538   float jresult ;
31539   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31540   float arg2 ;
31541   float result;
31542
31543   arg1 = (Dali::Actor *)jarg1;
31544   arg2 = (float)jarg2;
31545   {
31546     try {
31547       result = (float)(arg1)->GetHeightForWidth(arg2);
31548     } catch (std::out_of_range& e) {
31549       {
31550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31551       };
31552     } catch (std::exception& e) {
31553       {
31554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31555       };
31556     } catch (...) {
31557       {
31558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31559       };
31560     }
31561   }
31562   jresult = result;
31563   return jresult;
31564 }
31565
31566
31567 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31568   float jresult ;
31569   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31570   float arg2 ;
31571   float result;
31572
31573   arg1 = (Dali::Actor *)jarg1;
31574   arg2 = (float)jarg2;
31575   {
31576     try {
31577       result = (float)(arg1)->GetWidthForHeight(arg2);
31578     } catch (std::out_of_range& e) {
31579       {
31580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31581       };
31582     } catch (std::exception& e) {
31583       {
31584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31585       };
31586     } catch (...) {
31587       {
31588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31589       };
31590     }
31591   }
31592   jresult = result;
31593   return jresult;
31594 }
31595
31596
31597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31598   float jresult ;
31599   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31600   Dali::Dimension::Type arg2 ;
31601   float result;
31602
31603   arg1 = (Dali::Actor *)jarg1;
31604   arg2 = (Dali::Dimension::Type)jarg2;
31605   {
31606     try {
31607       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31608     } catch (std::out_of_range& e) {
31609       {
31610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31611       };
31612     } catch (std::exception& e) {
31613       {
31614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31615       };
31616     } catch (...) {
31617       {
31618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31619       };
31620     }
31621   }
31622   jresult = result;
31623   return jresult;
31624 }
31625
31626
31627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31628   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31629   Dali::Padding *arg2 = 0 ;
31630
31631   arg1 = (Dali::Actor *)jarg1;
31632   arg2 = (Dali::Padding *)jarg2;
31633   if (!arg2) {
31634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31635     return ;
31636   }
31637   {
31638     try {
31639       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31640     } catch (std::out_of_range& e) {
31641       {
31642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31643       };
31644     } catch (std::exception& e) {
31645       {
31646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31647       };
31648     } catch (...) {
31649       {
31650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31651       };
31652     }
31653   }
31654 }
31655
31656
31657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31658   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31659   Dali::Padding *arg2 = 0 ;
31660
31661   arg1 = (Dali::Actor *)jarg1;
31662   arg2 = (Dali::Padding *)jarg2;
31663   if (!arg2) {
31664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31665     return ;
31666   }
31667   {
31668     try {
31669       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31670     } catch (std::out_of_range& e) {
31671       {
31672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31673       };
31674     } catch (std::exception& e) {
31675       {
31676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31677       };
31678     } catch (...) {
31679       {
31680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31681       };
31682     }
31683   }
31684 }
31685
31686
31687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31689   Dali::Vector2 *arg2 = 0 ;
31690
31691   arg1 = (Dali::Actor *)jarg1;
31692   arg2 = (Dali::Vector2 *)jarg2;
31693   if (!arg2) {
31694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31695     return ;
31696   }
31697   {
31698     try {
31699       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31700     } catch (std::out_of_range& e) {
31701       {
31702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31703       };
31704     } catch (std::exception& e) {
31705       {
31706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31707       };
31708     } catch (...) {
31709       {
31710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31711       };
31712     }
31713   }
31714 }
31715
31716
31717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31718   void * jresult ;
31719   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31720   Dali::Vector2 result;
31721
31722   arg1 = (Dali::Actor *)jarg1;
31723   {
31724     try {
31725       result = (arg1)->GetMinimumSize();
31726     } catch (std::out_of_range& e) {
31727       {
31728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31729       };
31730     } catch (std::exception& e) {
31731       {
31732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31733       };
31734     } catch (...) {
31735       {
31736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31737       };
31738     }
31739   }
31740   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31741   return jresult;
31742 }
31743
31744
31745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31746   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31747   Dali::Vector2 *arg2 = 0 ;
31748
31749   arg1 = (Dali::Actor *)jarg1;
31750   arg2 = (Dali::Vector2 *)jarg2;
31751   if (!arg2) {
31752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31753     return ;
31754   }
31755   {
31756     try {
31757       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
31758     } catch (std::out_of_range& e) {
31759       {
31760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31761       };
31762     } catch (std::exception& e) {
31763       {
31764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31765       };
31766     } catch (...) {
31767       {
31768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31769       };
31770     }
31771   }
31772 }
31773
31774
31775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
31776   void * jresult ;
31777   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31778   Dali::Vector2 result;
31779
31780   arg1 = (Dali::Actor *)jarg1;
31781   {
31782     try {
31783       result = (arg1)->GetMaximumSize();
31784     } catch (std::out_of_range& e) {
31785       {
31786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31787       };
31788     } catch (std::exception& e) {
31789       {
31790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31791       };
31792     } catch (...) {
31793       {
31794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31795       };
31796     }
31797   }
31798   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31799   return jresult;
31800 }
31801
31802
31803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
31804   int jresult ;
31805   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31806   int result;
31807
31808   arg1 = (Dali::Actor *)jarg1;
31809   {
31810     try {
31811       result = (int)(arg1)->GetHierarchyDepth();
31812     } catch (std::out_of_range& e) {
31813       {
31814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31815       };
31816     } catch (std::exception& e) {
31817       {
31818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31819       };
31820     } catch (...) {
31821       {
31822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31823       };
31824     }
31825   }
31826   jresult = result;
31827   return jresult;
31828 }
31829
31830
31831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
31832   unsigned int jresult ;
31833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31834   Dali::Renderer *arg2 = 0 ;
31835   unsigned int result;
31836
31837   arg1 = (Dali::Actor *)jarg1;
31838   arg2 = (Dali::Renderer *)jarg2;
31839   if (!arg2) {
31840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31841     return 0;
31842   }
31843   {
31844     try {
31845       result = (unsigned int)(arg1)->AddRenderer(*arg2);
31846     } catch (std::out_of_range& e) {
31847       {
31848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31849       };
31850     } catch (std::exception& e) {
31851       {
31852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31853       };
31854     } catch (...) {
31855       {
31856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31857       };
31858     }
31859   }
31860   jresult = result;
31861   return jresult;
31862 }
31863
31864
31865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
31866   unsigned int jresult ;
31867   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31868   unsigned int result;
31869
31870   arg1 = (Dali::Actor *)jarg1;
31871   {
31872     try {
31873       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
31874     } catch (std::out_of_range& e) {
31875       {
31876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31877       };
31878     } catch (std::exception& e) {
31879       {
31880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31881       };
31882     } catch (...) {
31883       {
31884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31885       };
31886     }
31887   }
31888   jresult = result;
31889   return jresult;
31890 }
31891
31892
31893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
31894   void * jresult ;
31895   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31896   unsigned int arg2 ;
31897   Dali::Renderer result;
31898
31899   arg1 = (Dali::Actor *)jarg1;
31900   arg2 = (unsigned int)jarg2;
31901   {
31902     try {
31903       result = (arg1)->GetRendererAt(arg2);
31904     } catch (std::out_of_range& e) {
31905       {
31906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31907       };
31908     } catch (std::exception& e) {
31909       {
31910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31911       };
31912     } catch (...) {
31913       {
31914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31915       };
31916     }
31917   }
31918   jresult = new Dali::Renderer((const Dali::Renderer &)result);
31919   return jresult;
31920 }
31921
31922
31923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
31924   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31925   Dali::Renderer *arg2 = 0 ;
31926
31927   arg1 = (Dali::Actor *)jarg1;
31928   arg2 = (Dali::Renderer *)jarg2;
31929   if (!arg2) {
31930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31931     return ;
31932   }
31933   {
31934     try {
31935       (arg1)->RemoveRenderer(*arg2);
31936     } catch (std::out_of_range& e) {
31937       {
31938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31939       };
31940     } catch (std::exception& e) {
31941       {
31942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31943       };
31944     } catch (...) {
31945       {
31946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31947       };
31948     }
31949   }
31950 }
31951
31952
31953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
31954   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31955   unsigned int arg2 ;
31956
31957   arg1 = (Dali::Actor *)jarg1;
31958   arg2 = (unsigned int)jarg2;
31959   {
31960     try {
31961       (arg1)->RemoveRenderer(arg2);
31962     } catch (std::out_of_range& e) {
31963       {
31964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31965       };
31966     } catch (std::exception& e) {
31967       {
31968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31969       };
31970     } catch (...) {
31971       {
31972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31973       };
31974     }
31975   }
31976 }
31977
31978
31979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
31980   void * jresult ;
31981   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31982   Dali::Actor::TouchSignalType *result = 0 ;
31983
31984   arg1 = (Dali::Actor *)jarg1;
31985   {
31986     try {
31987       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
31988     } catch (std::out_of_range& e) {
31989       {
31990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31991       };
31992     } catch (std::exception& e) {
31993       {
31994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31995       };
31996     } catch (...) {
31997       {
31998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31999       };
32000     }
32001   }
32002   jresult = (void *)result;
32003   return jresult;
32004 }
32005
32006
32007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32008   void * jresult ;
32009   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32010   Dali::Actor::TouchDataSignalType *result = 0 ;
32011
32012   arg1 = (Dali::Actor *)jarg1;
32013   {
32014     try {
32015       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32016     } catch (std::out_of_range& e) {
32017       {
32018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32019       };
32020     } catch (std::exception& e) {
32021       {
32022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32023       };
32024     } catch (...) {
32025       {
32026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32027       };
32028     }
32029   }
32030   jresult = (void *)result;
32031   return jresult;
32032 }
32033
32034
32035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32036   void * jresult ;
32037   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32038   Dali::Actor::HoverSignalType *result = 0 ;
32039
32040   arg1 = (Dali::Actor *)jarg1;
32041   {
32042     try {
32043       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32044     } catch (std::out_of_range& e) {
32045       {
32046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32047       };
32048     } catch (std::exception& e) {
32049       {
32050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32051       };
32052     } catch (...) {
32053       {
32054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32055       };
32056     }
32057   }
32058   jresult = (void *)result;
32059   return jresult;
32060 }
32061
32062
32063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32064   void * jresult ;
32065   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32066   Dali::Actor::WheelEventSignalType *result = 0 ;
32067
32068   arg1 = (Dali::Actor *)jarg1;
32069   {
32070     try {
32071       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32072     } catch (std::out_of_range& e) {
32073       {
32074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32075       };
32076     } catch (std::exception& e) {
32077       {
32078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32079       };
32080     } catch (...) {
32081       {
32082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32083       };
32084     }
32085   }
32086   jresult = (void *)result;
32087   return jresult;
32088 }
32089
32090
32091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32092   void * jresult ;
32093   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32094   Dali::Actor::OnStageSignalType *result = 0 ;
32095
32096   arg1 = (Dali::Actor *)jarg1;
32097   {
32098     try {
32099       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32100     } catch (std::out_of_range& e) {
32101       {
32102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32103       };
32104     } catch (std::exception& e) {
32105       {
32106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32107       };
32108     } catch (...) {
32109       {
32110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32111       };
32112     }
32113   }
32114   jresult = (void *)result;
32115   return jresult;
32116 }
32117
32118
32119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32120   void * jresult ;
32121   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32122   Dali::Actor::OffStageSignalType *result = 0 ;
32123
32124   arg1 = (Dali::Actor *)jarg1;
32125   {
32126     try {
32127       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32128     } catch (std::out_of_range& e) {
32129       {
32130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32131       };
32132     } catch (std::exception& e) {
32133       {
32134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32135       };
32136     } catch (...) {
32137       {
32138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32139       };
32140     }
32141   }
32142   jresult = (void *)result;
32143   return jresult;
32144 }
32145
32146
32147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32148   void * jresult ;
32149   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32150   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32151
32152   arg1 = (Dali::Actor *)jarg1;
32153   {
32154     try {
32155       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32156     } catch (std::out_of_range& e) {
32157       {
32158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32159       };
32160     } catch (std::exception& e) {
32161       {
32162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32163       };
32164     } catch (...) {
32165       {
32166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32167       };
32168     }
32169   }
32170   jresult = (void *)result;
32171   return jresult;
32172 }
32173
32174
32175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32176   Dali::Actor *arg1 = 0 ;
32177
32178   arg1 = (Dali::Actor *)jarg1;
32179   if (!arg1) {
32180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32181     return ;
32182   }
32183   {
32184     try {
32185       Dali::UnparentAndReset(*arg1);
32186     } catch (std::out_of_range& e) {
32187       {
32188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32189       };
32190     } catch (std::exception& e) {
32191       {
32192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32193       };
32194     } catch (...) {
32195       {
32196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32197       };
32198     }
32199   }
32200 }
32201
32202
32203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32204   int jresult ;
32205   int result;
32206
32207   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32208   jresult = (int)result;
32209   return jresult;
32210 }
32211
32212
32213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32214   int jresult ;
32215   int result;
32216
32217   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32218   jresult = (int)result;
32219   return jresult;
32220 }
32221
32222
32223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32224   int jresult ;
32225   int result;
32226
32227   result = (int)Dali::Layer::Property::BEHAVIOR;
32228   jresult = (int)result;
32229   return jresult;
32230 }
32231
32232
32233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32234   void * jresult ;
32235   Dali::Layer::Property *result = 0 ;
32236
32237   {
32238     try {
32239       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32240     } catch (std::out_of_range& e) {
32241       {
32242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32243       };
32244     } catch (std::exception& e) {
32245       {
32246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32247       };
32248     } catch (...) {
32249       {
32250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32251       };
32252     }
32253   }
32254   jresult = (void *)result;
32255   return jresult;
32256 }
32257
32258
32259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32260   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32261
32262   arg1 = (Dali::Layer::Property *)jarg1;
32263   {
32264     try {
32265       delete arg1;
32266     } catch (std::out_of_range& e) {
32267       {
32268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32269       };
32270     } catch (std::exception& e) {
32271       {
32272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32273       };
32274     } catch (...) {
32275       {
32276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32277       };
32278     }
32279   }
32280 }
32281
32282
32283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32284   void * jresult ;
32285   Dali::Layer *result = 0 ;
32286
32287   {
32288     try {
32289       result = (Dali::Layer *)new Dali::Layer();
32290     } catch (std::out_of_range& e) {
32291       {
32292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32293       };
32294     } catch (std::exception& e) {
32295       {
32296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32297       };
32298     } catch (...) {
32299       {
32300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32301       };
32302     }
32303   }
32304   jresult = (void *)result;
32305   return jresult;
32306 }
32307
32308
32309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32310   void * jresult ;
32311   Dali::Layer result;
32312
32313   {
32314     try {
32315       result = Dali::Layer::New();
32316     } catch (std::out_of_range& e) {
32317       {
32318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32319       };
32320     } catch (std::exception& e) {
32321       {
32322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32323       };
32324     } catch (...) {
32325       {
32326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32327       };
32328     }
32329   }
32330   jresult = new Dali::Layer((const Dali::Layer &)result);
32331   return jresult;
32332 }
32333
32334
32335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32336   void * jresult ;
32337   Dali::BaseHandle arg1 ;
32338   Dali::BaseHandle *argp1 ;
32339   Dali::Layer result;
32340
32341   argp1 = (Dali::BaseHandle *)jarg1;
32342   if (!argp1) {
32343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32344     return 0;
32345   }
32346   arg1 = *argp1;
32347   {
32348     try {
32349       result = Dali::Layer::DownCast(arg1);
32350     } catch (std::out_of_range& e) {
32351       {
32352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32353       };
32354     } catch (std::exception& e) {
32355       {
32356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32357       };
32358     } catch (...) {
32359       {
32360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32361       };
32362     }
32363   }
32364   jresult = new Dali::Layer((const Dali::Layer &)result);
32365   return jresult;
32366 }
32367
32368
32369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32370   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32371
32372   arg1 = (Dali::Layer *)jarg1;
32373   {
32374     try {
32375       delete arg1;
32376     } catch (std::out_of_range& e) {
32377       {
32378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32379       };
32380     } catch (std::exception& e) {
32381       {
32382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32383       };
32384     } catch (...) {
32385       {
32386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32387       };
32388     }
32389   }
32390 }
32391
32392
32393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32394   void * jresult ;
32395   Dali::Layer *arg1 = 0 ;
32396   Dali::Layer *result = 0 ;
32397
32398   arg1 = (Dali::Layer *)jarg1;
32399   if (!arg1) {
32400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32401     return 0;
32402   }
32403   {
32404     try {
32405       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32406     } catch (std::out_of_range& e) {
32407       {
32408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32409       };
32410     } catch (std::exception& e) {
32411       {
32412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32413       };
32414     } catch (...) {
32415       {
32416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32417       };
32418     }
32419   }
32420   jresult = (void *)result;
32421   return jresult;
32422 }
32423
32424
32425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32426   void * jresult ;
32427   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32428   Dali::Layer *arg2 = 0 ;
32429   Dali::Layer *result = 0 ;
32430
32431   arg1 = (Dali::Layer *)jarg1;
32432   arg2 = (Dali::Layer *)jarg2;
32433   if (!arg2) {
32434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32435     return 0;
32436   }
32437   {
32438     try {
32439       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32440     } catch (std::out_of_range& e) {
32441       {
32442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32443       };
32444     } catch (std::exception& e) {
32445       {
32446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32447       };
32448     } catch (...) {
32449       {
32450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32451       };
32452     }
32453   }
32454   jresult = (void *)result;
32455   return jresult;
32456 }
32457
32458
32459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32460   unsigned int jresult ;
32461   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32462   unsigned int result;
32463
32464   arg1 = (Dali::Layer *)jarg1;
32465   {
32466     try {
32467       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32468     } catch (std::out_of_range& e) {
32469       {
32470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32471       };
32472     } catch (std::exception& e) {
32473       {
32474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32475       };
32476     } catch (...) {
32477       {
32478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32479       };
32480     }
32481   }
32482   jresult = result;
32483   return jresult;
32484 }
32485
32486
32487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32488   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32489
32490   arg1 = (Dali::Layer *)jarg1;
32491   {
32492     try {
32493       (arg1)->Raise();
32494     } catch (std::out_of_range& e) {
32495       {
32496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32497       };
32498     } catch (std::exception& e) {
32499       {
32500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32501       };
32502     } catch (...) {
32503       {
32504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32505       };
32506     }
32507   }
32508 }
32509
32510
32511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32512   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32513
32514   arg1 = (Dali::Layer *)jarg1;
32515   {
32516     try {
32517       (arg1)->Lower();
32518     } catch (std::out_of_range& e) {
32519       {
32520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32521       };
32522     } catch (std::exception& e) {
32523       {
32524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32525       };
32526     } catch (...) {
32527       {
32528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32529       };
32530     }
32531   }
32532 }
32533
32534
32535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32536   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32537   Dali::Layer arg2 ;
32538   Dali::Layer *argp2 ;
32539
32540   arg1 = (Dali::Layer *)jarg1;
32541   argp2 = (Dali::Layer *)jarg2;
32542   if (!argp2) {
32543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32544     return ;
32545   }
32546   arg2 = *argp2;
32547   {
32548     try {
32549       (arg1)->RaiseAbove(arg2);
32550     } catch (std::out_of_range& e) {
32551       {
32552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32553       };
32554     } catch (std::exception& e) {
32555       {
32556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32557       };
32558     } catch (...) {
32559       {
32560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32561       };
32562     }
32563   }
32564 }
32565
32566
32567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32568   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32569   Dali::Layer arg2 ;
32570   Dali::Layer *argp2 ;
32571
32572   arg1 = (Dali::Layer *)jarg1;
32573   argp2 = (Dali::Layer *)jarg2;
32574   if (!argp2) {
32575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32576     return ;
32577   }
32578   arg2 = *argp2;
32579   {
32580     try {
32581       (arg1)->LowerBelow(arg2);
32582     } catch (std::out_of_range& e) {
32583       {
32584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32585       };
32586     } catch (std::exception& e) {
32587       {
32588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32589       };
32590     } catch (...) {
32591       {
32592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32593       };
32594     }
32595   }
32596 }
32597
32598
32599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32600   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32601
32602   arg1 = (Dali::Layer *)jarg1;
32603   {
32604     try {
32605       (arg1)->RaiseToTop();
32606     } catch (std::out_of_range& e) {
32607       {
32608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32609       };
32610     } catch (std::exception& e) {
32611       {
32612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32613       };
32614     } catch (...) {
32615       {
32616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32617       };
32618     }
32619   }
32620 }
32621
32622
32623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32624   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32625
32626   arg1 = (Dali::Layer *)jarg1;
32627   {
32628     try {
32629       (arg1)->LowerToBottom();
32630     } catch (std::out_of_range& e) {
32631       {
32632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32633       };
32634     } catch (std::exception& e) {
32635       {
32636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32637       };
32638     } catch (...) {
32639       {
32640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32641       };
32642     }
32643   }
32644 }
32645
32646
32647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32648   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32649   Dali::Layer arg2 ;
32650   Dali::Layer *argp2 ;
32651
32652   arg1 = (Dali::Layer *)jarg1;
32653   argp2 = (Dali::Layer *)jarg2;
32654   if (!argp2) {
32655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32656     return ;
32657   }
32658   arg2 = *argp2;
32659   {
32660     try {
32661       (arg1)->MoveAbove(arg2);
32662     } catch (std::out_of_range& e) {
32663       {
32664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32665       };
32666     } catch (std::exception& e) {
32667       {
32668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32669       };
32670     } catch (...) {
32671       {
32672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32673       };
32674     }
32675   }
32676 }
32677
32678
32679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32680   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32681   Dali::Layer arg2 ;
32682   Dali::Layer *argp2 ;
32683
32684   arg1 = (Dali::Layer *)jarg1;
32685   argp2 = (Dali::Layer *)jarg2;
32686   if (!argp2) {
32687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32688     return ;
32689   }
32690   arg2 = *argp2;
32691   {
32692     try {
32693       (arg1)->MoveBelow(arg2);
32694     } catch (std::out_of_range& e) {
32695       {
32696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32697       };
32698     } catch (std::exception& e) {
32699       {
32700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32701       };
32702     } catch (...) {
32703       {
32704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32705       };
32706     }
32707   }
32708 }
32709
32710
32711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32712   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32713   Dali::Layer::Behavior arg2 ;
32714
32715   arg1 = (Dali::Layer *)jarg1;
32716   arg2 = (Dali::Layer::Behavior)jarg2;
32717   {
32718     try {
32719       (arg1)->SetBehavior(arg2);
32720     } catch (std::out_of_range& e) {
32721       {
32722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32723       };
32724     } catch (std::exception& e) {
32725       {
32726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32727       };
32728     } catch (...) {
32729       {
32730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32731       };
32732     }
32733   }
32734 }
32735
32736
32737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
32738   int jresult ;
32739   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32740   Dali::Layer::Behavior result;
32741
32742   arg1 = (Dali::Layer *)jarg1;
32743   {
32744     try {
32745       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32746     } catch (std::out_of_range& e) {
32747       {
32748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32749       };
32750     } catch (std::exception& e) {
32751       {
32752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32753       };
32754     } catch (...) {
32755       {
32756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32757       };
32758     }
32759   }
32760   jresult = (int)result;
32761   return jresult;
32762 }
32763
32764
32765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
32766   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32767   bool arg2 ;
32768
32769   arg1 = (Dali::Layer *)jarg1;
32770   arg2 = jarg2 ? true : false;
32771   {
32772     try {
32773       (arg1)->SetClipping(arg2);
32774     } catch (std::out_of_range& e) {
32775       {
32776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32777       };
32778     } catch (std::exception& e) {
32779       {
32780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32781       };
32782     } catch (...) {
32783       {
32784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32785       };
32786     }
32787   }
32788 }
32789
32790
32791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
32792   unsigned int jresult ;
32793   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32794   bool result;
32795
32796   arg1 = (Dali::Layer *)jarg1;
32797   {
32798     try {
32799       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
32800     } catch (std::out_of_range& e) {
32801       {
32802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32803       };
32804     } catch (std::exception& e) {
32805       {
32806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32807       };
32808     } catch (...) {
32809       {
32810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32811       };
32812     }
32813   }
32814   jresult = result;
32815   return jresult;
32816 }
32817
32818
32819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
32820   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32821   int arg2 ;
32822   int arg3 ;
32823   int arg4 ;
32824   int arg5 ;
32825
32826   arg1 = (Dali::Layer *)jarg1;
32827   arg2 = (int)jarg2;
32828   arg3 = (int)jarg3;
32829   arg4 = (int)jarg4;
32830   arg5 = (int)jarg5;
32831   {
32832     try {
32833       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
32834     } catch (std::out_of_range& e) {
32835       {
32836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32837       };
32838     } catch (std::exception& e) {
32839       {
32840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32841       };
32842     } catch (...) {
32843       {
32844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32845       };
32846     }
32847   }
32848 }
32849
32850
32851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
32852   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32853   Dali::ClippingBox arg2 ;
32854   Dali::ClippingBox *argp2 ;
32855
32856   arg1 = (Dali::Layer *)jarg1;
32857   argp2 = (Dali::ClippingBox *)jarg2;
32858   if (!argp2) {
32859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
32860     return ;
32861   }
32862   arg2 = *argp2;
32863   {
32864     try {
32865       (arg1)->SetClippingBox(arg2);
32866     } catch (std::out_of_range& e) {
32867       {
32868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32869       };
32870     } catch (std::exception& e) {
32871       {
32872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32873       };
32874     } catch (...) {
32875       {
32876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32877       };
32878     }
32879   }
32880 }
32881
32882
32883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
32884   void * jresult ;
32885   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32886   Dali::ClippingBox result;
32887
32888   arg1 = (Dali::Layer *)jarg1;
32889   {
32890     try {
32891       result = ((Dali::Layer const *)arg1)->GetClippingBox();
32892     } catch (std::out_of_range& e) {
32893       {
32894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32895       };
32896     } catch (std::exception& e) {
32897       {
32898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32899       };
32900     } catch (...) {
32901       {
32902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32903       };
32904     }
32905   }
32906   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
32907   return jresult;
32908 }
32909
32910
32911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
32912   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32913   bool arg2 ;
32914
32915   arg1 = (Dali::Layer *)jarg1;
32916   arg2 = jarg2 ? true : false;
32917   {
32918     try {
32919       (arg1)->SetDepthTestDisabled(arg2);
32920     } catch (std::out_of_range& e) {
32921       {
32922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32923       };
32924     } catch (std::exception& e) {
32925       {
32926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32927       };
32928     } catch (...) {
32929       {
32930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32931       };
32932     }
32933   }
32934 }
32935
32936
32937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
32938   unsigned int jresult ;
32939   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32940   bool result;
32941
32942   arg1 = (Dali::Layer *)jarg1;
32943   {
32944     try {
32945       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
32946     } catch (std::out_of_range& e) {
32947       {
32948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32949       };
32950     } catch (std::exception& e) {
32951       {
32952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32953       };
32954     } catch (...) {
32955       {
32956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32957       };
32958     }
32959   }
32960   jresult = result;
32961   return jresult;
32962 }
32963
32964
32965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
32966   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32967   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
32968
32969   arg1 = (Dali::Layer *)jarg1;
32970   arg2 = (Dali::Layer::SortFunctionType)jarg2;
32971   {
32972     try {
32973       (arg1)->SetSortFunction(arg2);
32974     } catch (std::out_of_range& e) {
32975       {
32976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32977       };
32978     } catch (std::exception& e) {
32979       {
32980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32981       };
32982     } catch (...) {
32983       {
32984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32985       };
32986     }
32987   }
32988 }
32989
32990
32991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
32992   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32993   bool arg2 ;
32994
32995   arg1 = (Dali::Layer *)jarg1;
32996   arg2 = jarg2 ? true : false;
32997   {
32998     try {
32999       (arg1)->SetTouchConsumed(arg2);
33000     } catch (std::out_of_range& e) {
33001       {
33002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33003       };
33004     } catch (std::exception& e) {
33005       {
33006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33007       };
33008     } catch (...) {
33009       {
33010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33011       };
33012     }
33013   }
33014 }
33015
33016
33017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33018   unsigned int jresult ;
33019   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33020   bool result;
33021
33022   arg1 = (Dali::Layer *)jarg1;
33023   {
33024     try {
33025       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33026     } catch (std::out_of_range& e) {
33027       {
33028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33029       };
33030     } catch (std::exception& e) {
33031       {
33032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33033       };
33034     } catch (...) {
33035       {
33036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33037       };
33038     }
33039   }
33040   jresult = result;
33041   return jresult;
33042 }
33043
33044
33045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33046   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33047   bool arg2 ;
33048
33049   arg1 = (Dali::Layer *)jarg1;
33050   arg2 = jarg2 ? true : false;
33051   {
33052     try {
33053       (arg1)->SetHoverConsumed(arg2);
33054     } catch (std::out_of_range& e) {
33055       {
33056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33057       };
33058     } catch (std::exception& e) {
33059       {
33060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33061       };
33062     } catch (...) {
33063       {
33064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33065       };
33066     }
33067   }
33068 }
33069
33070
33071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33072   unsigned int jresult ;
33073   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33074   bool result;
33075
33076   arg1 = (Dali::Layer *)jarg1;
33077   {
33078     try {
33079       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33080     } catch (std::out_of_range& e) {
33081       {
33082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33083       };
33084     } catch (std::exception& e) {
33085       {
33086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33087       };
33088     } catch (...) {
33089       {
33090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33091       };
33092     }
33093   }
33094   jresult = result;
33095   return jresult;
33096 }
33097
33098
33099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33100   void * jresult ;
33101   Dali::Vector4 *result = 0 ;
33102
33103   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33104   jresult = (void *)result;
33105   return jresult;
33106 }
33107
33108
33109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33110   void * jresult ;
33111   Dali::Vector4 *result = 0 ;
33112
33113   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33114   jresult = (void *)result;
33115   return jresult;
33116 }
33117
33118
33119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33120   void * jresult ;
33121   Dali::Stage *result = 0 ;
33122
33123   {
33124     try {
33125       result = (Dali::Stage *)new Dali::Stage();
33126     } catch (std::out_of_range& e) {
33127       {
33128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33129       };
33130     } catch (std::exception& e) {
33131       {
33132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33133       };
33134     } catch (...) {
33135       {
33136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33137       };
33138     }
33139   }
33140   jresult = (void *)result;
33141   return jresult;
33142 }
33143
33144
33145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33146   void * jresult ;
33147   Dali::Stage result;
33148
33149   {
33150     try {
33151       result = Dali::Stage::GetCurrent();
33152     } catch (std::out_of_range& e) {
33153       {
33154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33155       };
33156     } catch (std::exception& e) {
33157       {
33158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33159       };
33160     } catch (...) {
33161       {
33162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33163       };
33164     }
33165   }
33166   jresult = new Dali::Stage((const Dali::Stage &)result);
33167   return jresult;
33168 }
33169
33170
33171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33172   unsigned int jresult ;
33173   bool result;
33174
33175   {
33176     try {
33177       result = (bool)Dali::Stage::IsInstalled();
33178     } catch (std::out_of_range& e) {
33179       {
33180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33181       };
33182     } catch (std::exception& e) {
33183       {
33184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33185       };
33186     } catch (...) {
33187       {
33188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33189       };
33190     }
33191   }
33192   jresult = result;
33193   return jresult;
33194 }
33195
33196
33197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33198   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33199
33200   arg1 = (Dali::Stage *)jarg1;
33201   {
33202     try {
33203       delete arg1;
33204     } catch (std::out_of_range& e) {
33205       {
33206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33207       };
33208     } catch (std::exception& e) {
33209       {
33210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33211       };
33212     } catch (...) {
33213       {
33214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33215       };
33216     }
33217   }
33218 }
33219
33220
33221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33222   void * jresult ;
33223   Dali::Stage *arg1 = 0 ;
33224   Dali::Stage *result = 0 ;
33225
33226   arg1 = (Dali::Stage *)jarg1;
33227   if (!arg1) {
33228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33229     return 0;
33230   }
33231   {
33232     try {
33233       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33234     } catch (std::out_of_range& e) {
33235       {
33236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33237       };
33238     } catch (std::exception& e) {
33239       {
33240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33241       };
33242     } catch (...) {
33243       {
33244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33245       };
33246     }
33247   }
33248   jresult = (void *)result;
33249   return jresult;
33250 }
33251
33252
33253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33254   void * jresult ;
33255   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33256   Dali::Stage *arg2 = 0 ;
33257   Dali::Stage *result = 0 ;
33258
33259   arg1 = (Dali::Stage *)jarg1;
33260   arg2 = (Dali::Stage *)jarg2;
33261   if (!arg2) {
33262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33263     return 0;
33264   }
33265   {
33266     try {
33267       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33268     } catch (std::out_of_range& e) {
33269       {
33270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33271       };
33272     } catch (std::exception& e) {
33273       {
33274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33275       };
33276     } catch (...) {
33277       {
33278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33279       };
33280     }
33281   }
33282   jresult = (void *)result;
33283   return jresult;
33284 }
33285
33286
33287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33288   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33289   Dali::Actor *arg2 = 0 ;
33290
33291   arg1 = (Dali::Stage *)jarg1;
33292   arg2 = (Dali::Actor *)jarg2;
33293   if (!arg2) {
33294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33295     return ;
33296   }
33297   {
33298     try {
33299       (arg1)->Add(*arg2);
33300     } catch (std::out_of_range& e) {
33301       {
33302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33303       };
33304     } catch (std::exception& e) {
33305       {
33306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33307       };
33308     } catch (...) {
33309       {
33310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33311       };
33312     }
33313   }
33314 }
33315
33316
33317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33318   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33319   Dali::Actor *arg2 = 0 ;
33320
33321   arg1 = (Dali::Stage *)jarg1;
33322   arg2 = (Dali::Actor *)jarg2;
33323   if (!arg2) {
33324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33325     return ;
33326   }
33327   {
33328     try {
33329       (arg1)->Remove(*arg2);
33330     } catch (std::out_of_range& e) {
33331       {
33332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33333       };
33334     } catch (std::exception& e) {
33335       {
33336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33337       };
33338     } catch (...) {
33339       {
33340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33341       };
33342     }
33343   }
33344 }
33345
33346
33347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33348   void * jresult ;
33349   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33350   Dali::Vector2 result;
33351
33352   arg1 = (Dali::Stage *)jarg1;
33353   {
33354     try {
33355       result = ((Dali::Stage const *)arg1)->GetSize();
33356     } catch (std::out_of_range& e) {
33357       {
33358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33359       };
33360     } catch (std::exception& e) {
33361       {
33362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33363       };
33364     } catch (...) {
33365       {
33366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33367       };
33368     }
33369   }
33370   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33371   return jresult;
33372 }
33373
33374
33375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33376   void * jresult ;
33377   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33378   Dali::RenderTaskList result;
33379
33380   arg1 = (Dali::Stage *)jarg1;
33381   {
33382     try {
33383       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33384     } catch (std::out_of_range& e) {
33385       {
33386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33387       };
33388     } catch (std::exception& e) {
33389       {
33390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33391       };
33392     } catch (...) {
33393       {
33394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33395       };
33396     }
33397   }
33398   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33399   return jresult;
33400 }
33401
33402
33403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33404   unsigned int jresult ;
33405   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33406   unsigned int result;
33407
33408   arg1 = (Dali::Stage *)jarg1;
33409   {
33410     try {
33411       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33412     } catch (std::out_of_range& e) {
33413       {
33414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33415       };
33416     } catch (std::exception& e) {
33417       {
33418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33419       };
33420     } catch (...) {
33421       {
33422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33423       };
33424     }
33425   }
33426   jresult = result;
33427   return jresult;
33428 }
33429
33430
33431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33432   void * jresult ;
33433   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33434   unsigned int arg2 ;
33435   Dali::Layer result;
33436
33437   arg1 = (Dali::Stage *)jarg1;
33438   arg2 = (unsigned int)jarg2;
33439   {
33440     try {
33441       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33442     } catch (std::out_of_range& e) {
33443       {
33444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33445       };
33446     } catch (std::exception& e) {
33447       {
33448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33449       };
33450     } catch (...) {
33451       {
33452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33453       };
33454     }
33455   }
33456   jresult = new Dali::Layer((const Dali::Layer &)result);
33457   return jresult;
33458 }
33459
33460
33461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33462   void * jresult ;
33463   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33464   Dali::Layer result;
33465
33466   arg1 = (Dali::Stage *)jarg1;
33467   {
33468     try {
33469       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33470     } catch (std::out_of_range& e) {
33471       {
33472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33473       };
33474     } catch (std::exception& e) {
33475       {
33476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33477       };
33478     } catch (...) {
33479       {
33480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33481       };
33482     }
33483   }
33484   jresult = new Dali::Layer((const Dali::Layer &)result);
33485   return jresult;
33486 }
33487
33488
33489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33490   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33491   Dali::Vector4 arg2 ;
33492   Dali::Vector4 *argp2 ;
33493
33494   arg1 = (Dali::Stage *)jarg1;
33495   argp2 = (Dali::Vector4 *)jarg2;
33496   if (!argp2) {
33497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33498     return ;
33499   }
33500   arg2 = *argp2;
33501   {
33502     try {
33503       (arg1)->SetBackgroundColor(arg2);
33504     } catch (std::out_of_range& e) {
33505       {
33506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33507       };
33508     } catch (std::exception& e) {
33509       {
33510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33511       };
33512     } catch (...) {
33513       {
33514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33515       };
33516     }
33517   }
33518 }
33519
33520
33521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33522   void * jresult ;
33523   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33524   Dali::Vector4 result;
33525
33526   arg1 = (Dali::Stage *)jarg1;
33527   {
33528     try {
33529       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33530     } catch (std::out_of_range& e) {
33531       {
33532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33533       };
33534     } catch (std::exception& e) {
33535       {
33536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33537       };
33538     } catch (...) {
33539       {
33540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33541       };
33542     }
33543   }
33544   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33545   return jresult;
33546 }
33547
33548
33549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33550   void * jresult ;
33551   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33552   Dali::Vector2 result;
33553
33554   arg1 = (Dali::Stage *)jarg1;
33555   {
33556     try {
33557       result = ((Dali::Stage const *)arg1)->GetDpi();
33558     } catch (std::out_of_range& e) {
33559       {
33560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33561       };
33562     } catch (std::exception& e) {
33563       {
33564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33565       };
33566     } catch (...) {
33567       {
33568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33569       };
33570     }
33571   }
33572   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33573   return jresult;
33574 }
33575
33576
33577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33578   void * jresult ;
33579   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33580   Dali::ObjectRegistry result;
33581
33582   arg1 = (Dali::Stage *)jarg1;
33583   {
33584     try {
33585       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33586     } catch (std::out_of_range& e) {
33587       {
33588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33589       };
33590     } catch (std::exception& e) {
33591       {
33592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33593       };
33594     } catch (...) {
33595       {
33596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33597       };
33598     }
33599   }
33600   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33601   return jresult;
33602 }
33603
33604
33605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33606   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33607   float arg2 ;
33608
33609   arg1 = (Dali::Stage *)jarg1;
33610   arg2 = (float)jarg2;
33611   {
33612     try {
33613       (arg1)->KeepRendering(arg2);
33614     } catch (std::out_of_range& e) {
33615       {
33616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33617       };
33618     } catch (std::exception& e) {
33619       {
33620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33621       };
33622     } catch (...) {
33623       {
33624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33625       };
33626     }
33627   }
33628 }
33629
33630
33631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33632   void * jresult ;
33633   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33634   Dali::Stage::KeyEventSignalType *result = 0 ;
33635
33636   arg1 = (Dali::Stage *)jarg1;
33637   {
33638     try {
33639       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33640     } catch (std::out_of_range& e) {
33641       {
33642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33643       };
33644     } catch (std::exception& e) {
33645       {
33646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33647       };
33648     } catch (...) {
33649       {
33650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33651       };
33652     }
33653   }
33654   jresult = (void *)result;
33655   return jresult;
33656 }
33657
33658
33659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33660   void * jresult ;
33661   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33662   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33663
33664   arg1 = (Dali::Stage *)jarg1;
33665   {
33666     try {
33667       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33668     } catch (std::out_of_range& e) {
33669       {
33670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33671       };
33672     } catch (std::exception& e) {
33673       {
33674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33675       };
33676     } catch (...) {
33677       {
33678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33679       };
33680     }
33681   }
33682   jresult = (void *)result;
33683   return jresult;
33684 }
33685
33686
33687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33688   void * jresult ;
33689   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33690   Dali::Stage::TouchSignalType *result = 0 ;
33691
33692   arg1 = (Dali::Stage *)jarg1;
33693   {
33694     try {
33695       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33696     } catch (std::out_of_range& e) {
33697       {
33698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33699       };
33700     } catch (std::exception& e) {
33701       {
33702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33703       };
33704     } catch (...) {
33705       {
33706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33707       };
33708     }
33709   }
33710   jresult = (void *)result;
33711   return jresult;
33712 }
33713
33714
33715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33716   void * jresult ;
33717   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33718   Dali::Stage::WheelEventSignalType *result = 0 ;
33719
33720   arg1 = (Dali::Stage *)jarg1;
33721   {
33722     try {
33723       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33724     } catch (std::out_of_range& e) {
33725       {
33726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33727       };
33728     } catch (std::exception& e) {
33729       {
33730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33731       };
33732     } catch (...) {
33733       {
33734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33735       };
33736     }
33737   }
33738   jresult = (void *)result;
33739   return jresult;
33740 }
33741
33742
33743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
33744   void * jresult ;
33745   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33746   Dali::Stage::ContextStatusSignal *result = 0 ;
33747
33748   arg1 = (Dali::Stage *)jarg1;
33749   {
33750     try {
33751       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33752     } catch (std::out_of_range& e) {
33753       {
33754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33755       };
33756     } catch (std::exception& e) {
33757       {
33758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33759       };
33760     } catch (...) {
33761       {
33762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33763       };
33764     }
33765   }
33766   jresult = (void *)result;
33767   return jresult;
33768 }
33769
33770
33771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
33772   void * jresult ;
33773   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33774   Dali::Stage::ContextStatusSignal *result = 0 ;
33775
33776   arg1 = (Dali::Stage *)jarg1;
33777   {
33778     try {
33779       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
33780     } catch (std::out_of_range& e) {
33781       {
33782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33783       };
33784     } catch (std::exception& e) {
33785       {
33786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33787       };
33788     } catch (...) {
33789       {
33790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33791       };
33792     }
33793   }
33794   jresult = (void *)result;
33795   return jresult;
33796 }
33797
33798
33799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
33800   void * jresult ;
33801   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33802   Dali::Stage::SceneCreatedSignalType *result = 0 ;
33803
33804   arg1 = (Dali::Stage *)jarg1;
33805   {
33806     try {
33807       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
33808     } catch (std::out_of_range& e) {
33809       {
33810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33811       };
33812     } catch (std::exception& e) {
33813       {
33814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33815       };
33816     } catch (...) {
33817       {
33818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33819       };
33820     }
33821   }
33822   jresult = (void *)result;
33823   return jresult;
33824 }
33825
33826
33827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
33828   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33829
33830   arg1 = (Dali::RelayoutContainer *)jarg1;
33831   {
33832     try {
33833       delete arg1;
33834     } catch (std::out_of_range& e) {
33835       {
33836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33837       };
33838     } catch (std::exception& e) {
33839       {
33840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33841       };
33842     } catch (...) {
33843       {
33844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33845       };
33846     }
33847   }
33848 }
33849
33850
33851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
33852   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33853   Dali::Actor *arg2 = 0 ;
33854   Dali::Vector2 *arg3 = 0 ;
33855
33856   arg1 = (Dali::RelayoutContainer *)jarg1;
33857   arg2 = (Dali::Actor *)jarg2;
33858   if (!arg2) {
33859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33860     return ;
33861   }
33862   arg3 = (Dali::Vector2 *)jarg3;
33863   if (!arg3) {
33864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
33865     return ;
33866   }
33867   {
33868     try {
33869       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
33870     } catch (std::out_of_range& e) {
33871       {
33872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33873       };
33874     } catch (std::exception& e) {
33875       {
33876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33877       };
33878     } catch (...) {
33879       {
33880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33881       };
33882     }
33883   }
33884 }
33885
33886
33887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
33888   void * jresult ;
33889   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33890   Dali::CustomActor result;
33891
33892   arg1 = (Dali::CustomActorImpl *)jarg1;
33893   {
33894     try {
33895       result = ((Dali::CustomActorImpl const *)arg1)->Self();
33896     } catch (std::out_of_range& e) {
33897       {
33898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33899       };
33900     } catch (std::exception& e) {
33901       {
33902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33903       };
33904     } catch (...) {
33905       {
33906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33907       };
33908     }
33909   }
33910   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
33911   return jresult;
33912 }
33913
33914
33915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
33916   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33917   int arg2 ;
33918
33919   arg1 = (Dali::CustomActorImpl *)jarg1;
33920   arg2 = (int)jarg2;
33921   {
33922     try {
33923       (arg1)->OnStageConnection(arg2);
33924     } catch (std::out_of_range& e) {
33925       {
33926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33927       };
33928     } catch (std::exception& e) {
33929       {
33930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33931       };
33932     } catch (...) {
33933       {
33934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33935       };
33936     }
33937   }
33938 }
33939
33940
33941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
33942   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33943
33944   arg1 = (Dali::CustomActorImpl *)jarg1;
33945   {
33946     try {
33947       (arg1)->OnStageDisconnection();
33948     } catch (std::out_of_range& e) {
33949       {
33950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33951       };
33952     } catch (std::exception& e) {
33953       {
33954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33955       };
33956     } catch (...) {
33957       {
33958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33959       };
33960     }
33961   }
33962 }
33963
33964
33965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
33966   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33967   Dali::Actor *arg2 = 0 ;
33968
33969   arg1 = (Dali::CustomActorImpl *)jarg1;
33970   arg2 = (Dali::Actor *)jarg2;
33971   if (!arg2) {
33972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33973     return ;
33974   }
33975   {
33976     try {
33977       (arg1)->OnChildAdd(*arg2);
33978     } catch (std::out_of_range& e) {
33979       {
33980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33981       };
33982     } catch (std::exception& e) {
33983       {
33984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33985       };
33986     } catch (...) {
33987       {
33988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33989       };
33990     }
33991   }
33992 }
33993
33994
33995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
33996   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
33997   Dali::Actor *arg2 = 0 ;
33998
33999   arg1 = (Dali::CustomActorImpl *)jarg1;
34000   arg2 = (Dali::Actor *)jarg2;
34001   if (!arg2) {
34002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34003     return ;
34004   }
34005   {
34006     try {
34007       (arg1)->OnChildRemove(*arg2);
34008     } catch (std::out_of_range& e) {
34009       {
34010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34011       };
34012     } catch (std::exception& e) {
34013       {
34014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34015       };
34016     } catch (...) {
34017       {
34018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34019       };
34020     }
34021   }
34022 }
34023
34024
34025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34026   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34027   Dali::Property::Index arg2 ;
34028   Dali::Property::Value arg3 ;
34029   Dali::Property::Value *argp3 ;
34030
34031   arg1 = (Dali::CustomActorImpl *)jarg1;
34032   arg2 = (Dali::Property::Index)jarg2;
34033   argp3 = (Dali::Property::Value *)jarg3;
34034   if (!argp3) {
34035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34036     return ;
34037   }
34038   arg3 = *argp3;
34039   {
34040     try {
34041       (arg1)->OnPropertySet(arg2,arg3);
34042     } catch (std::out_of_range& e) {
34043       {
34044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34045       };
34046     } catch (std::exception& e) {
34047       {
34048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34049       };
34050     } catch (...) {
34051       {
34052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34053       };
34054     }
34055   }
34056 }
34057
34058
34059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34060   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34061   Dali::Vector3 *arg2 = 0 ;
34062
34063   arg1 = (Dali::CustomActorImpl *)jarg1;
34064   arg2 = (Dali::Vector3 *)jarg2;
34065   if (!arg2) {
34066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34067     return ;
34068   }
34069   {
34070     try {
34071       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34072     } catch (std::out_of_range& e) {
34073       {
34074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34075       };
34076     } catch (std::exception& e) {
34077       {
34078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34079       };
34080     } catch (...) {
34081       {
34082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34083       };
34084     }
34085   }
34086 }
34087
34088
34089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34090   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34091   Dali::Animation *arg2 = 0 ;
34092   Dali::Vector3 *arg3 = 0 ;
34093
34094   arg1 = (Dali::CustomActorImpl *)jarg1;
34095   arg2 = (Dali::Animation *)jarg2;
34096   if (!arg2) {
34097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34098     return ;
34099   }
34100   arg3 = (Dali::Vector3 *)jarg3;
34101   if (!arg3) {
34102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34103     return ;
34104   }
34105   {
34106     try {
34107       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34108     } catch (std::out_of_range& e) {
34109       {
34110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34111       };
34112     } catch (std::exception& e) {
34113       {
34114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34115       };
34116     } catch (...) {
34117       {
34118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34119       };
34120     }
34121   }
34122 }
34123
34124
34125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34126   unsigned int jresult ;
34127   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34128   Dali::TouchEvent *arg2 = 0 ;
34129   bool result;
34130
34131   arg1 = (Dali::CustomActorImpl *)jarg1;
34132   arg2 = (Dali::TouchEvent *)jarg2;
34133   if (!arg2) {
34134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34135     return 0;
34136   }
34137   {
34138     try {
34139       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34140     } catch (std::out_of_range& e) {
34141       {
34142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34143       };
34144     } catch (std::exception& e) {
34145       {
34146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34147       };
34148     } catch (...) {
34149       {
34150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34151       };
34152     }
34153   }
34154   jresult = result;
34155   return jresult;
34156 }
34157
34158
34159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34160   unsigned int jresult ;
34161   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34162   Dali::HoverEvent *arg2 = 0 ;
34163   bool result;
34164
34165   arg1 = (Dali::CustomActorImpl *)jarg1;
34166   arg2 = (Dali::HoverEvent *)jarg2;
34167   if (!arg2) {
34168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34169     return 0;
34170   }
34171   {
34172     try {
34173       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34174     } catch (std::out_of_range& e) {
34175       {
34176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34177       };
34178     } catch (std::exception& e) {
34179       {
34180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34181       };
34182     } catch (...) {
34183       {
34184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34185       };
34186     }
34187   }
34188   jresult = result;
34189   return jresult;
34190 }
34191
34192
34193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34194   unsigned int jresult ;
34195   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34196   Dali::KeyEvent *arg2 = 0 ;
34197   bool result;
34198
34199   arg1 = (Dali::CustomActorImpl *)jarg1;
34200   arg2 = (Dali::KeyEvent *)jarg2;
34201   if (!arg2) {
34202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34203     return 0;
34204   }
34205   {
34206     try {
34207       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34208     } catch (std::out_of_range& e) {
34209       {
34210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34211       };
34212     } catch (std::exception& e) {
34213       {
34214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34215       };
34216     } catch (...) {
34217       {
34218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34219       };
34220     }
34221   }
34222   jresult = result;
34223   return jresult;
34224 }
34225
34226
34227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34228   unsigned int jresult ;
34229   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34230   Dali::WheelEvent *arg2 = 0 ;
34231   bool result;
34232
34233   arg1 = (Dali::CustomActorImpl *)jarg1;
34234   arg2 = (Dali::WheelEvent *)jarg2;
34235   if (!arg2) {
34236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34237     return 0;
34238   }
34239   {
34240     try {
34241       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34242     } catch (std::out_of_range& e) {
34243       {
34244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34245       };
34246     } catch (std::exception& e) {
34247       {
34248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34249       };
34250     } catch (...) {
34251       {
34252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34253       };
34254     }
34255   }
34256   jresult = result;
34257   return jresult;
34258 }
34259
34260
34261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34262   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34263   Dali::Vector2 *arg2 = 0 ;
34264   Dali::RelayoutContainer *arg3 = 0 ;
34265
34266   arg1 = (Dali::CustomActorImpl *)jarg1;
34267   arg2 = (Dali::Vector2 *)jarg2;
34268   if (!arg2) {
34269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34270     return ;
34271   }
34272   arg3 = (Dali::RelayoutContainer *)jarg3;
34273   if (!arg3) {
34274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34275     return ;
34276   }
34277   {
34278     try {
34279       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34280     } catch (std::out_of_range& e) {
34281       {
34282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34283       };
34284     } catch (std::exception& e) {
34285       {
34286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34287       };
34288     } catch (...) {
34289       {
34290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34291       };
34292     }
34293   }
34294 }
34295
34296
34297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34298   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34299   Dali::ResizePolicy::Type arg2 ;
34300   Dali::Dimension::Type arg3 ;
34301
34302   arg1 = (Dali::CustomActorImpl *)jarg1;
34303   arg2 = (Dali::ResizePolicy::Type)jarg2;
34304   arg3 = (Dali::Dimension::Type)jarg3;
34305   {
34306     try {
34307       (arg1)->OnSetResizePolicy(arg2,arg3);
34308     } catch (std::out_of_range& e) {
34309       {
34310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34311       };
34312     } catch (std::exception& e) {
34313       {
34314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34315       };
34316     } catch (...) {
34317       {
34318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34319       };
34320     }
34321   }
34322 }
34323
34324
34325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34326   void * jresult ;
34327   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34328   Dali::Vector3 result;
34329
34330   arg1 = (Dali::CustomActorImpl *)jarg1;
34331   {
34332     try {
34333       result = (arg1)->GetNaturalSize();
34334     } catch (std::out_of_range& e) {
34335       {
34336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34337       };
34338     } catch (std::exception& e) {
34339       {
34340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34341       };
34342     } catch (...) {
34343       {
34344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34345       };
34346     }
34347   }
34348   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34349   return jresult;
34350 }
34351
34352
34353 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34354   float jresult ;
34355   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34356   Dali::Actor *arg2 = 0 ;
34357   Dali::Dimension::Type arg3 ;
34358   float result;
34359
34360   arg1 = (Dali::CustomActorImpl *)jarg1;
34361   arg2 = (Dali::Actor *)jarg2;
34362   if (!arg2) {
34363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34364     return 0;
34365   }
34366   arg3 = (Dali::Dimension::Type)jarg3;
34367   {
34368     try {
34369       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34370     } catch (std::out_of_range& e) {
34371       {
34372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34373       };
34374     } catch (std::exception& e) {
34375       {
34376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34377       };
34378     } catch (...) {
34379       {
34380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34381       };
34382     }
34383   }
34384   jresult = result;
34385   return jresult;
34386 }
34387
34388
34389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34390   float jresult ;
34391   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34392   float arg2 ;
34393   float result;
34394
34395   arg1 = (Dali::CustomActorImpl *)jarg1;
34396   arg2 = (float)jarg2;
34397   {
34398     try {
34399       result = (float)(arg1)->GetHeightForWidth(arg2);
34400     } catch (std::out_of_range& e) {
34401       {
34402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34403       };
34404     } catch (std::exception& e) {
34405       {
34406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34407       };
34408     } catch (...) {
34409       {
34410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34411       };
34412     }
34413   }
34414   jresult = result;
34415   return jresult;
34416 }
34417
34418
34419 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34420   float jresult ;
34421   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34422   float arg2 ;
34423   float result;
34424
34425   arg1 = (Dali::CustomActorImpl *)jarg1;
34426   arg2 = (float)jarg2;
34427   {
34428     try {
34429       result = (float)(arg1)->GetWidthForHeight(arg2);
34430     } catch (std::out_of_range& e) {
34431       {
34432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34433       };
34434     } catch (std::exception& e) {
34435       {
34436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34437       };
34438     } catch (...) {
34439       {
34440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34441       };
34442     }
34443   }
34444   jresult = result;
34445   return jresult;
34446 }
34447
34448
34449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34450   unsigned int jresult ;
34451   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34452   Dali::Dimension::Type arg2 ;
34453   bool result;
34454
34455   arg1 = (Dali::CustomActorImpl *)jarg1;
34456   arg2 = (Dali::Dimension::Type)jarg2;
34457   {
34458     try {
34459       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34460     } catch (std::out_of_range& e) {
34461       {
34462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34463       };
34464     } catch (std::exception& e) {
34465       {
34466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34467       };
34468     } catch (...) {
34469       {
34470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34471       };
34472     }
34473   }
34474   jresult = result;
34475   return jresult;
34476 }
34477
34478
34479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34480   unsigned int jresult ;
34481   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34482   bool result;
34483
34484   arg1 = (Dali::CustomActorImpl *)jarg1;
34485   {
34486     try {
34487       result = (bool)(arg1)->RelayoutDependentOnChildren();
34488     } catch (std::out_of_range& e) {
34489       {
34490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34491       };
34492     } catch (std::exception& e) {
34493       {
34494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34495       };
34496     } catch (...) {
34497       {
34498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34499       };
34500     }
34501   }
34502   jresult = result;
34503   return jresult;
34504 }
34505
34506
34507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34508   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34509   Dali::Dimension::Type arg2 ;
34510
34511   arg1 = (Dali::CustomActorImpl *)jarg1;
34512   arg2 = (Dali::Dimension::Type)jarg2;
34513   {
34514     try {
34515       (arg1)->OnCalculateRelayoutSize(arg2);
34516     } catch (std::out_of_range& e) {
34517       {
34518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34519       };
34520     } catch (std::exception& e) {
34521       {
34522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34523       };
34524     } catch (...) {
34525       {
34526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34527       };
34528     }
34529   }
34530 }
34531
34532
34533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34534   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34535   float arg2 ;
34536   Dali::Dimension::Type arg3 ;
34537
34538   arg1 = (Dali::CustomActorImpl *)jarg1;
34539   arg2 = (float)jarg2;
34540   arg3 = (Dali::Dimension::Type)jarg3;
34541   {
34542     try {
34543       (arg1)->OnLayoutNegotiated(arg2,arg3);
34544     } catch (std::out_of_range& e) {
34545       {
34546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34547       };
34548     } catch (std::exception& e) {
34549       {
34550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34551       };
34552     } catch (...) {
34553       {
34554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34555       };
34556     }
34557   }
34558 }
34559
34560
34561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34562   unsigned int jresult ;
34563   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34564   bool result;
34565
34566   arg1 = (Dali::CustomActorImpl *)jarg1;
34567   {
34568     try {
34569       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34570     } catch (std::out_of_range& e) {
34571       {
34572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34573       };
34574     } catch (std::exception& e) {
34575       {
34576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34577       };
34578     } catch (...) {
34579       {
34580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34581       };
34582     }
34583   }
34584   jresult = result;
34585   return jresult;
34586 }
34587
34588
34589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34590   unsigned int jresult ;
34591   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34592   bool result;
34593
34594   arg1 = (Dali::CustomActorImpl *)jarg1;
34595   {
34596     try {
34597       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34598     } catch (std::out_of_range& e) {
34599       {
34600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34601       };
34602     } catch (std::exception& e) {
34603       {
34604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34605       };
34606     } catch (...) {
34607       {
34608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34609       };
34610     }
34611   }
34612   jresult = result;
34613   return jresult;
34614 }
34615
34616
34617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34618   unsigned int jresult ;
34619   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34620   bool result;
34621
34622   arg1 = (Dali::CustomActorImpl *)jarg1;
34623   {
34624     try {
34625       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34626     } catch (std::out_of_range& e) {
34627       {
34628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34629       };
34630     } catch (std::exception& e) {
34631       {
34632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34633       };
34634     } catch (...) {
34635       {
34636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34637       };
34638     }
34639   }
34640   jresult = result;
34641   return jresult;
34642 }
34643
34644
34645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34646   unsigned int jresult ;
34647   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34648   bool result;
34649
34650   arg1 = (Dali::CustomActorImpl *)jarg1;
34651   {
34652     try {
34653       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34654     } catch (std::out_of_range& e) {
34655       {
34656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34657       };
34658     } catch (std::exception& e) {
34659       {
34660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34661       };
34662     } catch (...) {
34663       {
34664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34665       };
34666     }
34667   }
34668   jresult = result;
34669   return jresult;
34670 }
34671
34672
34673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34674   void * jresult ;
34675   Dali::CustomActor *result = 0 ;
34676
34677   {
34678     try {
34679       result = (Dali::CustomActor *)new Dali::CustomActor();
34680     } catch (std::out_of_range& e) {
34681       {
34682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34683       };
34684     } catch (std::exception& e) {
34685       {
34686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34687       };
34688     } catch (...) {
34689       {
34690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34691       };
34692     }
34693   }
34694   jresult = (void *)result;
34695   return jresult;
34696 }
34697
34698
34699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34700   void * jresult ;
34701   Dali::BaseHandle arg1 ;
34702   Dali::BaseHandle *argp1 ;
34703   Dali::CustomActor result;
34704
34705   argp1 = (Dali::BaseHandle *)jarg1;
34706   if (!argp1) {
34707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34708     return 0;
34709   }
34710   arg1 = *argp1;
34711   {
34712     try {
34713       result = Dali::CustomActor::DownCast(arg1);
34714     } catch (std::out_of_range& e) {
34715       {
34716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34717       };
34718     } catch (std::exception& e) {
34719       {
34720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34721       };
34722     } catch (...) {
34723       {
34724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34725       };
34726     }
34727   }
34728   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34729   return jresult;
34730 }
34731
34732
34733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34734   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34735
34736   arg1 = (Dali::CustomActor *)jarg1;
34737   {
34738     try {
34739       delete arg1;
34740     } catch (std::out_of_range& e) {
34741       {
34742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34743       };
34744     } catch (std::exception& e) {
34745       {
34746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34747       };
34748     } catch (...) {
34749       {
34750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34751       };
34752     }
34753   }
34754 }
34755
34756
34757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
34758   void * jresult ;
34759   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34760   Dali::CustomActorImpl *result = 0 ;
34761
34762   arg1 = (Dali::CustomActor *)jarg1;
34763   {
34764     try {
34765       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
34766     } catch (std::out_of_range& e) {
34767       {
34768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34769       };
34770     } catch (std::exception& e) {
34771       {
34772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34773       };
34774     } catch (...) {
34775       {
34776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34777       };
34778     }
34779   }
34780   jresult = (void *)result;
34781   return jresult;
34782 }
34783
34784
34785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
34786   void * jresult ;
34787   Dali::CustomActorImpl *arg1 = 0 ;
34788   Dali::CustomActor *result = 0 ;
34789
34790   arg1 = (Dali::CustomActorImpl *)jarg1;
34791   if (!arg1) {
34792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
34793     return 0;
34794   }
34795   {
34796     try {
34797       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
34798     } catch (std::out_of_range& e) {
34799       {
34800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34801       };
34802     } catch (std::exception& e) {
34803       {
34804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34805       };
34806     } catch (...) {
34807       {
34808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34809       };
34810     }
34811   }
34812   jresult = (void *)result;
34813   return jresult;
34814 }
34815
34816
34817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
34818   void * jresult ;
34819   Dali::CustomActor *arg1 = 0 ;
34820   Dali::CustomActor *result = 0 ;
34821
34822   arg1 = (Dali::CustomActor *)jarg1;
34823   if (!arg1) {
34824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34825     return 0;
34826   }
34827   {
34828     try {
34829       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
34830     } catch (std::out_of_range& e) {
34831       {
34832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34833       };
34834     } catch (std::exception& e) {
34835       {
34836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34837       };
34838     } catch (...) {
34839       {
34840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34841       };
34842     }
34843   }
34844   jresult = (void *)result;
34845   return jresult;
34846 }
34847
34848
34849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
34850   void * jresult ;
34851   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34852   Dali::CustomActor *arg2 = 0 ;
34853   Dali::CustomActor *result = 0 ;
34854
34855   arg1 = (Dali::CustomActor *)jarg1;
34856   arg2 = (Dali::CustomActor *)jarg2;
34857   if (!arg2) {
34858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34859     return 0;
34860   }
34861   {
34862     try {
34863       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
34864     } catch (std::out_of_range& e) {
34865       {
34866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34867       };
34868     } catch (std::exception& e) {
34869       {
34870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34871       };
34872     } catch (...) {
34873       {
34874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34875       };
34876     }
34877   }
34878   jresult = (void *)result;
34879   return jresult;
34880 }
34881
34882
34883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
34884   int jresult ;
34885   int result;
34886
34887   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
34888   jresult = (int)result;
34889   return jresult;
34890 }
34891
34892
34893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
34894   int jresult ;
34895   int result;
34896
34897   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
34898   jresult = (int)result;
34899   return jresult;
34900 }
34901
34902
34903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
34904   int jresult ;
34905   int result;
34906
34907   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
34908   jresult = (int)result;
34909   return jresult;
34910 }
34911
34912
34913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
34914   int jresult ;
34915   int result;
34916
34917   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
34918   jresult = (int)result;
34919   return jresult;
34920 }
34921
34922
34923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
34924   int jresult ;
34925   int result;
34926
34927   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
34928   jresult = (int)result;
34929   return jresult;
34930 }
34931
34932
34933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
34934   int jresult ;
34935   int result;
34936
34937   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
34938   jresult = (int)result;
34939   return jresult;
34940 }
34941
34942
34943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
34944   int jresult ;
34945   int result;
34946
34947   result = (int)Dali::PanGestureDetector::Property::PANNING;
34948   jresult = (int)result;
34949   return jresult;
34950 }
34951
34952
34953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
34954   void * jresult ;
34955   Dali::PanGestureDetector::Property *result = 0 ;
34956
34957   {
34958     try {
34959       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
34960     } catch (std::out_of_range& e) {
34961       {
34962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34963       };
34964     } catch (std::exception& e) {
34965       {
34966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34967       };
34968     } catch (...) {
34969       {
34970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34971       };
34972     }
34973   }
34974   jresult = (void *)result;
34975   return jresult;
34976 }
34977
34978
34979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
34980   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
34981
34982   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
34983   {
34984     try {
34985       delete arg1;
34986     } catch (std::out_of_range& e) {
34987       {
34988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34989       };
34990     } catch (std::exception& e) {
34991       {
34992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34993       };
34994     } catch (...) {
34995       {
34996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34997       };
34998     }
34999   }
35000 }
35001
35002
35003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35004   void * jresult ;
35005   Dali::Radian *result = 0 ;
35006
35007   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35008   jresult = (void *)result;
35009   return jresult;
35010 }
35011
35012
35013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35014   void * jresult ;
35015   Dali::Radian *result = 0 ;
35016
35017   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35018   jresult = (void *)result;
35019   return jresult;
35020 }
35021
35022
35023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35024   void * jresult ;
35025   Dali::Radian *result = 0 ;
35026
35027   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35028   jresult = (void *)result;
35029   return jresult;
35030 }
35031
35032
35033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35034   void * jresult ;
35035   Dali::Radian *result = 0 ;
35036
35037   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35038   jresult = (void *)result;
35039   return jresult;
35040 }
35041
35042
35043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35044   void * jresult ;
35045   Dali::Radian *result = 0 ;
35046
35047   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35048   jresult = (void *)result;
35049   return jresult;
35050 }
35051
35052
35053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35054   void * jresult ;
35055   Dali::Radian *result = 0 ;
35056
35057   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35058   jresult = (void *)result;
35059   return jresult;
35060 }
35061
35062
35063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35064   void * jresult ;
35065   Dali::Radian *result = 0 ;
35066
35067   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35068   jresult = (void *)result;
35069   return jresult;
35070 }
35071
35072
35073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35074   void * jresult ;
35075   Dali::PanGestureDetector *result = 0 ;
35076
35077   {
35078     try {
35079       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35080     } catch (std::out_of_range& e) {
35081       {
35082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35083       };
35084     } catch (std::exception& e) {
35085       {
35086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35087       };
35088     } catch (...) {
35089       {
35090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35091       };
35092     }
35093   }
35094   jresult = (void *)result;
35095   return jresult;
35096 }
35097
35098
35099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35100   void * jresult ;
35101   Dali::PanGestureDetector result;
35102
35103   {
35104     try {
35105       result = Dali::PanGestureDetector::New();
35106     } catch (std::out_of_range& e) {
35107       {
35108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35109       };
35110     } catch (std::exception& e) {
35111       {
35112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35113       };
35114     } catch (...) {
35115       {
35116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35117       };
35118     }
35119   }
35120   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35121   return jresult;
35122 }
35123
35124
35125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35126   void * jresult ;
35127   Dali::BaseHandle arg1 ;
35128   Dali::BaseHandle *argp1 ;
35129   Dali::PanGestureDetector result;
35130
35131   argp1 = (Dali::BaseHandle *)jarg1;
35132   if (!argp1) {
35133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35134     return 0;
35135   }
35136   arg1 = *argp1;
35137   {
35138     try {
35139       result = Dali::PanGestureDetector::DownCast(arg1);
35140     } catch (std::out_of_range& e) {
35141       {
35142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35143       };
35144     } catch (std::exception& e) {
35145       {
35146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35147       };
35148     } catch (...) {
35149       {
35150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35151       };
35152     }
35153   }
35154   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35155   return jresult;
35156 }
35157
35158
35159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35160   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35161
35162   arg1 = (Dali::PanGestureDetector *)jarg1;
35163   {
35164     try {
35165       delete arg1;
35166     } catch (std::out_of_range& e) {
35167       {
35168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35169       };
35170     } catch (std::exception& e) {
35171       {
35172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35173       };
35174     } catch (...) {
35175       {
35176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35177       };
35178     }
35179   }
35180 }
35181
35182
35183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35184   void * jresult ;
35185   Dali::PanGestureDetector *arg1 = 0 ;
35186   Dali::PanGestureDetector *result = 0 ;
35187
35188   arg1 = (Dali::PanGestureDetector *)jarg1;
35189   if (!arg1) {
35190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35191     return 0;
35192   }
35193   {
35194     try {
35195       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35196     } catch (std::out_of_range& e) {
35197       {
35198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35199       };
35200     } catch (std::exception& e) {
35201       {
35202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35203       };
35204     } catch (...) {
35205       {
35206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35207       };
35208     }
35209   }
35210   jresult = (void *)result;
35211   return jresult;
35212 }
35213
35214
35215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35216   void * jresult ;
35217   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35218   Dali::PanGestureDetector *arg2 = 0 ;
35219   Dali::PanGestureDetector *result = 0 ;
35220
35221   arg1 = (Dali::PanGestureDetector *)jarg1;
35222   arg2 = (Dali::PanGestureDetector *)jarg2;
35223   if (!arg2) {
35224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35225     return 0;
35226   }
35227   {
35228     try {
35229       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35230     } catch (std::out_of_range& e) {
35231       {
35232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35233       };
35234     } catch (std::exception& e) {
35235       {
35236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35237       };
35238     } catch (...) {
35239       {
35240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35241       };
35242     }
35243   }
35244   jresult = (void *)result;
35245   return jresult;
35246 }
35247
35248
35249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35250   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35251   unsigned int arg2 ;
35252
35253   arg1 = (Dali::PanGestureDetector *)jarg1;
35254   arg2 = (unsigned int)jarg2;
35255   {
35256     try {
35257       (arg1)->SetMinimumTouchesRequired(arg2);
35258     } catch (std::out_of_range& e) {
35259       {
35260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35261       };
35262     } catch (std::exception& e) {
35263       {
35264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35265       };
35266     } catch (...) {
35267       {
35268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35269       };
35270     }
35271   }
35272 }
35273
35274
35275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35276   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35277   unsigned int arg2 ;
35278
35279   arg1 = (Dali::PanGestureDetector *)jarg1;
35280   arg2 = (unsigned int)jarg2;
35281   {
35282     try {
35283       (arg1)->SetMaximumTouchesRequired(arg2);
35284     } catch (std::out_of_range& e) {
35285       {
35286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35287       };
35288     } catch (std::exception& e) {
35289       {
35290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35291       };
35292     } catch (...) {
35293       {
35294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35295       };
35296     }
35297   }
35298 }
35299
35300
35301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35302   unsigned int jresult ;
35303   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35304   unsigned int result;
35305
35306   arg1 = (Dali::PanGestureDetector *)jarg1;
35307   {
35308     try {
35309       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35310     } catch (std::out_of_range& e) {
35311       {
35312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35313       };
35314     } catch (std::exception& e) {
35315       {
35316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35317       };
35318     } catch (...) {
35319       {
35320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35321       };
35322     }
35323   }
35324   jresult = result;
35325   return jresult;
35326 }
35327
35328
35329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35330   unsigned int jresult ;
35331   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35332   unsigned int result;
35333
35334   arg1 = (Dali::PanGestureDetector *)jarg1;
35335   {
35336     try {
35337       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35338     } catch (std::out_of_range& e) {
35339       {
35340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35341       };
35342     } catch (std::exception& e) {
35343       {
35344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35345       };
35346     } catch (...) {
35347       {
35348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35349       };
35350     }
35351   }
35352   jresult = result;
35353   return jresult;
35354 }
35355
35356
35357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35358   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35359   Dali::Radian arg2 ;
35360   Dali::Radian arg3 ;
35361   Dali::Radian *argp2 ;
35362   Dali::Radian *argp3 ;
35363
35364   arg1 = (Dali::PanGestureDetector *)jarg1;
35365   argp2 = (Dali::Radian *)jarg2;
35366   if (!argp2) {
35367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35368     return ;
35369   }
35370   arg2 = *argp2;
35371   argp3 = (Dali::Radian *)jarg3;
35372   if (!argp3) {
35373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35374     return ;
35375   }
35376   arg3 = *argp3;
35377   {
35378     try {
35379       (arg1)->AddAngle(arg2,arg3);
35380     } catch (std::out_of_range& e) {
35381       {
35382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35383       };
35384     } catch (std::exception& e) {
35385       {
35386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35387       };
35388     } catch (...) {
35389       {
35390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35391       };
35392     }
35393   }
35394 }
35395
35396
35397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35398   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35399   Dali::Radian arg2 ;
35400   Dali::Radian *argp2 ;
35401
35402   arg1 = (Dali::PanGestureDetector *)jarg1;
35403   argp2 = (Dali::Radian *)jarg2;
35404   if (!argp2) {
35405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35406     return ;
35407   }
35408   arg2 = *argp2;
35409   {
35410     try {
35411       (arg1)->AddAngle(arg2);
35412     } catch (std::out_of_range& e) {
35413       {
35414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35415       };
35416     } catch (std::exception& e) {
35417       {
35418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35419       };
35420     } catch (...) {
35421       {
35422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35423       };
35424     }
35425   }
35426 }
35427
35428
35429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35430   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35431   Dali::Radian arg2 ;
35432   Dali::Radian arg3 ;
35433   Dali::Radian *argp2 ;
35434   Dali::Radian *argp3 ;
35435
35436   arg1 = (Dali::PanGestureDetector *)jarg1;
35437   argp2 = (Dali::Radian *)jarg2;
35438   if (!argp2) {
35439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35440     return ;
35441   }
35442   arg2 = *argp2;
35443   argp3 = (Dali::Radian *)jarg3;
35444   if (!argp3) {
35445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35446     return ;
35447   }
35448   arg3 = *argp3;
35449   {
35450     try {
35451       (arg1)->AddDirection(arg2,arg3);
35452     } catch (std::out_of_range& e) {
35453       {
35454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35455       };
35456     } catch (std::exception& e) {
35457       {
35458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35459       };
35460     } catch (...) {
35461       {
35462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35463       };
35464     }
35465   }
35466 }
35467
35468
35469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35470   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35471   Dali::Radian arg2 ;
35472   Dali::Radian *argp2 ;
35473
35474   arg1 = (Dali::PanGestureDetector *)jarg1;
35475   argp2 = (Dali::Radian *)jarg2;
35476   if (!argp2) {
35477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35478     return ;
35479   }
35480   arg2 = *argp2;
35481   {
35482     try {
35483       (arg1)->AddDirection(arg2);
35484     } catch (std::out_of_range& e) {
35485       {
35486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35487       };
35488     } catch (std::exception& e) {
35489       {
35490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35491       };
35492     } catch (...) {
35493       {
35494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35495       };
35496     }
35497   }
35498 }
35499
35500
35501 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35502   unsigned long jresult ;
35503   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35504   size_t result;
35505
35506   arg1 = (Dali::PanGestureDetector *)jarg1;
35507   {
35508     try {
35509       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35510     } catch (std::out_of_range& e) {
35511       {
35512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35513       };
35514     } catch (std::exception& e) {
35515       {
35516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35517       };
35518     } catch (...) {
35519       {
35520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35521       };
35522     }
35523   }
35524   jresult = (unsigned long)result;
35525   return jresult;
35526 }
35527
35528
35529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35530   void * jresult ;
35531   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35532   size_t arg2 ;
35533   Dali::PanGestureDetector::AngleThresholdPair result;
35534
35535   arg1 = (Dali::PanGestureDetector *)jarg1;
35536   arg2 = (size_t)jarg2;
35537   {
35538     try {
35539       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35540     } catch (std::out_of_range& e) {
35541       {
35542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35543       };
35544     } catch (std::exception& e) {
35545       {
35546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35547       };
35548     } catch (...) {
35549       {
35550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35551       };
35552     }
35553   }
35554   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35555   return jresult;
35556 }
35557
35558
35559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35560   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35561
35562   arg1 = (Dali::PanGestureDetector *)jarg1;
35563   {
35564     try {
35565       (arg1)->ClearAngles();
35566     } catch (std::out_of_range& e) {
35567       {
35568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35569       };
35570     } catch (std::exception& e) {
35571       {
35572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35573       };
35574     } catch (...) {
35575       {
35576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35577       };
35578     }
35579   }
35580 }
35581
35582
35583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35584   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35585   Dali::Radian arg2 ;
35586   Dali::Radian *argp2 ;
35587
35588   arg1 = (Dali::PanGestureDetector *)jarg1;
35589   argp2 = (Dali::Radian *)jarg2;
35590   if (!argp2) {
35591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35592     return ;
35593   }
35594   arg2 = *argp2;
35595   {
35596     try {
35597       (arg1)->RemoveAngle(arg2);
35598     } catch (std::out_of_range& e) {
35599       {
35600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35601       };
35602     } catch (std::exception& e) {
35603       {
35604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35605       };
35606     } catch (...) {
35607       {
35608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35609       };
35610     }
35611   }
35612 }
35613
35614
35615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35616   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35617   Dali::Radian arg2 ;
35618   Dali::Radian *argp2 ;
35619
35620   arg1 = (Dali::PanGestureDetector *)jarg1;
35621   argp2 = (Dali::Radian *)jarg2;
35622   if (!argp2) {
35623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35624     return ;
35625   }
35626   arg2 = *argp2;
35627   {
35628     try {
35629       (arg1)->RemoveDirection(arg2);
35630     } catch (std::out_of_range& e) {
35631       {
35632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35633       };
35634     } catch (std::exception& e) {
35635       {
35636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35637       };
35638     } catch (...) {
35639       {
35640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35641       };
35642     }
35643   }
35644 }
35645
35646
35647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35648   void * jresult ;
35649   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35650   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35651
35652   arg1 = (Dali::PanGestureDetector *)jarg1;
35653   {
35654     try {
35655       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35656     } catch (std::out_of_range& e) {
35657       {
35658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35659       };
35660     } catch (std::exception& e) {
35661       {
35662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35663       };
35664     } catch (...) {
35665       {
35666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35667       };
35668     }
35669   }
35670   jresult = (void *)result;
35671   return jresult;
35672 }
35673
35674
35675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35676   Dali::PanGesture *arg1 = 0 ;
35677
35678   arg1 = (Dali::PanGesture *)jarg1;
35679   if (!arg1) {
35680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35681     return ;
35682   }
35683   {
35684     try {
35685       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35686     } catch (std::out_of_range& e) {
35687       {
35688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35689       };
35690     } catch (std::exception& e) {
35691       {
35692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35693       };
35694     } catch (...) {
35695       {
35696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35697       };
35698     }
35699   }
35700 }
35701
35702
35703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35704   void * jresult ;
35705   Dali::PanGesture *result = 0 ;
35706
35707   {
35708     try {
35709       result = (Dali::PanGesture *)new Dali::PanGesture();
35710     } catch (std::out_of_range& e) {
35711       {
35712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35713       };
35714     } catch (std::exception& e) {
35715       {
35716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35717       };
35718     } catch (...) {
35719       {
35720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35721       };
35722     }
35723   }
35724   jresult = (void *)result;
35725   return jresult;
35726 }
35727
35728
35729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35730   void * jresult ;
35731   Dali::Gesture::State arg1 ;
35732   Dali::PanGesture *result = 0 ;
35733
35734   arg1 = (Dali::Gesture::State)jarg1;
35735   {
35736     try {
35737       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35738     } catch (std::out_of_range& e) {
35739       {
35740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35741       };
35742     } catch (std::exception& e) {
35743       {
35744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35745       };
35746     } catch (...) {
35747       {
35748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35749       };
35750     }
35751   }
35752   jresult = (void *)result;
35753   return jresult;
35754 }
35755
35756
35757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
35758   void * jresult ;
35759   Dali::PanGesture *arg1 = 0 ;
35760   Dali::PanGesture *result = 0 ;
35761
35762   arg1 = (Dali::PanGesture *)jarg1;
35763   if (!arg1) {
35764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35765     return 0;
35766   }
35767   {
35768     try {
35769       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
35770     } catch (std::out_of_range& e) {
35771       {
35772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35773       };
35774     } catch (std::exception& e) {
35775       {
35776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35777       };
35778     } catch (...) {
35779       {
35780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35781       };
35782     }
35783   }
35784   jresult = (void *)result;
35785   return jresult;
35786 }
35787
35788
35789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
35790   void * jresult ;
35791   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35792   Dali::PanGesture *arg2 = 0 ;
35793   Dali::PanGesture *result = 0 ;
35794
35795   arg1 = (Dali::PanGesture *)jarg1;
35796   arg2 = (Dali::PanGesture *)jarg2;
35797   if (!arg2) {
35798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35799     return 0;
35800   }
35801   {
35802     try {
35803       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
35804     } catch (std::out_of_range& e) {
35805       {
35806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35807       };
35808     } catch (std::exception& e) {
35809       {
35810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35811       };
35812     } catch (...) {
35813       {
35814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35815       };
35816     }
35817   }
35818   jresult = (void *)result;
35819   return jresult;
35820 }
35821
35822
35823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
35824   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35825
35826   arg1 = (Dali::PanGesture *)jarg1;
35827   {
35828     try {
35829       delete arg1;
35830     } catch (std::out_of_range& e) {
35831       {
35832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35833       };
35834     } catch (std::exception& e) {
35835       {
35836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35837       };
35838     } catch (...) {
35839       {
35840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35841       };
35842     }
35843   }
35844 }
35845
35846
35847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
35848   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35849   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35850
35851   arg1 = (Dali::PanGesture *)jarg1;
35852   arg2 = (Dali::Vector2 *)jarg2;
35853   if (arg1) (arg1)->velocity = *arg2;
35854 }
35855
35856
35857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
35858   void * jresult ;
35859   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35860   Dali::Vector2 *result = 0 ;
35861
35862   arg1 = (Dali::PanGesture *)jarg1;
35863   result = (Dali::Vector2 *)& ((arg1)->velocity);
35864   jresult = (void *)result;
35865   return jresult;
35866 }
35867
35868
35869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
35870   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35871   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35872
35873   arg1 = (Dali::PanGesture *)jarg1;
35874   arg2 = (Dali::Vector2 *)jarg2;
35875   if (arg1) (arg1)->displacement = *arg2;
35876 }
35877
35878
35879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
35880   void * jresult ;
35881   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35882   Dali::Vector2 *result = 0 ;
35883
35884   arg1 = (Dali::PanGesture *)jarg1;
35885   result = (Dali::Vector2 *)& ((arg1)->displacement);
35886   jresult = (void *)result;
35887   return jresult;
35888 }
35889
35890
35891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
35892   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35893   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35894
35895   arg1 = (Dali::PanGesture *)jarg1;
35896   arg2 = (Dali::Vector2 *)jarg2;
35897   if (arg1) (arg1)->position = *arg2;
35898 }
35899
35900
35901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
35902   void * jresult ;
35903   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35904   Dali::Vector2 *result = 0 ;
35905
35906   arg1 = (Dali::PanGesture *)jarg1;
35907   result = (Dali::Vector2 *)& ((arg1)->position);
35908   jresult = (void *)result;
35909   return jresult;
35910 }
35911
35912
35913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
35914   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35915   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35916
35917   arg1 = (Dali::PanGesture *)jarg1;
35918   arg2 = (Dali::Vector2 *)jarg2;
35919   if (arg1) (arg1)->screenVelocity = *arg2;
35920 }
35921
35922
35923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
35924   void * jresult ;
35925   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35926   Dali::Vector2 *result = 0 ;
35927
35928   arg1 = (Dali::PanGesture *)jarg1;
35929   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
35930   jresult = (void *)result;
35931   return jresult;
35932 }
35933
35934
35935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
35936   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35937   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35938
35939   arg1 = (Dali::PanGesture *)jarg1;
35940   arg2 = (Dali::Vector2 *)jarg2;
35941   if (arg1) (arg1)->screenDisplacement = *arg2;
35942 }
35943
35944
35945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
35946   void * jresult ;
35947   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35948   Dali::Vector2 *result = 0 ;
35949
35950   arg1 = (Dali::PanGesture *)jarg1;
35951   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
35952   jresult = (void *)result;
35953   return jresult;
35954 }
35955
35956
35957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
35958   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35959   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35960
35961   arg1 = (Dali::PanGesture *)jarg1;
35962   arg2 = (Dali::Vector2 *)jarg2;
35963   if (arg1) (arg1)->screenPosition = *arg2;
35964 }
35965
35966
35967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
35968   void * jresult ;
35969   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35970   Dali::Vector2 *result = 0 ;
35971
35972   arg1 = (Dali::PanGesture *)jarg1;
35973   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
35974   jresult = (void *)result;
35975   return jresult;
35976 }
35977
35978
35979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
35980   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35981   unsigned int arg2 ;
35982
35983   arg1 = (Dali::PanGesture *)jarg1;
35984   arg2 = (unsigned int)jarg2;
35985   if (arg1) (arg1)->numberOfTouches = arg2;
35986 }
35987
35988
35989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
35990   unsigned int jresult ;
35991   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35992   unsigned int result;
35993
35994   arg1 = (Dali::PanGesture *)jarg1;
35995   result = (unsigned int) ((arg1)->numberOfTouches);
35996   jresult = result;
35997   return jresult;
35998 }
35999
36000
36001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36002   float jresult ;
36003   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36004   float result;
36005
36006   arg1 = (Dali::PanGesture *)jarg1;
36007   {
36008     try {
36009       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36010     } catch (std::out_of_range& e) {
36011       {
36012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36013       };
36014     } catch (std::exception& e) {
36015       {
36016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36017       };
36018     } catch (...) {
36019       {
36020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36021       };
36022     }
36023   }
36024   jresult = result;
36025   return jresult;
36026 }
36027
36028
36029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36030   float jresult ;
36031   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36032   float result;
36033
36034   arg1 = (Dali::PanGesture *)jarg1;
36035   {
36036     try {
36037       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36038     } catch (std::out_of_range& e) {
36039       {
36040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36041       };
36042     } catch (std::exception& e) {
36043       {
36044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36045       };
36046     } catch (...) {
36047       {
36048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36049       };
36050     }
36051   }
36052   jresult = result;
36053   return jresult;
36054 }
36055
36056
36057 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36058   float jresult ;
36059   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36060   float result;
36061
36062   arg1 = (Dali::PanGesture *)jarg1;
36063   {
36064     try {
36065       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36066     } catch (std::out_of_range& e) {
36067       {
36068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36069       };
36070     } catch (std::exception& e) {
36071       {
36072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36073       };
36074     } catch (...) {
36075       {
36076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36077       };
36078     }
36079   }
36080   jresult = result;
36081   return jresult;
36082 }
36083
36084
36085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36086   float jresult ;
36087   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36088   float result;
36089
36090   arg1 = (Dali::PanGesture *)jarg1;
36091   {
36092     try {
36093       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36094     } catch (std::out_of_range& e) {
36095       {
36096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36097       };
36098     } catch (std::exception& e) {
36099       {
36100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36101       };
36102     } catch (...) {
36103       {
36104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36105       };
36106     }
36107   }
36108   jresult = result;
36109   return jresult;
36110 }
36111
36112
36113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36114   void * jresult ;
36115   Dali::PinchGestureDetector *result = 0 ;
36116
36117   {
36118     try {
36119       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36120     } catch (std::out_of_range& e) {
36121       {
36122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36123       };
36124     } catch (std::exception& e) {
36125       {
36126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36127       };
36128     } catch (...) {
36129       {
36130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36131       };
36132     }
36133   }
36134   jresult = (void *)result;
36135   return jresult;
36136 }
36137
36138
36139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36140   void * jresult ;
36141   Dali::PinchGestureDetector result;
36142
36143   {
36144     try {
36145       result = Dali::PinchGestureDetector::New();
36146     } catch (std::out_of_range& e) {
36147       {
36148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36149       };
36150     } catch (std::exception& e) {
36151       {
36152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36153       };
36154     } catch (...) {
36155       {
36156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36157       };
36158     }
36159   }
36160   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36161   return jresult;
36162 }
36163
36164
36165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36166   void * jresult ;
36167   Dali::BaseHandle arg1 ;
36168   Dali::BaseHandle *argp1 ;
36169   Dali::PinchGestureDetector result;
36170
36171   argp1 = (Dali::BaseHandle *)jarg1;
36172   if (!argp1) {
36173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36174     return 0;
36175   }
36176   arg1 = *argp1;
36177   {
36178     try {
36179       result = Dali::PinchGestureDetector::DownCast(arg1);
36180     } catch (std::out_of_range& e) {
36181       {
36182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36183       };
36184     } catch (std::exception& e) {
36185       {
36186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36187       };
36188     } catch (...) {
36189       {
36190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36191       };
36192     }
36193   }
36194   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36195   return jresult;
36196 }
36197
36198
36199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36200   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36201
36202   arg1 = (Dali::PinchGestureDetector *)jarg1;
36203   {
36204     try {
36205       delete arg1;
36206     } catch (std::out_of_range& e) {
36207       {
36208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36209       };
36210     } catch (std::exception& e) {
36211       {
36212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36213       };
36214     } catch (...) {
36215       {
36216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36217       };
36218     }
36219   }
36220 }
36221
36222
36223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36224   void * jresult ;
36225   Dali::PinchGestureDetector *arg1 = 0 ;
36226   Dali::PinchGestureDetector *result = 0 ;
36227
36228   arg1 = (Dali::PinchGestureDetector *)jarg1;
36229   if (!arg1) {
36230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36231     return 0;
36232   }
36233   {
36234     try {
36235       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36236     } catch (std::out_of_range& e) {
36237       {
36238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36239       };
36240     } catch (std::exception& e) {
36241       {
36242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36243       };
36244     } catch (...) {
36245       {
36246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36247       };
36248     }
36249   }
36250   jresult = (void *)result;
36251   return jresult;
36252 }
36253
36254
36255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36256   void * jresult ;
36257   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36258   Dali::PinchGestureDetector *arg2 = 0 ;
36259   Dali::PinchGestureDetector *result = 0 ;
36260
36261   arg1 = (Dali::PinchGestureDetector *)jarg1;
36262   arg2 = (Dali::PinchGestureDetector *)jarg2;
36263   if (!arg2) {
36264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36265     return 0;
36266   }
36267   {
36268     try {
36269       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36270     } catch (std::out_of_range& e) {
36271       {
36272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36273       };
36274     } catch (std::exception& e) {
36275       {
36276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36277       };
36278     } catch (...) {
36279       {
36280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36281       };
36282     }
36283   }
36284   jresult = (void *)result;
36285   return jresult;
36286 }
36287
36288
36289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36290   void * jresult ;
36291   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36292   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36293
36294   arg1 = (Dali::PinchGestureDetector *)jarg1;
36295   {
36296     try {
36297       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36298     } catch (std::out_of_range& e) {
36299       {
36300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36301       };
36302     } catch (std::exception& e) {
36303       {
36304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36305       };
36306     } catch (...) {
36307       {
36308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36309       };
36310     }
36311   }
36312   jresult = (void *)result;
36313   return jresult;
36314 }
36315
36316
36317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36318   void * jresult ;
36319   Dali::Gesture::State arg1 ;
36320   Dali::PinchGesture *result = 0 ;
36321
36322   arg1 = (Dali::Gesture::State)jarg1;
36323   {
36324     try {
36325       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36326     } catch (std::out_of_range& e) {
36327       {
36328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36329       };
36330     } catch (std::exception& e) {
36331       {
36332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36333       };
36334     } catch (...) {
36335       {
36336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36337       };
36338     }
36339   }
36340   jresult = (void *)result;
36341   return jresult;
36342 }
36343
36344
36345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36346   void * jresult ;
36347   Dali::PinchGesture *arg1 = 0 ;
36348   Dali::PinchGesture *result = 0 ;
36349
36350   arg1 = (Dali::PinchGesture *)jarg1;
36351   if (!arg1) {
36352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36353     return 0;
36354   }
36355   {
36356     try {
36357       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36358     } catch (std::out_of_range& e) {
36359       {
36360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36361       };
36362     } catch (std::exception& e) {
36363       {
36364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36365       };
36366     } catch (...) {
36367       {
36368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36369       };
36370     }
36371   }
36372   jresult = (void *)result;
36373   return jresult;
36374 }
36375
36376
36377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36378   void * jresult ;
36379   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36380   Dali::PinchGesture *arg2 = 0 ;
36381   Dali::PinchGesture *result = 0 ;
36382
36383   arg1 = (Dali::PinchGesture *)jarg1;
36384   arg2 = (Dali::PinchGesture *)jarg2;
36385   if (!arg2) {
36386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36387     return 0;
36388   }
36389   {
36390     try {
36391       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36392     } catch (std::out_of_range& e) {
36393       {
36394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36395       };
36396     } catch (std::exception& e) {
36397       {
36398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36399       };
36400     } catch (...) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36403       };
36404     }
36405   }
36406   jresult = (void *)result;
36407   return jresult;
36408 }
36409
36410
36411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36412   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36413
36414   arg1 = (Dali::PinchGesture *)jarg1;
36415   {
36416     try {
36417       delete arg1;
36418     } catch (std::out_of_range& e) {
36419       {
36420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36421       };
36422     } catch (std::exception& e) {
36423       {
36424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36425       };
36426     } catch (...) {
36427       {
36428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36429       };
36430     }
36431   }
36432 }
36433
36434
36435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36436   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36437   float arg2 ;
36438
36439   arg1 = (Dali::PinchGesture *)jarg1;
36440   arg2 = (float)jarg2;
36441   if (arg1) (arg1)->scale = arg2;
36442 }
36443
36444
36445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36446   float jresult ;
36447   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36448   float result;
36449
36450   arg1 = (Dali::PinchGesture *)jarg1;
36451   result = (float) ((arg1)->scale);
36452   jresult = result;
36453   return jresult;
36454 }
36455
36456
36457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36458   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36459   float arg2 ;
36460
36461   arg1 = (Dali::PinchGesture *)jarg1;
36462   arg2 = (float)jarg2;
36463   if (arg1) (arg1)->speed = arg2;
36464 }
36465
36466
36467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36468   float jresult ;
36469   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36470   float result;
36471
36472   arg1 = (Dali::PinchGesture *)jarg1;
36473   result = (float) ((arg1)->speed);
36474   jresult = result;
36475   return jresult;
36476 }
36477
36478
36479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36480   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36481   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36482
36483   arg1 = (Dali::PinchGesture *)jarg1;
36484   arg2 = (Dali::Vector2 *)jarg2;
36485   if (arg1) (arg1)->screenCenterPoint = *arg2;
36486 }
36487
36488
36489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36490   void * jresult ;
36491   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36492   Dali::Vector2 *result = 0 ;
36493
36494   arg1 = (Dali::PinchGesture *)jarg1;
36495   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36496   jresult = (void *)result;
36497   return jresult;
36498 }
36499
36500
36501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36502   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36503   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36504
36505   arg1 = (Dali::PinchGesture *)jarg1;
36506   arg2 = (Dali::Vector2 *)jarg2;
36507   if (arg1) (arg1)->localCenterPoint = *arg2;
36508 }
36509
36510
36511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36512   void * jresult ;
36513   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36514   Dali::Vector2 *result = 0 ;
36515
36516   arg1 = (Dali::PinchGesture *)jarg1;
36517   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36518   jresult = (void *)result;
36519   return jresult;
36520 }
36521
36522
36523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36524   void * jresult ;
36525   Dali::TapGestureDetector *result = 0 ;
36526
36527   {
36528     try {
36529       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36530     } catch (std::out_of_range& e) {
36531       {
36532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36533       };
36534     } catch (std::exception& e) {
36535       {
36536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36537       };
36538     } catch (...) {
36539       {
36540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36541       };
36542     }
36543   }
36544   jresult = (void *)result;
36545   return jresult;
36546 }
36547
36548
36549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36550   void * jresult ;
36551   Dali::TapGestureDetector result;
36552
36553   {
36554     try {
36555       result = Dali::TapGestureDetector::New();
36556     } catch (std::out_of_range& e) {
36557       {
36558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36559       };
36560     } catch (std::exception& e) {
36561       {
36562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36563       };
36564     } catch (...) {
36565       {
36566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36567       };
36568     }
36569   }
36570   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36571   return jresult;
36572 }
36573
36574
36575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36576   void * jresult ;
36577   unsigned int arg1 ;
36578   Dali::TapGestureDetector result;
36579
36580   arg1 = (unsigned int)jarg1;
36581   {
36582     try {
36583       result = Dali::TapGestureDetector::New(arg1);
36584     } catch (std::out_of_range& e) {
36585       {
36586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36587       };
36588     } catch (std::exception& e) {
36589       {
36590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36591       };
36592     } catch (...) {
36593       {
36594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36595       };
36596     }
36597   }
36598   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36599   return jresult;
36600 }
36601
36602
36603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36604   void * jresult ;
36605   Dali::BaseHandle arg1 ;
36606   Dali::BaseHandle *argp1 ;
36607   Dali::TapGestureDetector result;
36608
36609   argp1 = (Dali::BaseHandle *)jarg1;
36610   if (!argp1) {
36611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36612     return 0;
36613   }
36614   arg1 = *argp1;
36615   {
36616     try {
36617       result = Dali::TapGestureDetector::DownCast(arg1);
36618     } catch (std::out_of_range& e) {
36619       {
36620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36621       };
36622     } catch (std::exception& e) {
36623       {
36624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36625       };
36626     } catch (...) {
36627       {
36628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36629       };
36630     }
36631   }
36632   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36633   return jresult;
36634 }
36635
36636
36637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36638   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36639
36640   arg1 = (Dali::TapGestureDetector *)jarg1;
36641   {
36642     try {
36643       delete arg1;
36644     } catch (std::out_of_range& e) {
36645       {
36646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36647       };
36648     } catch (std::exception& e) {
36649       {
36650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36651       };
36652     } catch (...) {
36653       {
36654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36655       };
36656     }
36657   }
36658 }
36659
36660
36661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36662   void * jresult ;
36663   Dali::TapGestureDetector *arg1 = 0 ;
36664   Dali::TapGestureDetector *result = 0 ;
36665
36666   arg1 = (Dali::TapGestureDetector *)jarg1;
36667   if (!arg1) {
36668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36669     return 0;
36670   }
36671   {
36672     try {
36673       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36674     } catch (std::out_of_range& e) {
36675       {
36676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36677       };
36678     } catch (std::exception& e) {
36679       {
36680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36681       };
36682     } catch (...) {
36683       {
36684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36685       };
36686     }
36687   }
36688   jresult = (void *)result;
36689   return jresult;
36690 }
36691
36692
36693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36694   void * jresult ;
36695   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36696   Dali::TapGestureDetector *arg2 = 0 ;
36697   Dali::TapGestureDetector *result = 0 ;
36698
36699   arg1 = (Dali::TapGestureDetector *)jarg1;
36700   arg2 = (Dali::TapGestureDetector *)jarg2;
36701   if (!arg2) {
36702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36703     return 0;
36704   }
36705   {
36706     try {
36707       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36708     } catch (std::out_of_range& e) {
36709       {
36710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36711       };
36712     } catch (std::exception& e) {
36713       {
36714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36715       };
36716     } catch (...) {
36717       {
36718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36719       };
36720     }
36721   }
36722   jresult = (void *)result;
36723   return jresult;
36724 }
36725
36726
36727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36728   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36729   unsigned int arg2 ;
36730
36731   arg1 = (Dali::TapGestureDetector *)jarg1;
36732   arg2 = (unsigned int)jarg2;
36733   {
36734     try {
36735       (arg1)->SetMinimumTapsRequired(arg2);
36736     } catch (std::out_of_range& e) {
36737       {
36738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36739       };
36740     } catch (std::exception& e) {
36741       {
36742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36743       };
36744     } catch (...) {
36745       {
36746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36747       };
36748     }
36749   }
36750 }
36751
36752
36753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
36754   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36755   unsigned int arg2 ;
36756
36757   arg1 = (Dali::TapGestureDetector *)jarg1;
36758   arg2 = (unsigned int)jarg2;
36759   {
36760     try {
36761       (arg1)->SetMaximumTapsRequired(arg2);
36762     } catch (std::out_of_range& e) {
36763       {
36764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36765       };
36766     } catch (std::exception& e) {
36767       {
36768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36769       };
36770     } catch (...) {
36771       {
36772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36773       };
36774     }
36775   }
36776 }
36777
36778
36779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
36780   unsigned int jresult ;
36781   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36782   unsigned int result;
36783
36784   arg1 = (Dali::TapGestureDetector *)jarg1;
36785   {
36786     try {
36787       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
36788     } catch (std::out_of_range& e) {
36789       {
36790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36791       };
36792     } catch (std::exception& e) {
36793       {
36794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36795       };
36796     } catch (...) {
36797       {
36798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36799       };
36800     }
36801   }
36802   jresult = result;
36803   return jresult;
36804 }
36805
36806
36807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
36808   unsigned int jresult ;
36809   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36810   unsigned int result;
36811
36812   arg1 = (Dali::TapGestureDetector *)jarg1;
36813   {
36814     try {
36815       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
36816     } catch (std::out_of_range& e) {
36817       {
36818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36819       };
36820     } catch (std::exception& e) {
36821       {
36822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36823       };
36824     } catch (...) {
36825       {
36826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36827       };
36828     }
36829   }
36830   jresult = result;
36831   return jresult;
36832 }
36833
36834
36835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
36836   void * jresult ;
36837   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36838   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
36839
36840   arg1 = (Dali::TapGestureDetector *)jarg1;
36841   {
36842     try {
36843       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36844     } catch (std::out_of_range& e) {
36845       {
36846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36847       };
36848     } catch (std::exception& e) {
36849       {
36850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36851       };
36852     } catch (...) {
36853       {
36854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36855       };
36856     }
36857   }
36858   jresult = (void *)result;
36859   return jresult;
36860 }
36861
36862
36863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
36864   void * jresult ;
36865   Dali::TapGesture *result = 0 ;
36866
36867   {
36868     try {
36869       result = (Dali::TapGesture *)new Dali::TapGesture();
36870     } catch (std::out_of_range& e) {
36871       {
36872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36873       };
36874     } catch (std::exception& e) {
36875       {
36876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36877       };
36878     } catch (...) {
36879       {
36880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36881       };
36882     }
36883   }
36884   jresult = (void *)result;
36885   return jresult;
36886 }
36887
36888
36889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
36890   void * jresult ;
36891   Dali::TapGesture *arg1 = 0 ;
36892   Dali::TapGesture *result = 0 ;
36893
36894   arg1 = (Dali::TapGesture *)jarg1;
36895   if (!arg1) {
36896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
36897     return 0;
36898   }
36899   {
36900     try {
36901       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
36902     } catch (std::out_of_range& e) {
36903       {
36904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36905       };
36906     } catch (std::exception& e) {
36907       {
36908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36909       };
36910     } catch (...) {
36911       {
36912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36913       };
36914     }
36915   }
36916   jresult = (void *)result;
36917   return jresult;
36918 }
36919
36920
36921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
36922   void * jresult ;
36923   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36924   Dali::TapGesture *arg2 = 0 ;
36925   Dali::TapGesture *result = 0 ;
36926
36927   arg1 = (Dali::TapGesture *)jarg1;
36928   arg2 = (Dali::TapGesture *)jarg2;
36929   if (!arg2) {
36930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
36931     return 0;
36932   }
36933   {
36934     try {
36935       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
36936     } catch (std::out_of_range& e) {
36937       {
36938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36939       };
36940     } catch (std::exception& e) {
36941       {
36942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36943       };
36944     } catch (...) {
36945       {
36946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36947       };
36948     }
36949   }
36950   jresult = (void *)result;
36951   return jresult;
36952 }
36953
36954
36955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
36956   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36957
36958   arg1 = (Dali::TapGesture *)jarg1;
36959   {
36960     try {
36961       delete arg1;
36962     } catch (std::out_of_range& e) {
36963       {
36964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36965       };
36966     } catch (std::exception& e) {
36967       {
36968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36969       };
36970     } catch (...) {
36971       {
36972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36973       };
36974     }
36975   }
36976 }
36977
36978
36979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
36980   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36981   unsigned int arg2 ;
36982
36983   arg1 = (Dali::TapGesture *)jarg1;
36984   arg2 = (unsigned int)jarg2;
36985   if (arg1) (arg1)->numberOfTaps = arg2;
36986 }
36987
36988
36989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
36990   unsigned int jresult ;
36991   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
36992   unsigned int result;
36993
36994   arg1 = (Dali::TapGesture *)jarg1;
36995   result = (unsigned int) ((arg1)->numberOfTaps);
36996   jresult = result;
36997   return jresult;
36998 }
36999
37000
37001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37002   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37003   unsigned int arg2 ;
37004
37005   arg1 = (Dali::TapGesture *)jarg1;
37006   arg2 = (unsigned int)jarg2;
37007   if (arg1) (arg1)->numberOfTouches = arg2;
37008 }
37009
37010
37011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37012   unsigned int jresult ;
37013   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37014   unsigned int result;
37015
37016   arg1 = (Dali::TapGesture *)jarg1;
37017   result = (unsigned int) ((arg1)->numberOfTouches);
37018   jresult = result;
37019   return jresult;
37020 }
37021
37022
37023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37024   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37025   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37026
37027   arg1 = (Dali::TapGesture *)jarg1;
37028   arg2 = (Dali::Vector2 *)jarg2;
37029   if (arg1) (arg1)->screenPoint = *arg2;
37030 }
37031
37032
37033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37034   void * jresult ;
37035   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37036   Dali::Vector2 *result = 0 ;
37037
37038   arg1 = (Dali::TapGesture *)jarg1;
37039   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37040   jresult = (void *)result;
37041   return jresult;
37042 }
37043
37044
37045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37046   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37047   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37048
37049   arg1 = (Dali::TapGesture *)jarg1;
37050   arg2 = (Dali::Vector2 *)jarg2;
37051   if (arg1) (arg1)->localPoint = *arg2;
37052 }
37053
37054
37055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37056   void * jresult ;
37057   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37058   Dali::Vector2 *result = 0 ;
37059
37060   arg1 = (Dali::TapGesture *)jarg1;
37061   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37062   jresult = (void *)result;
37063   return jresult;
37064 }
37065
37066
37067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37068   void * jresult ;
37069   Dali::AlphaFunction *result = 0 ;
37070
37071   {
37072     try {
37073       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37074     } catch (std::out_of_range& e) {
37075       {
37076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37077       };
37078     } catch (std::exception& e) {
37079       {
37080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37081       };
37082     } catch (...) {
37083       {
37084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37085       };
37086     }
37087   }
37088   jresult = (void *)result;
37089   return jresult;
37090 }
37091
37092
37093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37094   void * jresult ;
37095   Dali::AlphaFunction::BuiltinFunction arg1 ;
37096   Dali::AlphaFunction *result = 0 ;
37097
37098   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37099   {
37100     try {
37101       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37102     } catch (std::out_of_range& e) {
37103       {
37104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37105       };
37106     } catch (std::exception& e) {
37107       {
37108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37109       };
37110     } catch (...) {
37111       {
37112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37113       };
37114     }
37115   }
37116   jresult = (void *)result;
37117   return jresult;
37118 }
37119
37120
37121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37122   void * jresult ;
37123   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37124   Dali::AlphaFunction *result = 0 ;
37125
37126   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37127   {
37128     try {
37129       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37130     } catch (std::out_of_range& e) {
37131       {
37132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37133       };
37134     } catch (std::exception& e) {
37135       {
37136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37137       };
37138     } catch (...) {
37139       {
37140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37141       };
37142     }
37143   }
37144   jresult = (void *)result;
37145   return jresult;
37146 }
37147
37148
37149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37150   void * jresult ;
37151   Dali::Vector2 *arg1 = 0 ;
37152   Dali::Vector2 *arg2 = 0 ;
37153   Dali::AlphaFunction *result = 0 ;
37154
37155   arg1 = (Dali::Vector2 *)jarg1;
37156   if (!arg1) {
37157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37158     return 0;
37159   }
37160   arg2 = (Dali::Vector2 *)jarg2;
37161   if (!arg2) {
37162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37163     return 0;
37164   }
37165   {
37166     try {
37167       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37168     } catch (std::out_of_range& e) {
37169       {
37170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37171       };
37172     } catch (std::exception& e) {
37173       {
37174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37175       };
37176     } catch (...) {
37177       {
37178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37179       };
37180     }
37181   }
37182   jresult = (void *)result;
37183   return jresult;
37184 }
37185
37186
37187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37188   void * jresult ;
37189   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37190   Dali::Vector4 result;
37191
37192   arg1 = (Dali::AlphaFunction *)jarg1;
37193   {
37194     try {
37195       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37196     } catch (std::out_of_range& e) {
37197       {
37198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37199       };
37200     } catch (std::exception& e) {
37201       {
37202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37203       };
37204     } catch (...) {
37205       {
37206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37207       };
37208     }
37209   }
37210   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37211   return jresult;
37212 }
37213
37214
37215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37216   void * jresult ;
37217   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37218   Dali::AlphaFunctionPrototype result;
37219
37220   arg1 = (Dali::AlphaFunction *)jarg1;
37221   {
37222     try {
37223       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37224     } catch (std::out_of_range& e) {
37225       {
37226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37227       };
37228     } catch (std::exception& e) {
37229       {
37230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37231       };
37232     } catch (...) {
37233       {
37234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37235       };
37236     }
37237   }
37238   jresult = (void *)result;
37239   return jresult;
37240 }
37241
37242
37243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37244   int jresult ;
37245   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37246   Dali::AlphaFunction::BuiltinFunction result;
37247
37248   arg1 = (Dali::AlphaFunction *)jarg1;
37249   {
37250     try {
37251       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37252     } catch (std::out_of_range& e) {
37253       {
37254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37255       };
37256     } catch (std::exception& e) {
37257       {
37258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37259       };
37260     } catch (...) {
37261       {
37262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37263       };
37264     }
37265   }
37266   jresult = (int)result;
37267   return jresult;
37268 }
37269
37270
37271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37272   int jresult ;
37273   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37274   Dali::AlphaFunction::Mode result;
37275
37276   arg1 = (Dali::AlphaFunction *)jarg1;
37277   {
37278     try {
37279       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37280     } catch (std::out_of_range& e) {
37281       {
37282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37283       };
37284     } catch (std::exception& e) {
37285       {
37286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37287       };
37288     } catch (...) {
37289       {
37290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37291       };
37292     }
37293   }
37294   jresult = (int)result;
37295   return jresult;
37296 }
37297
37298
37299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37300   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37301
37302   arg1 = (Dali::AlphaFunction *)jarg1;
37303   {
37304     try {
37305       delete arg1;
37306     } catch (std::out_of_range& e) {
37307       {
37308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37309       };
37310     } catch (std::exception& e) {
37311       {
37312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37313       };
37314     } catch (...) {
37315       {
37316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37317       };
37318     }
37319   }
37320 }
37321
37322
37323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37324   void * jresult ;
37325   Dali::KeyFrames result;
37326
37327   {
37328     try {
37329       result = Dali::KeyFrames::New();
37330     } catch (std::out_of_range& e) {
37331       {
37332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37333       };
37334     } catch (std::exception& e) {
37335       {
37336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37337       };
37338     } catch (...) {
37339       {
37340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37341       };
37342     }
37343   }
37344   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37345   return jresult;
37346 }
37347
37348
37349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37350   void * jresult ;
37351   Dali::BaseHandle arg1 ;
37352   Dali::BaseHandle *argp1 ;
37353   Dali::KeyFrames result;
37354
37355   argp1 = (Dali::BaseHandle *)jarg1;
37356   if (!argp1) {
37357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37358     return 0;
37359   }
37360   arg1 = *argp1;
37361   {
37362     try {
37363       result = Dali::KeyFrames::DownCast(arg1);
37364     } catch (std::out_of_range& e) {
37365       {
37366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37367       };
37368     } catch (std::exception& e) {
37369       {
37370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37371       };
37372     } catch (...) {
37373       {
37374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37375       };
37376     }
37377   }
37378   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37379   return jresult;
37380 }
37381
37382
37383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37384   void * jresult ;
37385   Dali::KeyFrames *result = 0 ;
37386
37387   {
37388     try {
37389       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37390     } catch (std::out_of_range& e) {
37391       {
37392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37393       };
37394     } catch (std::exception& e) {
37395       {
37396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37397       };
37398     } catch (...) {
37399       {
37400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37401       };
37402     }
37403   }
37404   jresult = (void *)result;
37405   return jresult;
37406 }
37407
37408
37409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37410   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37411
37412   arg1 = (Dali::KeyFrames *)jarg1;
37413   {
37414     try {
37415       delete arg1;
37416     } catch (std::out_of_range& e) {
37417       {
37418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37419       };
37420     } catch (std::exception& e) {
37421       {
37422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37423       };
37424     } catch (...) {
37425       {
37426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37427       };
37428     }
37429   }
37430 }
37431
37432
37433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37434   void * jresult ;
37435   Dali::KeyFrames *arg1 = 0 ;
37436   Dali::KeyFrames *result = 0 ;
37437
37438   arg1 = (Dali::KeyFrames *)jarg1;
37439   if (!arg1) {
37440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37441     return 0;
37442   }
37443   {
37444     try {
37445       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37446     } catch (std::out_of_range& e) {
37447       {
37448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37449       };
37450     } catch (std::exception& e) {
37451       {
37452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37453       };
37454     } catch (...) {
37455       {
37456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37457       };
37458     }
37459   }
37460   jresult = (void *)result;
37461   return jresult;
37462 }
37463
37464
37465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37466   void * jresult ;
37467   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37468   Dali::KeyFrames *arg2 = 0 ;
37469   Dali::KeyFrames *result = 0 ;
37470
37471   arg1 = (Dali::KeyFrames *)jarg1;
37472   arg2 = (Dali::KeyFrames *)jarg2;
37473   if (!arg2) {
37474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37475     return 0;
37476   }
37477   {
37478     try {
37479       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37480     } catch (std::out_of_range& e) {
37481       {
37482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37483       };
37484     } catch (std::exception& e) {
37485       {
37486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37487       };
37488     } catch (...) {
37489       {
37490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37491       };
37492     }
37493   }
37494   jresult = (void *)result;
37495   return jresult;
37496 }
37497
37498
37499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37500   int jresult ;
37501   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37502   Dali::Property::Type result;
37503
37504   arg1 = (Dali::KeyFrames *)jarg1;
37505   {
37506     try {
37507       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37508     } catch (std::out_of_range& e) {
37509       {
37510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37511       };
37512     } catch (std::exception& e) {
37513       {
37514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37515       };
37516     } catch (...) {
37517       {
37518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37519       };
37520     }
37521   }
37522   jresult = (int)result;
37523   return jresult;
37524 }
37525
37526
37527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37528   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37529   float arg2 ;
37530   Dali::Property::Value arg3 ;
37531   Dali::Property::Value *argp3 ;
37532
37533   arg1 = (Dali::KeyFrames *)jarg1;
37534   arg2 = (float)jarg2;
37535   argp3 = (Dali::Property::Value *)jarg3;
37536   if (!argp3) {
37537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37538     return ;
37539   }
37540   arg3 = *argp3;
37541   {
37542     try {
37543       (arg1)->Add(arg2,arg3);
37544     } catch (std::out_of_range& e) {
37545       {
37546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37547       };
37548     } catch (std::exception& e) {
37549       {
37550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37551       };
37552     } catch (...) {
37553       {
37554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37555       };
37556     }
37557   }
37558 }
37559
37560
37561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37562   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37563   float arg2 ;
37564   Dali::Property::Value arg3 ;
37565   Dali::AlphaFunction arg4 ;
37566   Dali::Property::Value *argp3 ;
37567   Dali::AlphaFunction *argp4 ;
37568
37569   arg1 = (Dali::KeyFrames *)jarg1;
37570   arg2 = (float)jarg2;
37571   argp3 = (Dali::Property::Value *)jarg3;
37572   if (!argp3) {
37573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37574     return ;
37575   }
37576   arg3 = *argp3;
37577   argp4 = (Dali::AlphaFunction *)jarg4;
37578   if (!argp4) {
37579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37580     return ;
37581   }
37582   arg4 = *argp4;
37583   {
37584     try {
37585       (arg1)->Add(arg2,arg3,arg4);
37586     } catch (std::out_of_range& e) {
37587       {
37588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37589       };
37590     } catch (std::exception& e) {
37591       {
37592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37593       };
37594     } catch (...) {
37595       {
37596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37597       };
37598     }
37599   }
37600 }
37601
37602
37603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37604   int jresult ;
37605   int result;
37606
37607   result = (int)Dali::Path::Property::POINTS;
37608   jresult = (int)result;
37609   return jresult;
37610 }
37611
37612
37613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37614   int jresult ;
37615   int result;
37616
37617   result = (int)Dali::Path::Property::CONTROL_POINTS;
37618   jresult = (int)result;
37619   return jresult;
37620 }
37621
37622
37623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37624   void * jresult ;
37625   Dali::Path::Property *result = 0 ;
37626
37627   {
37628     try {
37629       result = (Dali::Path::Property *)new Dali::Path::Property();
37630     } catch (std::out_of_range& e) {
37631       {
37632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37633       };
37634     } catch (std::exception& e) {
37635       {
37636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37637       };
37638     } catch (...) {
37639       {
37640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37641       };
37642     }
37643   }
37644   jresult = (void *)result;
37645   return jresult;
37646 }
37647
37648
37649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37650   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37651
37652   arg1 = (Dali::Path::Property *)jarg1;
37653   {
37654     try {
37655       delete arg1;
37656     } catch (std::out_of_range& e) {
37657       {
37658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37659       };
37660     } catch (std::exception& e) {
37661       {
37662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37663       };
37664     } catch (...) {
37665       {
37666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37667       };
37668     }
37669   }
37670 }
37671
37672
37673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37674   void * jresult ;
37675   Dali::Path result;
37676
37677   {
37678     try {
37679       result = Dali::Path::New();
37680     } catch (std::out_of_range& e) {
37681       {
37682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37683       };
37684     } catch (std::exception& e) {
37685       {
37686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37687       };
37688     } catch (...) {
37689       {
37690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37691       };
37692     }
37693   }
37694   jresult = new Dali::Path((const Dali::Path &)result);
37695   return jresult;
37696 }
37697
37698
37699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37700   void * jresult ;
37701   Dali::BaseHandle arg1 ;
37702   Dali::BaseHandle *argp1 ;
37703   Dali::Path result;
37704
37705   argp1 = (Dali::BaseHandle *)jarg1;
37706   if (!argp1) {
37707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37708     return 0;
37709   }
37710   arg1 = *argp1;
37711   {
37712     try {
37713       result = Dali::Path::DownCast(arg1);
37714     } catch (std::out_of_range& e) {
37715       {
37716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37717       };
37718     } catch (std::exception& e) {
37719       {
37720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37721       };
37722     } catch (...) {
37723       {
37724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37725       };
37726     }
37727   }
37728   jresult = new Dali::Path((const Dali::Path &)result);
37729   return jresult;
37730 }
37731
37732
37733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37734   void * jresult ;
37735   Dali::Path *result = 0 ;
37736
37737   {
37738     try {
37739       result = (Dali::Path *)new Dali::Path();
37740     } catch (std::out_of_range& e) {
37741       {
37742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37743       };
37744     } catch (std::exception& e) {
37745       {
37746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37747       };
37748     } catch (...) {
37749       {
37750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37751       };
37752     }
37753   }
37754   jresult = (void *)result;
37755   return jresult;
37756 }
37757
37758
37759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
37760   Dali::Path *arg1 = (Dali::Path *) 0 ;
37761
37762   arg1 = (Dali::Path *)jarg1;
37763   {
37764     try {
37765       delete arg1;
37766     } catch (std::out_of_range& e) {
37767       {
37768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37769       };
37770     } catch (std::exception& e) {
37771       {
37772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37773       };
37774     } catch (...) {
37775       {
37776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37777       };
37778     }
37779   }
37780 }
37781
37782
37783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
37784   void * jresult ;
37785   Dali::Path *arg1 = 0 ;
37786   Dali::Path *result = 0 ;
37787
37788   arg1 = (Dali::Path *)jarg1;
37789   if (!arg1) {
37790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37791     return 0;
37792   }
37793   {
37794     try {
37795       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
37796     } catch (std::out_of_range& e) {
37797       {
37798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37799       };
37800     } catch (std::exception& e) {
37801       {
37802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37803       };
37804     } catch (...) {
37805       {
37806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37807       };
37808     }
37809   }
37810   jresult = (void *)result;
37811   return jresult;
37812 }
37813
37814
37815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
37816   void * jresult ;
37817   Dali::Path *arg1 = (Dali::Path *) 0 ;
37818   Dali::Path *arg2 = 0 ;
37819   Dali::Path *result = 0 ;
37820
37821   arg1 = (Dali::Path *)jarg1;
37822   arg2 = (Dali::Path *)jarg2;
37823   if (!arg2) {
37824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37825     return 0;
37826   }
37827   {
37828     try {
37829       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
37830     } catch (std::out_of_range& e) {
37831       {
37832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37833       };
37834     } catch (std::exception& e) {
37835       {
37836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37837       };
37838     } catch (...) {
37839       {
37840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37841       };
37842     }
37843   }
37844   jresult = (void *)result;
37845   return jresult;
37846 }
37847
37848
37849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
37850   Dali::Path *arg1 = (Dali::Path *) 0 ;
37851   Dali::Vector3 *arg2 = 0 ;
37852
37853   arg1 = (Dali::Path *)jarg1;
37854   arg2 = (Dali::Vector3 *)jarg2;
37855   if (!arg2) {
37856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37857     return ;
37858   }
37859   {
37860     try {
37861       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
37862     } catch (std::out_of_range& e) {
37863       {
37864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37865       };
37866     } catch (std::exception& e) {
37867       {
37868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37869       };
37870     } catch (...) {
37871       {
37872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37873       };
37874     }
37875   }
37876 }
37877
37878
37879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
37880   Dali::Path *arg1 = (Dali::Path *) 0 ;
37881   Dali::Vector3 *arg2 = 0 ;
37882
37883   arg1 = (Dali::Path *)jarg1;
37884   arg2 = (Dali::Vector3 *)jarg2;
37885   if (!arg2) {
37886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
37887     return ;
37888   }
37889   {
37890     try {
37891       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
37892     } catch (std::out_of_range& e) {
37893       {
37894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37895       };
37896     } catch (std::exception& e) {
37897       {
37898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37899       };
37900     } catch (...) {
37901       {
37902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37903       };
37904     }
37905   }
37906 }
37907
37908
37909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
37910   Dali::Path *arg1 = (Dali::Path *) 0 ;
37911   float arg2 ;
37912
37913   arg1 = (Dali::Path *)jarg1;
37914   arg2 = (float)jarg2;
37915   {
37916     try {
37917       (arg1)->GenerateControlPoints(arg2);
37918     } catch (std::out_of_range& e) {
37919       {
37920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37921       };
37922     } catch (std::exception& e) {
37923       {
37924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37925       };
37926     } catch (...) {
37927       {
37928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37929       };
37930     }
37931   }
37932 }
37933
37934
37935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37936   Dali::Path *arg1 = (Dali::Path *) 0 ;
37937   float arg2 ;
37938   Dali::Vector3 *arg3 = 0 ;
37939   Dali::Vector3 *arg4 = 0 ;
37940
37941   arg1 = (Dali::Path *)jarg1;
37942   arg2 = (float)jarg2;
37943   arg3 = (Dali::Vector3 *)jarg3;
37944   if (!arg3) {
37945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
37946     return ;
37947   }
37948   arg4 = (Dali::Vector3 *)jarg4;
37949   if (!arg4) {
37950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
37951     return ;
37952   }
37953   {
37954     try {
37955       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
37956     } catch (std::out_of_range& e) {
37957       {
37958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37959       };
37960     } catch (std::exception& e) {
37961       {
37962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37963       };
37964     } catch (...) {
37965       {
37966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37967       };
37968     }
37969   }
37970 }
37971
37972
37973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
37974   void * jresult ;
37975   Dali::Path *arg1 = (Dali::Path *) 0 ;
37976   size_t arg2 ;
37977   Dali::Vector3 *result = 0 ;
37978
37979   arg1 = (Dali::Path *)jarg1;
37980   arg2 = (size_t)jarg2;
37981   {
37982     try {
37983       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
37984     } catch (std::out_of_range& e) {
37985       {
37986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37987       };
37988     } catch (std::exception& e) {
37989       {
37990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37991       };
37992     } catch (...) {
37993       {
37994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37995       };
37996     }
37997   }
37998   jresult = (void *)result;
37999   return jresult;
38000 }
38001
38002
38003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38004   void * jresult ;
38005   Dali::Path *arg1 = (Dali::Path *) 0 ;
38006   size_t arg2 ;
38007   Dali::Vector3 *result = 0 ;
38008
38009   arg1 = (Dali::Path *)jarg1;
38010   arg2 = (size_t)jarg2;
38011   {
38012     try {
38013       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38014     } catch (std::out_of_range& e) {
38015       {
38016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38017       };
38018     } catch (std::exception& e) {
38019       {
38020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38021       };
38022     } catch (...) {
38023       {
38024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38025       };
38026     }
38027   }
38028   jresult = (void *)result;
38029   return jresult;
38030 }
38031
38032
38033 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38034   unsigned long jresult ;
38035   Dali::Path *arg1 = (Dali::Path *) 0 ;
38036   size_t result;
38037
38038   arg1 = (Dali::Path *)jarg1;
38039   {
38040     try {
38041       result = ((Dali::Path const *)arg1)->GetPointCount();
38042     } catch (std::out_of_range& e) {
38043       {
38044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38045       };
38046     } catch (std::exception& e) {
38047       {
38048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38049       };
38050     } catch (...) {
38051       {
38052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38053       };
38054     }
38055   }
38056   jresult = (unsigned long)result;
38057   return jresult;
38058 }
38059
38060
38061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38062   void * jresult ;
38063   float arg1 ;
38064   Dali::TimePeriod *result = 0 ;
38065
38066   arg1 = (float)jarg1;
38067   {
38068     try {
38069       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38070     } catch (std::out_of_range& e) {
38071       {
38072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38073       };
38074     } catch (std::exception& e) {
38075       {
38076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38077       };
38078     } catch (...) {
38079       {
38080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38081       };
38082     }
38083   }
38084   jresult = (void *)result;
38085   return jresult;
38086 }
38087
38088
38089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38090   void * jresult ;
38091   float arg1 ;
38092   float arg2 ;
38093   Dali::TimePeriod *result = 0 ;
38094
38095   arg1 = (float)jarg1;
38096   arg2 = (float)jarg2;
38097   {
38098     try {
38099       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38100     } catch (std::out_of_range& e) {
38101       {
38102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38103       };
38104     } catch (std::exception& e) {
38105       {
38106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38107       };
38108     } catch (...) {
38109       {
38110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38111       };
38112     }
38113   }
38114   jresult = (void *)result;
38115   return jresult;
38116 }
38117
38118
38119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38120   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38121
38122   arg1 = (Dali::TimePeriod *)jarg1;
38123   {
38124     try {
38125       delete arg1;
38126     } catch (std::out_of_range& e) {
38127       {
38128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38129       };
38130     } catch (std::exception& e) {
38131       {
38132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38133       };
38134     } catch (...) {
38135       {
38136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38137       };
38138     }
38139   }
38140 }
38141
38142
38143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38144   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38145   float arg2 ;
38146
38147   arg1 = (Dali::TimePeriod *)jarg1;
38148   arg2 = (float)jarg2;
38149   if (arg1) (arg1)->delaySeconds = arg2;
38150 }
38151
38152
38153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38154   float jresult ;
38155   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38156   float result;
38157
38158   arg1 = (Dali::TimePeriod *)jarg1;
38159   result = (float) ((arg1)->delaySeconds);
38160   jresult = result;
38161   return jresult;
38162 }
38163
38164
38165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38166   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38167   float arg2 ;
38168
38169   arg1 = (Dali::TimePeriod *)jarg1;
38170   arg2 = (float)jarg2;
38171   if (arg1) (arg1)->durationSeconds = arg2;
38172 }
38173
38174
38175 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38176   float jresult ;
38177   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38178   float result;
38179
38180   arg1 = (Dali::TimePeriod *)jarg1;
38181   result = (float) ((arg1)->durationSeconds);
38182   jresult = result;
38183   return jresult;
38184 }
38185
38186
38187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38188   void * jresult ;
38189   Dali::Animation *result = 0 ;
38190
38191   {
38192     try {
38193       result = (Dali::Animation *)new Dali::Animation();
38194     } catch (std::out_of_range& e) {
38195       {
38196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38197       };
38198     } catch (std::exception& e) {
38199       {
38200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38201       };
38202     } catch (...) {
38203       {
38204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38205       };
38206     }
38207   }
38208   jresult = (void *)result;
38209   return jresult;
38210 }
38211
38212
38213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38214   void * jresult ;
38215   float arg1 ;
38216   Dali::Animation result;
38217
38218   arg1 = (float)jarg1;
38219   {
38220     try {
38221       result = Dali::Animation::New(arg1);
38222     } catch (std::out_of_range& e) {
38223       {
38224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38225       };
38226     } catch (std::exception& e) {
38227       {
38228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38229       };
38230     } catch (...) {
38231       {
38232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38233       };
38234     }
38235   }
38236   jresult = new Dali::Animation((const Dali::Animation &)result);
38237   return jresult;
38238 }
38239
38240
38241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38242   void * jresult ;
38243   Dali::BaseHandle arg1 ;
38244   Dali::BaseHandle *argp1 ;
38245   Dali::Animation result;
38246
38247   argp1 = (Dali::BaseHandle *)jarg1;
38248   if (!argp1) {
38249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38250     return 0;
38251   }
38252   arg1 = *argp1;
38253   {
38254     try {
38255       result = Dali::Animation::DownCast(arg1);
38256     } catch (std::out_of_range& e) {
38257       {
38258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38259       };
38260     } catch (std::exception& e) {
38261       {
38262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38263       };
38264     } catch (...) {
38265       {
38266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38267       };
38268     }
38269   }
38270   jresult = new Dali::Animation((const Dali::Animation &)result);
38271   return jresult;
38272 }
38273
38274
38275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38276   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38277
38278   arg1 = (Dali::Animation *)jarg1;
38279   {
38280     try {
38281       delete arg1;
38282     } catch (std::out_of_range& e) {
38283       {
38284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38285       };
38286     } catch (std::exception& e) {
38287       {
38288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38289       };
38290     } catch (...) {
38291       {
38292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38293       };
38294     }
38295   }
38296 }
38297
38298
38299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38300   void * jresult ;
38301   Dali::Animation *arg1 = 0 ;
38302   Dali::Animation *result = 0 ;
38303
38304   arg1 = (Dali::Animation *)jarg1;
38305   if (!arg1) {
38306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38307     return 0;
38308   }
38309   {
38310     try {
38311       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38312     } catch (std::out_of_range& e) {
38313       {
38314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38315       };
38316     } catch (std::exception& e) {
38317       {
38318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38319       };
38320     } catch (...) {
38321       {
38322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38323       };
38324     }
38325   }
38326   jresult = (void *)result;
38327   return jresult;
38328 }
38329
38330
38331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38332   void * jresult ;
38333   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38334   Dali::Animation *arg2 = 0 ;
38335   Dali::Animation *result = 0 ;
38336
38337   arg1 = (Dali::Animation *)jarg1;
38338   arg2 = (Dali::Animation *)jarg2;
38339   if (!arg2) {
38340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38341     return 0;
38342   }
38343   {
38344     try {
38345       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38346     } catch (std::out_of_range& e) {
38347       {
38348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38349       };
38350     } catch (std::exception& e) {
38351       {
38352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38353       };
38354     } catch (...) {
38355       {
38356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38357       };
38358     }
38359   }
38360   jresult = (void *)result;
38361   return jresult;
38362 }
38363
38364
38365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38366   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38367   float arg2 ;
38368
38369   arg1 = (Dali::Animation *)jarg1;
38370   arg2 = (float)jarg2;
38371   {
38372     try {
38373       (arg1)->SetDuration(arg2);
38374     } catch (std::out_of_range& e) {
38375       {
38376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38377       };
38378     } catch (std::exception& e) {
38379       {
38380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38381       };
38382     } catch (...) {
38383       {
38384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38385       };
38386     }
38387   }
38388 }
38389
38390
38391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38392   float jresult ;
38393   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38394   float result;
38395
38396   arg1 = (Dali::Animation *)jarg1;
38397   {
38398     try {
38399       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38400     } catch (std::out_of_range& e) {
38401       {
38402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38403       };
38404     } catch (std::exception& e) {
38405       {
38406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38407       };
38408     } catch (...) {
38409       {
38410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38411       };
38412     }
38413   }
38414   jresult = result;
38415   return jresult;
38416 }
38417
38418
38419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38420   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38421   bool arg2 ;
38422
38423   arg1 = (Dali::Animation *)jarg1;
38424   arg2 = jarg2 ? true : false;
38425   {
38426     try {
38427       (arg1)->SetLooping(arg2);
38428     } catch (std::out_of_range& e) {
38429       {
38430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38431       };
38432     } catch (std::exception& e) {
38433       {
38434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38435       };
38436     } catch (...) {
38437       {
38438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38439       };
38440     }
38441   }
38442 }
38443
38444
38445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38446   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38447   int arg2 ;
38448
38449   arg1 = (Dali::Animation *)jarg1;
38450   arg2 = (int)jarg2;
38451   {
38452     try {
38453       (arg1)->SetLoopCount(arg2);
38454     } catch (std::out_of_range& e) {
38455       {
38456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38457       };
38458     } catch (std::exception& e) {
38459       {
38460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38461       };
38462     } catch (...) {
38463       {
38464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38465       };
38466     }
38467   }
38468 }
38469
38470
38471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38472   int jresult ;
38473   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38474   int result;
38475
38476   arg1 = (Dali::Animation *)jarg1;
38477   {
38478     try {
38479       result = (int)(arg1)->GetLoopCount();
38480     } catch (std::out_of_range& e) {
38481       {
38482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38483       };
38484     } catch (std::exception& e) {
38485       {
38486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38487       };
38488     } catch (...) {
38489       {
38490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38491       };
38492     }
38493   }
38494   jresult = result;
38495   return jresult;
38496 }
38497
38498
38499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38500   int jresult ;
38501   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38502   int result;
38503
38504   arg1 = (Dali::Animation *)jarg1;
38505   {
38506     try {
38507       result = (int)(arg1)->GetCurrentLoop();
38508     } catch (std::out_of_range& e) {
38509       {
38510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38511       };
38512     } catch (std::exception& e) {
38513       {
38514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38515       };
38516     } catch (...) {
38517       {
38518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38519       };
38520     }
38521   }
38522   jresult = result;
38523   return jresult;
38524 }
38525
38526
38527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38528   unsigned int jresult ;
38529   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38530   bool result;
38531
38532   arg1 = (Dali::Animation *)jarg1;
38533   {
38534     try {
38535       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38536     } catch (std::out_of_range& e) {
38537       {
38538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38539       };
38540     } catch (std::exception& e) {
38541       {
38542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38543       };
38544     } catch (...) {
38545       {
38546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38547       };
38548     }
38549   }
38550   jresult = result;
38551   return jresult;
38552 }
38553
38554
38555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38556   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38557   Dali::Animation::EndAction arg2 ;
38558
38559   arg1 = (Dali::Animation *)jarg1;
38560   arg2 = (Dali::Animation::EndAction)jarg2;
38561   {
38562     try {
38563       (arg1)->SetEndAction(arg2);
38564     } catch (std::out_of_range& e) {
38565       {
38566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38567       };
38568     } catch (std::exception& e) {
38569       {
38570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38571       };
38572     } catch (...) {
38573       {
38574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38575       };
38576     }
38577   }
38578 }
38579
38580
38581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38582   int jresult ;
38583   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38584   Dali::Animation::EndAction result;
38585
38586   arg1 = (Dali::Animation *)jarg1;
38587   {
38588     try {
38589       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38590     } catch (std::out_of_range& e) {
38591       {
38592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38593       };
38594     } catch (std::exception& e) {
38595       {
38596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38597       };
38598     } catch (...) {
38599       {
38600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38601       };
38602     }
38603   }
38604   jresult = (int)result;
38605   return jresult;
38606 }
38607
38608
38609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38610   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38611   Dali::Animation::EndAction arg2 ;
38612
38613   arg1 = (Dali::Animation *)jarg1;
38614   arg2 = (Dali::Animation::EndAction)jarg2;
38615   {
38616     try {
38617       (arg1)->SetDisconnectAction(arg2);
38618     } catch (std::out_of_range& e) {
38619       {
38620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38621       };
38622     } catch (std::exception& e) {
38623       {
38624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38625       };
38626     } catch (...) {
38627       {
38628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38629       };
38630     }
38631   }
38632 }
38633
38634
38635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38636   int jresult ;
38637   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38638   Dali::Animation::EndAction result;
38639
38640   arg1 = (Dali::Animation *)jarg1;
38641   {
38642     try {
38643       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38644     } catch (std::out_of_range& e) {
38645       {
38646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38647       };
38648     } catch (std::exception& e) {
38649       {
38650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38651       };
38652     } catch (...) {
38653       {
38654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38655       };
38656     }
38657   }
38658   jresult = (int)result;
38659   return jresult;
38660 }
38661
38662
38663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38664   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38665   Dali::AlphaFunction arg2 ;
38666   Dali::AlphaFunction *argp2 ;
38667
38668   arg1 = (Dali::Animation *)jarg1;
38669   argp2 = (Dali::AlphaFunction *)jarg2;
38670   if (!argp2) {
38671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38672     return ;
38673   }
38674   arg2 = *argp2;
38675   {
38676     try {
38677       (arg1)->SetDefaultAlphaFunction(arg2);
38678     } catch (std::out_of_range& e) {
38679       {
38680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38681       };
38682     } catch (std::exception& e) {
38683       {
38684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38685       };
38686     } catch (...) {
38687       {
38688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38689       };
38690     }
38691   }
38692 }
38693
38694
38695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
38696   void * jresult ;
38697   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38698   Dali::AlphaFunction result;
38699
38700   arg1 = (Dali::Animation *)jarg1;
38701   {
38702     try {
38703       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
38704     } catch (std::out_of_range& e) {
38705       {
38706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38707       };
38708     } catch (std::exception& e) {
38709       {
38710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38711       };
38712     } catch (...) {
38713       {
38714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38715       };
38716     }
38717   }
38718   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
38719   return jresult;
38720 }
38721
38722
38723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
38724   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38725   float arg2 ;
38726
38727   arg1 = (Dali::Animation *)jarg1;
38728   arg2 = (float)jarg2;
38729   {
38730     try {
38731       (arg1)->SetCurrentProgress(arg2);
38732     } catch (std::out_of_range& e) {
38733       {
38734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38735       };
38736     } catch (std::exception& e) {
38737       {
38738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38739       };
38740     } catch (...) {
38741       {
38742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38743       };
38744     }
38745   }
38746 }
38747
38748
38749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
38750   float jresult ;
38751   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38752   float result;
38753
38754   arg1 = (Dali::Animation *)jarg1;
38755   {
38756     try {
38757       result = (float)(arg1)->GetCurrentProgress();
38758     } catch (std::out_of_range& e) {
38759       {
38760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38761       };
38762     } catch (std::exception& e) {
38763       {
38764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38765       };
38766     } catch (...) {
38767       {
38768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38769       };
38770     }
38771   }
38772   jresult = result;
38773   return jresult;
38774 }
38775
38776
38777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
38778   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38779   float arg2 ;
38780
38781   arg1 = (Dali::Animation *)jarg1;
38782   arg2 = (float)jarg2;
38783   {
38784     try {
38785       (arg1)->SetSpeedFactor(arg2);
38786     } catch (std::out_of_range& e) {
38787       {
38788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38789       };
38790     } catch (std::exception& e) {
38791       {
38792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38793       };
38794     } catch (...) {
38795       {
38796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38797       };
38798     }
38799   }
38800 }
38801
38802
38803 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
38804   float jresult ;
38805   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38806   float result;
38807
38808   arg1 = (Dali::Animation *)jarg1;
38809   {
38810     try {
38811       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
38812     } catch (std::out_of_range& e) {
38813       {
38814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38815       };
38816     } catch (std::exception& e) {
38817       {
38818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38819       };
38820     } catch (...) {
38821       {
38822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38823       };
38824     }
38825   }
38826   jresult = result;
38827   return jresult;
38828 }
38829
38830
38831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
38832   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38833   Dali::Vector2 *arg2 = 0 ;
38834
38835   arg1 = (Dali::Animation *)jarg1;
38836   arg2 = (Dali::Vector2 *)jarg2;
38837   if (!arg2) {
38838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38839     return ;
38840   }
38841   {
38842     try {
38843       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
38844     } catch (std::out_of_range& e) {
38845       {
38846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38847       };
38848     } catch (std::exception& e) {
38849       {
38850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38851       };
38852     } catch (...) {
38853       {
38854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38855       };
38856     }
38857   }
38858 }
38859
38860
38861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
38862   void * jresult ;
38863   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38864   Dali::Vector2 result;
38865
38866   arg1 = (Dali::Animation *)jarg1;
38867   {
38868     try {
38869       result = ((Dali::Animation const *)arg1)->GetPlayRange();
38870     } catch (std::out_of_range& e) {
38871       {
38872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38873       };
38874     } catch (std::exception& e) {
38875       {
38876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38877       };
38878     } catch (...) {
38879       {
38880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38881       };
38882     }
38883   }
38884   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38885   return jresult;
38886 }
38887
38888
38889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
38890   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38891
38892   arg1 = (Dali::Animation *)jarg1;
38893   {
38894     try {
38895       (arg1)->Play();
38896     } catch (std::out_of_range& e) {
38897       {
38898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38899       };
38900     } catch (std::exception& e) {
38901       {
38902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38903       };
38904     } catch (...) {
38905       {
38906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38907       };
38908     }
38909   }
38910 }
38911
38912
38913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
38914   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38915   float arg2 ;
38916
38917   arg1 = (Dali::Animation *)jarg1;
38918   arg2 = (float)jarg2;
38919   {
38920     try {
38921       (arg1)->PlayFrom(arg2);
38922     } catch (std::out_of_range& e) {
38923       {
38924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38925       };
38926     } catch (std::exception& e) {
38927       {
38928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38929       };
38930     } catch (...) {
38931       {
38932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38933       };
38934     }
38935   }
38936 }
38937
38938
38939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
38940   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38941
38942   arg1 = (Dali::Animation *)jarg1;
38943   {
38944     try {
38945       (arg1)->Pause();
38946     } catch (std::out_of_range& e) {
38947       {
38948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38949       };
38950     } catch (std::exception& e) {
38951       {
38952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38953       };
38954     } catch (...) {
38955       {
38956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38957       };
38958     }
38959   }
38960 }
38961
38962
38963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
38964   int jresult ;
38965   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38966   Dali::Animation::State result;
38967
38968   arg1 = (Dali::Animation *)jarg1;
38969   {
38970     try {
38971       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
38972     } catch (std::out_of_range& e) {
38973       {
38974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38975       };
38976     } catch (std::exception& e) {
38977       {
38978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38979       };
38980     } catch (...) {
38981       {
38982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38983       };
38984     }
38985   }
38986   jresult = (int)result;
38987   return jresult;
38988 }
38989
38990
38991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
38992   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38993
38994   arg1 = (Dali::Animation *)jarg1;
38995   {
38996     try {
38997       (arg1)->Stop();
38998     } catch (std::out_of_range& e) {
38999       {
39000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39001       };
39002     } catch (std::exception& e) {
39003       {
39004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39005       };
39006     } catch (...) {
39007       {
39008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39009       };
39010     }
39011   }
39012 }
39013
39014
39015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39016   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39017
39018   arg1 = (Dali::Animation *)jarg1;
39019   {
39020     try {
39021       (arg1)->Clear();
39022     } catch (std::out_of_range& e) {
39023       {
39024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39025       };
39026     } catch (std::exception& e) {
39027       {
39028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39029       };
39030     } catch (...) {
39031       {
39032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39033       };
39034     }
39035   }
39036 }
39037
39038
39039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39040   void * jresult ;
39041   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39042   Dali::Animation::AnimationSignalType *result = 0 ;
39043
39044   arg1 = (Dali::Animation *)jarg1;
39045   {
39046     try {
39047       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39048     } catch (std::out_of_range& e) {
39049       {
39050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39051       };
39052     } catch (std::exception& e) {
39053       {
39054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39055       };
39056     } catch (...) {
39057       {
39058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39059       };
39060     }
39061   }
39062   jresult = (void *)result;
39063   return jresult;
39064 }
39065
39066
39067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39068   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39069   SwigValueWrapper< Dali::Property > arg2 ;
39070   Dali::Property::Value arg3 ;
39071   Dali::Property *argp2 ;
39072   Dali::Property::Value *argp3 ;
39073
39074   arg1 = (Dali::Animation *)jarg1;
39075   argp2 = (Dali::Property *)jarg2;
39076   if (!argp2) {
39077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39078     return ;
39079   }
39080   arg2 = *argp2;
39081   argp3 = (Dali::Property::Value *)jarg3;
39082   if (!argp3) {
39083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39084     return ;
39085   }
39086   arg3 = *argp3;
39087   {
39088     try {
39089       (arg1)->AnimateBy(arg2,arg3);
39090     } catch (std::out_of_range& e) {
39091       {
39092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39093       };
39094     } catch (std::exception& e) {
39095       {
39096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39097       };
39098     } catch (...) {
39099       {
39100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39101       };
39102     }
39103   }
39104 }
39105
39106
39107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39108   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39109   SwigValueWrapper< Dali::Property > arg2 ;
39110   Dali::Property::Value arg3 ;
39111   Dali::AlphaFunction arg4 ;
39112   Dali::Property *argp2 ;
39113   Dali::Property::Value *argp3 ;
39114   Dali::AlphaFunction *argp4 ;
39115
39116   arg1 = (Dali::Animation *)jarg1;
39117   argp2 = (Dali::Property *)jarg2;
39118   if (!argp2) {
39119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39120     return ;
39121   }
39122   arg2 = *argp2;
39123   argp3 = (Dali::Property::Value *)jarg3;
39124   if (!argp3) {
39125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39126     return ;
39127   }
39128   arg3 = *argp3;
39129   argp4 = (Dali::AlphaFunction *)jarg4;
39130   if (!argp4) {
39131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39132     return ;
39133   }
39134   arg4 = *argp4;
39135   {
39136     try {
39137       (arg1)->AnimateBy(arg2,arg3,arg4);
39138     } catch (std::out_of_range& e) {
39139       {
39140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39141       };
39142     } catch (std::exception& e) {
39143       {
39144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39145       };
39146     } catch (...) {
39147       {
39148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39149       };
39150     }
39151   }
39152 }
39153
39154
39155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39156   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39157   SwigValueWrapper< Dali::Property > arg2 ;
39158   Dali::Property::Value arg3 ;
39159   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39160   Dali::Property *argp2 ;
39161   Dali::Property::Value *argp3 ;
39162   Dali::TimePeriod *argp4 ;
39163
39164   arg1 = (Dali::Animation *)jarg1;
39165   argp2 = (Dali::Property *)jarg2;
39166   if (!argp2) {
39167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39168     return ;
39169   }
39170   arg2 = *argp2;
39171   argp3 = (Dali::Property::Value *)jarg3;
39172   if (!argp3) {
39173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39174     return ;
39175   }
39176   arg3 = *argp3;
39177   argp4 = (Dali::TimePeriod *)jarg4;
39178   if (!argp4) {
39179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39180     return ;
39181   }
39182   arg4 = *argp4;
39183   {
39184     try {
39185       (arg1)->AnimateBy(arg2,arg3,arg4);
39186     } catch (std::out_of_range& e) {
39187       {
39188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39189       };
39190     } catch (std::exception& e) {
39191       {
39192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39193       };
39194     } catch (...) {
39195       {
39196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39197       };
39198     }
39199   }
39200 }
39201
39202
39203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39204   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39205   SwigValueWrapper< Dali::Property > arg2 ;
39206   Dali::Property::Value arg3 ;
39207   Dali::AlphaFunction arg4 ;
39208   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39209   Dali::Property *argp2 ;
39210   Dali::Property::Value *argp3 ;
39211   Dali::AlphaFunction *argp4 ;
39212   Dali::TimePeriod *argp5 ;
39213
39214   arg1 = (Dali::Animation *)jarg1;
39215   argp2 = (Dali::Property *)jarg2;
39216   if (!argp2) {
39217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39218     return ;
39219   }
39220   arg2 = *argp2;
39221   argp3 = (Dali::Property::Value *)jarg3;
39222   if (!argp3) {
39223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39224     return ;
39225   }
39226   arg3 = *argp3;
39227   argp4 = (Dali::AlphaFunction *)jarg4;
39228   if (!argp4) {
39229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39230     return ;
39231   }
39232   arg4 = *argp4;
39233   argp5 = (Dali::TimePeriod *)jarg5;
39234   if (!argp5) {
39235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39236     return ;
39237   }
39238   arg5 = *argp5;
39239   {
39240     try {
39241       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39242     } catch (std::out_of_range& e) {
39243       {
39244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39245       };
39246     } catch (std::exception& e) {
39247       {
39248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39249       };
39250     } catch (...) {
39251       {
39252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39253       };
39254     }
39255   }
39256 }
39257
39258
39259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39260   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39261   SwigValueWrapper< Dali::Property > arg2 ;
39262   Dali::Property::Value arg3 ;
39263   Dali::Property *argp2 ;
39264   Dali::Property::Value *argp3 ;
39265
39266   arg1 = (Dali::Animation *)jarg1;
39267   argp2 = (Dali::Property *)jarg2;
39268   if (!argp2) {
39269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39270     return ;
39271   }
39272   arg2 = *argp2;
39273   argp3 = (Dali::Property::Value *)jarg3;
39274   if (!argp3) {
39275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39276     return ;
39277   }
39278   arg3 = *argp3;
39279   {
39280     try {
39281       (arg1)->AnimateTo(arg2,arg3);
39282     } catch (std::out_of_range& e) {
39283       {
39284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39285       };
39286     } catch (std::exception& e) {
39287       {
39288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39289       };
39290     } catch (...) {
39291       {
39292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39293       };
39294     }
39295   }
39296 }
39297
39298
39299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39300   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39301   SwigValueWrapper< Dali::Property > arg2 ;
39302   Dali::Property::Value arg3 ;
39303   Dali::AlphaFunction arg4 ;
39304   Dali::Property *argp2 ;
39305   Dali::Property::Value *argp3 ;
39306   Dali::AlphaFunction *argp4 ;
39307
39308   arg1 = (Dali::Animation *)jarg1;
39309   argp2 = (Dali::Property *)jarg2;
39310   if (!argp2) {
39311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39312     return ;
39313   }
39314   arg2 = *argp2;
39315   argp3 = (Dali::Property::Value *)jarg3;
39316   if (!argp3) {
39317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39318     return ;
39319   }
39320   arg3 = *argp3;
39321   argp4 = (Dali::AlphaFunction *)jarg4;
39322   if (!argp4) {
39323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39324     return ;
39325   }
39326   arg4 = *argp4;
39327   {
39328     try {
39329       (arg1)->AnimateTo(arg2,arg3,arg4);
39330     } catch (std::out_of_range& e) {
39331       {
39332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39333       };
39334     } catch (std::exception& e) {
39335       {
39336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39337       };
39338     } catch (...) {
39339       {
39340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39341       };
39342     }
39343   }
39344 }
39345
39346
39347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39348   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39349   SwigValueWrapper< Dali::Property > arg2 ;
39350   Dali::Property::Value arg3 ;
39351   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39352   Dali::Property *argp2 ;
39353   Dali::Property::Value *argp3 ;
39354   Dali::TimePeriod *argp4 ;
39355
39356   arg1 = (Dali::Animation *)jarg1;
39357   argp2 = (Dali::Property *)jarg2;
39358   if (!argp2) {
39359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39360     return ;
39361   }
39362   arg2 = *argp2;
39363   argp3 = (Dali::Property::Value *)jarg3;
39364   if (!argp3) {
39365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39366     return ;
39367   }
39368   arg3 = *argp3;
39369   argp4 = (Dali::TimePeriod *)jarg4;
39370   if (!argp4) {
39371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39372     return ;
39373   }
39374   arg4 = *argp4;
39375   {
39376     try {
39377       (arg1)->AnimateTo(arg2,arg3,arg4);
39378     } catch (std::out_of_range& e) {
39379       {
39380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39381       };
39382     } catch (std::exception& e) {
39383       {
39384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39385       };
39386     } catch (...) {
39387       {
39388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39389       };
39390     }
39391   }
39392 }
39393
39394
39395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39396   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39397   SwigValueWrapper< Dali::Property > arg2 ;
39398   Dali::Property::Value arg3 ;
39399   Dali::AlphaFunction arg4 ;
39400   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39401   Dali::Property *argp2 ;
39402   Dali::Property::Value *argp3 ;
39403   Dali::AlphaFunction *argp4 ;
39404   Dali::TimePeriod *argp5 ;
39405
39406   arg1 = (Dali::Animation *)jarg1;
39407   argp2 = (Dali::Property *)jarg2;
39408   if (!argp2) {
39409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39410     return ;
39411   }
39412   arg2 = *argp2;
39413   argp3 = (Dali::Property::Value *)jarg3;
39414   if (!argp3) {
39415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39416     return ;
39417   }
39418   arg3 = *argp3;
39419   argp4 = (Dali::AlphaFunction *)jarg4;
39420   if (!argp4) {
39421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39422     return ;
39423   }
39424   arg4 = *argp4;
39425   argp5 = (Dali::TimePeriod *)jarg5;
39426   if (!argp5) {
39427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39428     return ;
39429   }
39430   arg5 = *argp5;
39431   {
39432     try {
39433       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39434     } catch (std::out_of_range& e) {
39435       {
39436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39437       };
39438     } catch (std::exception& e) {
39439       {
39440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39441       };
39442     } catch (...) {
39443       {
39444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39445       };
39446     }
39447   }
39448 }
39449
39450
39451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39452   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39453   SwigValueWrapper< Dali::Property > arg2 ;
39454   Dali::KeyFrames *arg3 = 0 ;
39455   Dali::Property *argp2 ;
39456
39457   arg1 = (Dali::Animation *)jarg1;
39458   argp2 = (Dali::Property *)jarg2;
39459   if (!argp2) {
39460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39461     return ;
39462   }
39463   arg2 = *argp2;
39464   arg3 = (Dali::KeyFrames *)jarg3;
39465   if (!arg3) {
39466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39467     return ;
39468   }
39469   {
39470     try {
39471       (arg1)->AnimateBetween(arg2,*arg3);
39472     } catch (std::out_of_range& e) {
39473       {
39474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39475       };
39476     } catch (std::exception& e) {
39477       {
39478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39479       };
39480     } catch (...) {
39481       {
39482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39483       };
39484     }
39485   }
39486 }
39487
39488
39489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39490   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39491   SwigValueWrapper< Dali::Property > arg2 ;
39492   Dali::KeyFrames *arg3 = 0 ;
39493   Dali::Animation::Interpolation arg4 ;
39494   Dali::Property *argp2 ;
39495
39496   arg1 = (Dali::Animation *)jarg1;
39497   argp2 = (Dali::Property *)jarg2;
39498   if (!argp2) {
39499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39500     return ;
39501   }
39502   arg2 = *argp2;
39503   arg3 = (Dali::KeyFrames *)jarg3;
39504   if (!arg3) {
39505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39506     return ;
39507   }
39508   arg4 = (Dali::Animation::Interpolation)jarg4;
39509   {
39510     try {
39511       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39512     } catch (std::out_of_range& e) {
39513       {
39514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39515       };
39516     } catch (std::exception& e) {
39517       {
39518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39519       };
39520     } catch (...) {
39521       {
39522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39523       };
39524     }
39525   }
39526 }
39527
39528
39529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39530   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39531   SwigValueWrapper< Dali::Property > arg2 ;
39532   Dali::KeyFrames *arg3 = 0 ;
39533   Dali::AlphaFunction arg4 ;
39534   Dali::Property *argp2 ;
39535   Dali::AlphaFunction *argp4 ;
39536
39537   arg1 = (Dali::Animation *)jarg1;
39538   argp2 = (Dali::Property *)jarg2;
39539   if (!argp2) {
39540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39541     return ;
39542   }
39543   arg2 = *argp2;
39544   arg3 = (Dali::KeyFrames *)jarg3;
39545   if (!arg3) {
39546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39547     return ;
39548   }
39549   argp4 = (Dali::AlphaFunction *)jarg4;
39550   if (!argp4) {
39551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39552     return ;
39553   }
39554   arg4 = *argp4;
39555   {
39556     try {
39557       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39558     } catch (std::out_of_range& e) {
39559       {
39560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39561       };
39562     } catch (std::exception& e) {
39563       {
39564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39565       };
39566     } catch (...) {
39567       {
39568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39569       };
39570     }
39571   }
39572 }
39573
39574
39575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39576   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39577   SwigValueWrapper< Dali::Property > arg2 ;
39578   Dali::KeyFrames *arg3 = 0 ;
39579   Dali::AlphaFunction arg4 ;
39580   Dali::Animation::Interpolation arg5 ;
39581   Dali::Property *argp2 ;
39582   Dali::AlphaFunction *argp4 ;
39583
39584   arg1 = (Dali::Animation *)jarg1;
39585   argp2 = (Dali::Property *)jarg2;
39586   if (!argp2) {
39587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39588     return ;
39589   }
39590   arg2 = *argp2;
39591   arg3 = (Dali::KeyFrames *)jarg3;
39592   if (!arg3) {
39593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39594     return ;
39595   }
39596   argp4 = (Dali::AlphaFunction *)jarg4;
39597   if (!argp4) {
39598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39599     return ;
39600   }
39601   arg4 = *argp4;
39602   arg5 = (Dali::Animation::Interpolation)jarg5;
39603   {
39604     try {
39605       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39606     } catch (std::out_of_range& e) {
39607       {
39608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39609       };
39610     } catch (std::exception& e) {
39611       {
39612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39613       };
39614     } catch (...) {
39615       {
39616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39617       };
39618     }
39619   }
39620 }
39621
39622
39623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39624   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39625   SwigValueWrapper< Dali::Property > arg2 ;
39626   Dali::KeyFrames *arg3 = 0 ;
39627   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39628   Dali::Property *argp2 ;
39629   Dali::TimePeriod *argp4 ;
39630
39631   arg1 = (Dali::Animation *)jarg1;
39632   argp2 = (Dali::Property *)jarg2;
39633   if (!argp2) {
39634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39635     return ;
39636   }
39637   arg2 = *argp2;
39638   arg3 = (Dali::KeyFrames *)jarg3;
39639   if (!arg3) {
39640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39641     return ;
39642   }
39643   argp4 = (Dali::TimePeriod *)jarg4;
39644   if (!argp4) {
39645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39646     return ;
39647   }
39648   arg4 = *argp4;
39649   {
39650     try {
39651       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39652     } catch (std::out_of_range& e) {
39653       {
39654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39655       };
39656     } catch (std::exception& e) {
39657       {
39658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39659       };
39660     } catch (...) {
39661       {
39662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39663       };
39664     }
39665   }
39666 }
39667
39668
39669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39670   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39671   SwigValueWrapper< Dali::Property > arg2 ;
39672   Dali::KeyFrames *arg3 = 0 ;
39673   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39674   Dali::Animation::Interpolation arg5 ;
39675   Dali::Property *argp2 ;
39676   Dali::TimePeriod *argp4 ;
39677
39678   arg1 = (Dali::Animation *)jarg1;
39679   argp2 = (Dali::Property *)jarg2;
39680   if (!argp2) {
39681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39682     return ;
39683   }
39684   arg2 = *argp2;
39685   arg3 = (Dali::KeyFrames *)jarg3;
39686   if (!arg3) {
39687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39688     return ;
39689   }
39690   argp4 = (Dali::TimePeriod *)jarg4;
39691   if (!argp4) {
39692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39693     return ;
39694   }
39695   arg4 = *argp4;
39696   arg5 = (Dali::Animation::Interpolation)jarg5;
39697   {
39698     try {
39699       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39700     } catch (std::out_of_range& e) {
39701       {
39702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39703       };
39704     } catch (std::exception& e) {
39705       {
39706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39707       };
39708     } catch (...) {
39709       {
39710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39711       };
39712     }
39713   }
39714 }
39715
39716
39717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39718   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39719   SwigValueWrapper< Dali::Property > arg2 ;
39720   Dali::KeyFrames *arg3 = 0 ;
39721   Dali::AlphaFunction arg4 ;
39722   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39723   Dali::Property *argp2 ;
39724   Dali::AlphaFunction *argp4 ;
39725   Dali::TimePeriod *argp5 ;
39726
39727   arg1 = (Dali::Animation *)jarg1;
39728   argp2 = (Dali::Property *)jarg2;
39729   if (!argp2) {
39730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39731     return ;
39732   }
39733   arg2 = *argp2;
39734   arg3 = (Dali::KeyFrames *)jarg3;
39735   if (!arg3) {
39736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39737     return ;
39738   }
39739   argp4 = (Dali::AlphaFunction *)jarg4;
39740   if (!argp4) {
39741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39742     return ;
39743   }
39744   arg4 = *argp4;
39745   argp5 = (Dali::TimePeriod *)jarg5;
39746   if (!argp5) {
39747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39748     return ;
39749   }
39750   arg5 = *argp5;
39751   {
39752     try {
39753       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39754     } catch (std::out_of_range& e) {
39755       {
39756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39757       };
39758     } catch (std::exception& e) {
39759       {
39760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39761       };
39762     } catch (...) {
39763       {
39764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39765       };
39766     }
39767   }
39768 }
39769
39770
39771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
39772   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39773   SwigValueWrapper< Dali::Property > arg2 ;
39774   Dali::KeyFrames *arg3 = 0 ;
39775   Dali::AlphaFunction arg4 ;
39776   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39777   Dali::Animation::Interpolation arg6 ;
39778   Dali::Property *argp2 ;
39779   Dali::AlphaFunction *argp4 ;
39780   Dali::TimePeriod *argp5 ;
39781
39782   arg1 = (Dali::Animation *)jarg1;
39783   argp2 = (Dali::Property *)jarg2;
39784   if (!argp2) {
39785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39786     return ;
39787   }
39788   arg2 = *argp2;
39789   arg3 = (Dali::KeyFrames *)jarg3;
39790   if (!arg3) {
39791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39792     return ;
39793   }
39794   argp4 = (Dali::AlphaFunction *)jarg4;
39795   if (!argp4) {
39796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39797     return ;
39798   }
39799   arg4 = *argp4;
39800   argp5 = (Dali::TimePeriod *)jarg5;
39801   if (!argp5) {
39802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39803     return ;
39804   }
39805   arg5 = *argp5;
39806   arg6 = (Dali::Animation::Interpolation)jarg6;
39807   {
39808     try {
39809       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
39810     } catch (std::out_of_range& e) {
39811       {
39812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39813       };
39814     } catch (std::exception& e) {
39815       {
39816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39817       };
39818     } catch (...) {
39819       {
39820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39821       };
39822     }
39823   }
39824 }
39825
39826
39827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39828   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39829   Dali::Actor arg2 ;
39830   Dali::Path arg3 ;
39831   Dali::Vector3 *arg4 = 0 ;
39832   Dali::Actor *argp2 ;
39833   Dali::Path *argp3 ;
39834
39835   arg1 = (Dali::Animation *)jarg1;
39836   argp2 = (Dali::Actor *)jarg2;
39837   if (!argp2) {
39838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39839     return ;
39840   }
39841   arg2 = *argp2;
39842   argp3 = (Dali::Path *)jarg3;
39843   if (!argp3) {
39844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39845     return ;
39846   }
39847   arg3 = *argp3;
39848   arg4 = (Dali::Vector3 *)jarg4;
39849   if (!arg4) {
39850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39851     return ;
39852   }
39853   {
39854     try {
39855       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
39856     } catch (std::out_of_range& e) {
39857       {
39858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39859       };
39860     } catch (std::exception& e) {
39861       {
39862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39863       };
39864     } catch (...) {
39865       {
39866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39867       };
39868     }
39869   }
39870 }
39871
39872
39873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39874   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39875   Dali::Actor arg2 ;
39876   Dali::Path arg3 ;
39877   Dali::Vector3 *arg4 = 0 ;
39878   Dali::AlphaFunction arg5 ;
39879   Dali::Actor *argp2 ;
39880   Dali::Path *argp3 ;
39881   Dali::AlphaFunction *argp5 ;
39882
39883   arg1 = (Dali::Animation *)jarg1;
39884   argp2 = (Dali::Actor *)jarg2;
39885   if (!argp2) {
39886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39887     return ;
39888   }
39889   arg2 = *argp2;
39890   argp3 = (Dali::Path *)jarg3;
39891   if (!argp3) {
39892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39893     return ;
39894   }
39895   arg3 = *argp3;
39896   arg4 = (Dali::Vector3 *)jarg4;
39897   if (!arg4) {
39898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39899     return ;
39900   }
39901   argp5 = (Dali::AlphaFunction *)jarg5;
39902   if (!argp5) {
39903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39904     return ;
39905   }
39906   arg5 = *argp5;
39907   {
39908     try {
39909       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
39910     } catch (std::out_of_range& e) {
39911       {
39912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39913       };
39914     } catch (std::exception& e) {
39915       {
39916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39917       };
39918     } catch (...) {
39919       {
39920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39921       };
39922     }
39923   }
39924 }
39925
39926
39927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39928   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39929   Dali::Actor arg2 ;
39930   Dali::Path arg3 ;
39931   Dali::Vector3 *arg4 = 0 ;
39932   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39933   Dali::Actor *argp2 ;
39934   Dali::Path *argp3 ;
39935   Dali::TimePeriod *argp5 ;
39936
39937   arg1 = (Dali::Animation *)jarg1;
39938   argp2 = (Dali::Actor *)jarg2;
39939   if (!argp2) {
39940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39941     return ;
39942   }
39943   arg2 = *argp2;
39944   argp3 = (Dali::Path *)jarg3;
39945   if (!argp3) {
39946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39947     return ;
39948   }
39949   arg3 = *argp3;
39950   arg4 = (Dali::Vector3 *)jarg4;
39951   if (!arg4) {
39952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39953     return ;
39954   }
39955   argp5 = (Dali::TimePeriod *)jarg5;
39956   if (!argp5) {
39957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39958     return ;
39959   }
39960   arg5 = *argp5;
39961   {
39962     try {
39963       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
39964     } catch (std::out_of_range& e) {
39965       {
39966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39967       };
39968     } catch (std::exception& e) {
39969       {
39970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39971       };
39972     } catch (...) {
39973       {
39974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39975       };
39976     }
39977   }
39978 }
39979
39980
39981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
39982   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39983   Dali::Actor arg2 ;
39984   Dali::Path arg3 ;
39985   Dali::Vector3 *arg4 = 0 ;
39986   Dali::AlphaFunction arg5 ;
39987   SwigValueWrapper< Dali::TimePeriod > arg6 ;
39988   Dali::Actor *argp2 ;
39989   Dali::Path *argp3 ;
39990   Dali::AlphaFunction *argp5 ;
39991   Dali::TimePeriod *argp6 ;
39992
39993   arg1 = (Dali::Animation *)jarg1;
39994   argp2 = (Dali::Actor *)jarg2;
39995   if (!argp2) {
39996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39997     return ;
39998   }
39999   arg2 = *argp2;
40000   argp3 = (Dali::Path *)jarg3;
40001   if (!argp3) {
40002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40003     return ;
40004   }
40005   arg3 = *argp3;
40006   arg4 = (Dali::Vector3 *)jarg4;
40007   if (!arg4) {
40008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40009     return ;
40010   }
40011   argp5 = (Dali::AlphaFunction *)jarg5;
40012   if (!argp5) {
40013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40014     return ;
40015   }
40016   arg5 = *argp5;
40017   argp6 = (Dali::TimePeriod *)jarg6;
40018   if (!argp6) {
40019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40020     return ;
40021   }
40022   arg6 = *argp6;
40023   {
40024     try {
40025       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40026     } catch (std::out_of_range& e) {
40027       {
40028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40029       };
40030     } catch (std::exception& e) {
40031       {
40032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40033       };
40034     } catch (...) {
40035       {
40036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40037       };
40038     }
40039   }
40040 }
40041
40042
40043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40044   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40045   Dali::Actor arg2 ;
40046   float arg3 ;
40047   Dali::Actor *argp2 ;
40048
40049   arg1 = (Dali::Animation *)jarg1;
40050   argp2 = (Dali::Actor *)jarg2;
40051   if (!argp2) {
40052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40053     return ;
40054   }
40055   arg2 = *argp2;
40056   arg3 = (float)jarg3;
40057   {
40058     try {
40059       (arg1)->Show(arg2,arg3);
40060     } catch (std::out_of_range& e) {
40061       {
40062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40063       };
40064     } catch (std::exception& e) {
40065       {
40066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40067       };
40068     } catch (...) {
40069       {
40070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40071       };
40072     }
40073   }
40074 }
40075
40076
40077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40078   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40079   Dali::Actor arg2 ;
40080   float arg3 ;
40081   Dali::Actor *argp2 ;
40082
40083   arg1 = (Dali::Animation *)jarg1;
40084   argp2 = (Dali::Actor *)jarg2;
40085   if (!argp2) {
40086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40087     return ;
40088   }
40089   arg2 = *argp2;
40090   arg3 = (float)jarg3;
40091   {
40092     try {
40093       (arg1)->Hide(arg2,arg3);
40094     } catch (std::out_of_range& e) {
40095       {
40096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40097       };
40098     } catch (std::exception& e) {
40099       {
40100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40101       };
40102     } catch (...) {
40103       {
40104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40105       };
40106     }
40107   }
40108 }
40109
40110
40111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40112   int jresult ;
40113   int result;
40114
40115   result = (int)Dali::LinearConstrainer::Property::VALUE;
40116   jresult = (int)result;
40117   return jresult;
40118 }
40119
40120
40121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40122   int jresult ;
40123   int result;
40124
40125   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40126   jresult = (int)result;
40127   return jresult;
40128 }
40129
40130
40131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40132   void * jresult ;
40133   Dali::LinearConstrainer::Property *result = 0 ;
40134
40135   {
40136     try {
40137       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40138     } catch (std::out_of_range& e) {
40139       {
40140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40141       };
40142     } catch (std::exception& e) {
40143       {
40144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40145       };
40146     } catch (...) {
40147       {
40148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40149       };
40150     }
40151   }
40152   jresult = (void *)result;
40153   return jresult;
40154 }
40155
40156
40157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40158   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40159
40160   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40161   {
40162     try {
40163       delete arg1;
40164     } catch (std::out_of_range& e) {
40165       {
40166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40167       };
40168     } catch (std::exception& e) {
40169       {
40170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40171       };
40172     } catch (...) {
40173       {
40174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40175       };
40176     }
40177   }
40178 }
40179
40180
40181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40182   void * jresult ;
40183   Dali::LinearConstrainer result;
40184
40185   {
40186     try {
40187       result = Dali::LinearConstrainer::New();
40188     } catch (std::out_of_range& e) {
40189       {
40190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40191       };
40192     } catch (std::exception& e) {
40193       {
40194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40195       };
40196     } catch (...) {
40197       {
40198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40199       };
40200     }
40201   }
40202   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40203   return jresult;
40204 }
40205
40206
40207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40208   void * jresult ;
40209   Dali::BaseHandle arg1 ;
40210   Dali::BaseHandle *argp1 ;
40211   Dali::LinearConstrainer result;
40212
40213   argp1 = (Dali::BaseHandle *)jarg1;
40214   if (!argp1) {
40215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40216     return 0;
40217   }
40218   arg1 = *argp1;
40219   {
40220     try {
40221       result = Dali::LinearConstrainer::DownCast(arg1);
40222     } catch (std::out_of_range& e) {
40223       {
40224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40225       };
40226     } catch (std::exception& e) {
40227       {
40228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40229       };
40230     } catch (...) {
40231       {
40232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40233       };
40234     }
40235   }
40236   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40237   return jresult;
40238 }
40239
40240
40241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40242   void * jresult ;
40243   Dali::LinearConstrainer *result = 0 ;
40244
40245   {
40246     try {
40247       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40248     } catch (std::out_of_range& e) {
40249       {
40250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40251       };
40252     } catch (std::exception& e) {
40253       {
40254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40255       };
40256     } catch (...) {
40257       {
40258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40259       };
40260     }
40261   }
40262   jresult = (void *)result;
40263   return jresult;
40264 }
40265
40266
40267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40268   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40269
40270   arg1 = (Dali::LinearConstrainer *)jarg1;
40271   {
40272     try {
40273       delete arg1;
40274     } catch (std::out_of_range& e) {
40275       {
40276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40277       };
40278     } catch (std::exception& e) {
40279       {
40280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40281       };
40282     } catch (...) {
40283       {
40284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40285       };
40286     }
40287   }
40288 }
40289
40290
40291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40292   void * jresult ;
40293   Dali::LinearConstrainer *arg1 = 0 ;
40294   Dali::LinearConstrainer *result = 0 ;
40295
40296   arg1 = (Dali::LinearConstrainer *)jarg1;
40297   if (!arg1) {
40298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40299     return 0;
40300   }
40301   {
40302     try {
40303       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40304     } catch (std::out_of_range& e) {
40305       {
40306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40307       };
40308     } catch (std::exception& e) {
40309       {
40310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40311       };
40312     } catch (...) {
40313       {
40314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40315       };
40316     }
40317   }
40318   jresult = (void *)result;
40319   return jresult;
40320 }
40321
40322
40323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40324   void * jresult ;
40325   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40326   Dali::LinearConstrainer *arg2 = 0 ;
40327   Dali::LinearConstrainer *result = 0 ;
40328
40329   arg1 = (Dali::LinearConstrainer *)jarg1;
40330   arg2 = (Dali::LinearConstrainer *)jarg2;
40331   if (!arg2) {
40332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40333     return 0;
40334   }
40335   {
40336     try {
40337       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40338     } catch (std::out_of_range& e) {
40339       {
40340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40341       };
40342     } catch (std::exception& e) {
40343       {
40344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40345       };
40346     } catch (...) {
40347       {
40348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40349       };
40350     }
40351   }
40352   jresult = (void *)result;
40353   return jresult;
40354 }
40355
40356
40357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40358   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40359   SwigValueWrapper< Dali::Property > arg2 ;
40360   SwigValueWrapper< Dali::Property > arg3 ;
40361   Dali::Vector2 *arg4 = 0 ;
40362   Dali::Vector2 *arg5 = 0 ;
40363   Dali::Property *argp2 ;
40364   Dali::Property *argp3 ;
40365
40366   arg1 = (Dali::LinearConstrainer *)jarg1;
40367   argp2 = (Dali::Property *)jarg2;
40368   if (!argp2) {
40369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40370     return ;
40371   }
40372   arg2 = *argp2;
40373   argp3 = (Dali::Property *)jarg3;
40374   if (!argp3) {
40375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40376     return ;
40377   }
40378   arg3 = *argp3;
40379   arg4 = (Dali::Vector2 *)jarg4;
40380   if (!arg4) {
40381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40382     return ;
40383   }
40384   arg5 = (Dali::Vector2 *)jarg5;
40385   if (!arg5) {
40386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40387     return ;
40388   }
40389   {
40390     try {
40391       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40392     } catch (std::out_of_range& e) {
40393       {
40394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40395       };
40396     } catch (std::exception& e) {
40397       {
40398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40399       };
40400     } catch (...) {
40401       {
40402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40403       };
40404     }
40405   }
40406 }
40407
40408
40409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40410   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40411   SwigValueWrapper< Dali::Property > arg2 ;
40412   SwigValueWrapper< Dali::Property > arg3 ;
40413   Dali::Vector2 *arg4 = 0 ;
40414   Dali::Property *argp2 ;
40415   Dali::Property *argp3 ;
40416
40417   arg1 = (Dali::LinearConstrainer *)jarg1;
40418   argp2 = (Dali::Property *)jarg2;
40419   if (!argp2) {
40420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40421     return ;
40422   }
40423   arg2 = *argp2;
40424   argp3 = (Dali::Property *)jarg3;
40425   if (!argp3) {
40426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40427     return ;
40428   }
40429   arg3 = *argp3;
40430   arg4 = (Dali::Vector2 *)jarg4;
40431   if (!arg4) {
40432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40433     return ;
40434   }
40435   {
40436     try {
40437       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40438     } catch (std::out_of_range& e) {
40439       {
40440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40441       };
40442     } catch (std::exception& e) {
40443       {
40444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40445       };
40446     } catch (...) {
40447       {
40448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40449       };
40450     }
40451   }
40452 }
40453
40454
40455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40456   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40457   Dali::Handle *arg2 = 0 ;
40458
40459   arg1 = (Dali::LinearConstrainer *)jarg1;
40460   arg2 = (Dali::Handle *)jarg2;
40461   if (!arg2) {
40462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40463     return ;
40464   }
40465   {
40466     try {
40467       (arg1)->Remove(*arg2);
40468     } catch (std::out_of_range& e) {
40469       {
40470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40471       };
40472     } catch (std::exception& e) {
40473       {
40474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40475       };
40476     } catch (...) {
40477       {
40478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40479       };
40480     }
40481   }
40482 }
40483
40484
40485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40486   int jresult ;
40487   int result;
40488
40489   result = (int)Dali::PathConstrainer::Property::FORWARD;
40490   jresult = (int)result;
40491   return jresult;
40492 }
40493
40494
40495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40496   int jresult ;
40497   int result;
40498
40499   result = (int)Dali::PathConstrainer::Property::POINTS;
40500   jresult = (int)result;
40501   return jresult;
40502 }
40503
40504
40505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40506   int jresult ;
40507   int result;
40508
40509   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40510   jresult = (int)result;
40511   return jresult;
40512 }
40513
40514
40515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40516   void * jresult ;
40517   Dali::PathConstrainer::Property *result = 0 ;
40518
40519   {
40520     try {
40521       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40522     } catch (std::out_of_range& e) {
40523       {
40524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40525       };
40526     } catch (std::exception& e) {
40527       {
40528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40529       };
40530     } catch (...) {
40531       {
40532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40533       };
40534     }
40535   }
40536   jresult = (void *)result;
40537   return jresult;
40538 }
40539
40540
40541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40542   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40543
40544   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40545   {
40546     try {
40547       delete arg1;
40548     } catch (std::out_of_range& e) {
40549       {
40550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40551       };
40552     } catch (std::exception& e) {
40553       {
40554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40555       };
40556     } catch (...) {
40557       {
40558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40559       };
40560     }
40561   }
40562 }
40563
40564
40565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40566   void * jresult ;
40567   Dali::PathConstrainer result;
40568
40569   {
40570     try {
40571       result = Dali::PathConstrainer::New();
40572     } catch (std::out_of_range& e) {
40573       {
40574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40575       };
40576     } catch (std::exception& e) {
40577       {
40578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40579       };
40580     } catch (...) {
40581       {
40582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40583       };
40584     }
40585   }
40586   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40587   return jresult;
40588 }
40589
40590
40591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40592   void * jresult ;
40593   Dali::BaseHandle arg1 ;
40594   Dali::BaseHandle *argp1 ;
40595   Dali::PathConstrainer result;
40596
40597   argp1 = (Dali::BaseHandle *)jarg1;
40598   if (!argp1) {
40599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40600     return 0;
40601   }
40602   arg1 = *argp1;
40603   {
40604     try {
40605       result = Dali::PathConstrainer::DownCast(arg1);
40606     } catch (std::out_of_range& e) {
40607       {
40608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40609       };
40610     } catch (std::exception& e) {
40611       {
40612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40613       };
40614     } catch (...) {
40615       {
40616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40617       };
40618     }
40619   }
40620   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40621   return jresult;
40622 }
40623
40624
40625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40626   void * jresult ;
40627   Dali::PathConstrainer *result = 0 ;
40628
40629   {
40630     try {
40631       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40632     } catch (std::out_of_range& e) {
40633       {
40634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40635       };
40636     } catch (std::exception& e) {
40637       {
40638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40639       };
40640     } catch (...) {
40641       {
40642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40643       };
40644     }
40645   }
40646   jresult = (void *)result;
40647   return jresult;
40648 }
40649
40650
40651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40652   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40653
40654   arg1 = (Dali::PathConstrainer *)jarg1;
40655   {
40656     try {
40657       delete arg1;
40658     } catch (std::out_of_range& e) {
40659       {
40660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40661       };
40662     } catch (std::exception& e) {
40663       {
40664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40665       };
40666     } catch (...) {
40667       {
40668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40669       };
40670     }
40671   }
40672 }
40673
40674
40675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
40676   void * jresult ;
40677   Dali::PathConstrainer *arg1 = 0 ;
40678   Dali::PathConstrainer *result = 0 ;
40679
40680   arg1 = (Dali::PathConstrainer *)jarg1;
40681   if (!arg1) {
40682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40683     return 0;
40684   }
40685   {
40686     try {
40687       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
40688     } catch (std::out_of_range& e) {
40689       {
40690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40691       };
40692     } catch (std::exception& e) {
40693       {
40694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40695       };
40696     } catch (...) {
40697       {
40698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40699       };
40700     }
40701   }
40702   jresult = (void *)result;
40703   return jresult;
40704 }
40705
40706
40707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
40708   void * jresult ;
40709   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40710   Dali::PathConstrainer *arg2 = 0 ;
40711   Dali::PathConstrainer *result = 0 ;
40712
40713   arg1 = (Dali::PathConstrainer *)jarg1;
40714   arg2 = (Dali::PathConstrainer *)jarg2;
40715   if (!arg2) {
40716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40717     return 0;
40718   }
40719   {
40720     try {
40721       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
40722     } catch (std::out_of_range& e) {
40723       {
40724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40725       };
40726     } catch (std::exception& e) {
40727       {
40728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40729       };
40730     } catch (...) {
40731       {
40732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40733       };
40734     }
40735   }
40736   jresult = (void *)result;
40737   return jresult;
40738 }
40739
40740
40741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40742   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40743   SwigValueWrapper< Dali::Property > arg2 ;
40744   SwigValueWrapper< Dali::Property > arg3 ;
40745   Dali::Vector2 *arg4 = 0 ;
40746   Dali::Vector2 *arg5 = 0 ;
40747   Dali::Property *argp2 ;
40748   Dali::Property *argp3 ;
40749
40750   arg1 = (Dali::PathConstrainer *)jarg1;
40751   argp2 = (Dali::Property *)jarg2;
40752   if (!argp2) {
40753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40754     return ;
40755   }
40756   arg2 = *argp2;
40757   argp3 = (Dali::Property *)jarg3;
40758   if (!argp3) {
40759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40760     return ;
40761   }
40762   arg3 = *argp3;
40763   arg4 = (Dali::Vector2 *)jarg4;
40764   if (!arg4) {
40765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40766     return ;
40767   }
40768   arg5 = (Dali::Vector2 *)jarg5;
40769   if (!arg5) {
40770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40771     return ;
40772   }
40773   {
40774     try {
40775       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40776     } catch (std::out_of_range& e) {
40777       {
40778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40779       };
40780     } catch (std::exception& e) {
40781       {
40782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40783       };
40784     } catch (...) {
40785       {
40786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40787       };
40788     }
40789   }
40790 }
40791
40792
40793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40794   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40795   SwigValueWrapper< Dali::Property > arg2 ;
40796   SwigValueWrapper< Dali::Property > arg3 ;
40797   Dali::Vector2 *arg4 = 0 ;
40798   Dali::Property *argp2 ;
40799   Dali::Property *argp3 ;
40800
40801   arg1 = (Dali::PathConstrainer *)jarg1;
40802   argp2 = (Dali::Property *)jarg2;
40803   if (!argp2) {
40804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40805     return ;
40806   }
40807   arg2 = *argp2;
40808   argp3 = (Dali::Property *)jarg3;
40809   if (!argp3) {
40810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40811     return ;
40812   }
40813   arg3 = *argp3;
40814   arg4 = (Dali::Vector2 *)jarg4;
40815   if (!arg4) {
40816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40817     return ;
40818   }
40819   {
40820     try {
40821       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40822     } catch (std::out_of_range& e) {
40823       {
40824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40825       };
40826     } catch (std::exception& e) {
40827       {
40828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40829       };
40830     } catch (...) {
40831       {
40832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40833       };
40834     }
40835   }
40836 }
40837
40838
40839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
40840   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40841   Dali::Handle *arg2 = 0 ;
40842
40843   arg1 = (Dali::PathConstrainer *)jarg1;
40844   arg2 = (Dali::Handle *)jarg2;
40845   if (!arg2) {
40846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40847     return ;
40848   }
40849   {
40850     try {
40851       (arg1)->Remove(*arg2);
40852     } catch (std::out_of_range& e) {
40853       {
40854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40855       };
40856     } catch (std::exception& e) {
40857       {
40858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40859       };
40860     } catch (...) {
40861       {
40862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40863       };
40864     }
40865   }
40866 }
40867
40868
40869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
40870   int jresult ;
40871   Dali::FittingMode::Type result;
40872
40873   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
40874   jresult = (int)result;
40875   return jresult;
40876 }
40877
40878
40879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
40880   int jresult ;
40881   Dali::SamplingMode::Type result;
40882
40883   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
40884   jresult = (int)result;
40885   return jresult;
40886 }
40887
40888
40889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
40890   void * jresult ;
40891   Dali::BufferImage *result = 0 ;
40892
40893   {
40894     try {
40895       result = (Dali::BufferImage *)new Dali::BufferImage();
40896     } catch (std::out_of_range& e) {
40897       {
40898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40899       };
40900     } catch (std::exception& e) {
40901       {
40902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40903       };
40904     } catch (...) {
40905       {
40906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40907       };
40908     }
40909   }
40910   jresult = (void *)result;
40911   return jresult;
40912 }
40913
40914
40915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
40916   void * jresult ;
40917   unsigned int arg1 ;
40918   unsigned int arg2 ;
40919   Dali::Pixel::Format arg3 ;
40920   Dali::BufferImage result;
40921
40922   arg1 = (unsigned int)jarg1;
40923   arg2 = (unsigned int)jarg2;
40924   arg3 = (Dali::Pixel::Format)jarg3;
40925   {
40926     try {
40927       result = Dali::BufferImage::New(arg1,arg2,arg3);
40928     } catch (std::out_of_range& e) {
40929       {
40930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40931       };
40932     } catch (std::exception& e) {
40933       {
40934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40935       };
40936     } catch (...) {
40937       {
40938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40939       };
40940     }
40941   }
40942   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40943   return jresult;
40944 }
40945
40946
40947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
40948   void * jresult ;
40949   unsigned int arg1 ;
40950   unsigned int arg2 ;
40951   Dali::BufferImage result;
40952
40953   arg1 = (unsigned int)jarg1;
40954   arg2 = (unsigned int)jarg2;
40955   {
40956     try {
40957       result = Dali::BufferImage::New(arg1,arg2);
40958     } catch (std::out_of_range& e) {
40959       {
40960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40961       };
40962     } catch (std::exception& e) {
40963       {
40964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40965       };
40966     } catch (...) {
40967       {
40968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40969       };
40970     }
40971   }
40972   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
40973   return jresult;
40974 }
40975
40976
40977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
40978   void * jresult ;
40979   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
40980   unsigned int arg2 ;
40981   unsigned int arg3 ;
40982   Dali::Pixel::Format arg4 ;
40983   unsigned int arg5 ;
40984   Dali::BufferImage result;
40985
40986   arg1 = jarg1;
40987   arg2 = (unsigned int)jarg2;
40988   arg3 = (unsigned int)jarg3;
40989   arg4 = (Dali::Pixel::Format)jarg4;
40990   arg5 = (unsigned int)jarg5;
40991   {
40992     try {
40993       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
40994     } catch (std::out_of_range& e) {
40995       {
40996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40997       };
40998     } catch (std::exception& e) {
40999       {
41000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41001       };
41002     } catch (...) {
41003       {
41004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41005       };
41006     }
41007   }
41008   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41009
41010
41011   return jresult;
41012 }
41013
41014
41015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41016   void * jresult ;
41017   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41018   unsigned int arg2 ;
41019   unsigned int arg3 ;
41020   Dali::Pixel::Format arg4 ;
41021   Dali::BufferImage result;
41022
41023   arg1 = jarg1;
41024   arg2 = (unsigned int)jarg2;
41025   arg3 = (unsigned int)jarg3;
41026   arg4 = (Dali::Pixel::Format)jarg4;
41027   {
41028     try {
41029       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41030     } catch (std::out_of_range& e) {
41031       {
41032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41033       };
41034     } catch (std::exception& e) {
41035       {
41036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41037       };
41038     } catch (...) {
41039       {
41040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41041       };
41042     }
41043   }
41044   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41045
41046
41047   return jresult;
41048 }
41049
41050
41051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41052   void * jresult ;
41053   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41054   unsigned int arg2 ;
41055   unsigned int arg3 ;
41056   Dali::BufferImage result;
41057
41058   arg1 = jarg1;
41059   arg2 = (unsigned int)jarg2;
41060   arg3 = (unsigned int)jarg3;
41061   {
41062     try {
41063       result = Dali::BufferImage::New(arg1,arg2,arg3);
41064     } catch (std::out_of_range& e) {
41065       {
41066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41067       };
41068     } catch (std::exception& e) {
41069       {
41070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41071       };
41072     } catch (...) {
41073       {
41074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41075       };
41076     }
41077   }
41078   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41079
41080
41081   return jresult;
41082 }
41083
41084
41085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41086   void * jresult ;
41087   Dali::BaseHandle arg1 ;
41088   Dali::BaseHandle *argp1 ;
41089   Dali::BufferImage result;
41090
41091   argp1 = (Dali::BaseHandle *)jarg1;
41092   if (!argp1) {
41093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41094     return 0;
41095   }
41096   arg1 = *argp1;
41097   {
41098     try {
41099       result = Dali::BufferImage::DownCast(arg1);
41100     } catch (std::out_of_range& e) {
41101       {
41102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41103       };
41104     } catch (std::exception& e) {
41105       {
41106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41107       };
41108     } catch (...) {
41109       {
41110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41111       };
41112     }
41113   }
41114   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41115   return jresult;
41116 }
41117
41118
41119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41120   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41121
41122   arg1 = (Dali::BufferImage *)jarg1;
41123   {
41124     try {
41125       delete arg1;
41126     } catch (std::out_of_range& e) {
41127       {
41128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41129       };
41130     } catch (std::exception& e) {
41131       {
41132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41133       };
41134     } catch (...) {
41135       {
41136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41137       };
41138     }
41139   }
41140 }
41141
41142
41143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41144   void * jresult ;
41145   Dali::BufferImage *arg1 = 0 ;
41146   Dali::BufferImage *result = 0 ;
41147
41148   arg1 = (Dali::BufferImage *)jarg1;
41149   if (!arg1) {
41150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41151     return 0;
41152   }
41153   {
41154     try {
41155       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41156     } catch (std::out_of_range& e) {
41157       {
41158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41159       };
41160     } catch (std::exception& e) {
41161       {
41162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41163       };
41164     } catch (...) {
41165       {
41166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41167       };
41168     }
41169   }
41170   jresult = (void *)result;
41171   return jresult;
41172 }
41173
41174
41175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41176   void * jresult ;
41177   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41178   Dali::BufferImage *arg2 = 0 ;
41179   Dali::BufferImage *result = 0 ;
41180
41181   arg1 = (Dali::BufferImage *)jarg1;
41182   arg2 = (Dali::BufferImage *)jarg2;
41183   if (!arg2) {
41184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41185     return 0;
41186   }
41187   {
41188     try {
41189       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41190     } catch (std::out_of_range& e) {
41191       {
41192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41193       };
41194     } catch (std::exception& e) {
41195       {
41196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41197       };
41198     } catch (...) {
41199       {
41200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41201       };
41202     }
41203   }
41204   jresult = (void *)result;
41205   return jresult;
41206 }
41207
41208
41209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41210   void * jresult ;
41211   Dali::BufferImage result;
41212
41213   {
41214     try {
41215       result = Dali::BufferImage::WHITE();
41216     } catch (std::out_of_range& e) {
41217       {
41218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41219       };
41220     } catch (std::exception& e) {
41221       {
41222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41223       };
41224     } catch (...) {
41225       {
41226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41227       };
41228     }
41229   }
41230   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41231   return jresult;
41232 }
41233
41234
41235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41236   void * jresult ;
41237   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41238   Dali::PixelBuffer *result = 0 ;
41239
41240   arg1 = (Dali::BufferImage *)jarg1;
41241   {
41242     try {
41243       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41244     } catch (std::out_of_range& e) {
41245       {
41246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41247       };
41248     } catch (std::exception& e) {
41249       {
41250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41251       };
41252     } catch (...) {
41253       {
41254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41255       };
41256     }
41257   }
41258   jresult = (void *)result;
41259   return jresult;
41260 }
41261
41262
41263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41264   unsigned int jresult ;
41265   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41266   unsigned int result;
41267
41268   arg1 = (Dali::BufferImage *)jarg1;
41269   {
41270     try {
41271       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41272     } catch (std::out_of_range& e) {
41273       {
41274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41275       };
41276     } catch (std::exception& e) {
41277       {
41278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41279       };
41280     } catch (...) {
41281       {
41282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41283       };
41284     }
41285   }
41286   jresult = result;
41287   return jresult;
41288 }
41289
41290
41291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41292   unsigned int jresult ;
41293   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41294   unsigned int result;
41295
41296   arg1 = (Dali::BufferImage *)jarg1;
41297   {
41298     try {
41299       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41300     } catch (std::out_of_range& e) {
41301       {
41302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41303       };
41304     } catch (std::exception& e) {
41305       {
41306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41307       };
41308     } catch (...) {
41309       {
41310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41311       };
41312     }
41313   }
41314   jresult = result;
41315   return jresult;
41316 }
41317
41318
41319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41320   int jresult ;
41321   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41322   Dali::Pixel::Format result;
41323
41324   arg1 = (Dali::BufferImage *)jarg1;
41325   {
41326     try {
41327       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41328     } catch (std::out_of_range& e) {
41329       {
41330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41331       };
41332     } catch (std::exception& e) {
41333       {
41334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41335       };
41336     } catch (...) {
41337       {
41338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41339       };
41340     }
41341   }
41342   jresult = (int)result;
41343   return jresult;
41344 }
41345
41346
41347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41348   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41349
41350   arg1 = (Dali::BufferImage *)jarg1;
41351   {
41352     try {
41353       (arg1)->Update();
41354     } catch (std::out_of_range& e) {
41355       {
41356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41357       };
41358     } catch (std::exception& e) {
41359       {
41360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41361       };
41362     } catch (...) {
41363       {
41364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41365       };
41366     }
41367   }
41368 }
41369
41370
41371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41372   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41373   Dali::RectArea arg2 ;
41374   Dali::RectArea *argp2 ;
41375
41376   arg1 = (Dali::BufferImage *)jarg1;
41377   argp2 = (Dali::RectArea *)jarg2;
41378   if (!argp2) {
41379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41380     return ;
41381   }
41382   arg2 = *argp2;
41383   {
41384     try {
41385       (arg1)->Update(arg2);
41386     } catch (std::out_of_range& e) {
41387       {
41388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41389       };
41390     } catch (std::exception& e) {
41391       {
41392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41393       };
41394     } catch (...) {
41395       {
41396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41397       };
41398     }
41399   }
41400 }
41401
41402
41403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41404   unsigned int jresult ;
41405   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41406   bool result;
41407
41408   arg1 = (Dali::BufferImage *)jarg1;
41409   {
41410     try {
41411       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41412     } catch (std::out_of_range& e) {
41413       {
41414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41415       };
41416     } catch (std::exception& e) {
41417       {
41418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41419       };
41420     } catch (...) {
41421       {
41422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41423       };
41424     }
41425   }
41426   jresult = result;
41427   return jresult;
41428 }
41429
41430
41431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41432   void * jresult ;
41433   Dali::EncodedBufferImage *result = 0 ;
41434
41435   {
41436     try {
41437       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41438     } catch (std::out_of_range& e) {
41439       {
41440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41441       };
41442     } catch (std::exception& e) {
41443       {
41444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41445       };
41446     } catch (...) {
41447       {
41448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41449       };
41450     }
41451   }
41452   jresult = (void *)result;
41453   return jresult;
41454 }
41455
41456
41457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41458   void * jresult ;
41459   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41460   std::size_t arg2 ;
41461   Dali::EncodedBufferImage result;
41462
41463   arg1 = (uint8_t *)jarg1;
41464   arg2 = (std::size_t)jarg2;
41465   {
41466     try {
41467       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41468     } catch (std::out_of_range& e) {
41469       {
41470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41471       };
41472     } catch (std::exception& e) {
41473       {
41474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41475       };
41476     } catch (...) {
41477       {
41478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41479       };
41480     }
41481   }
41482   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41483   return jresult;
41484 }
41485
41486
41487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41488   void * jresult ;
41489   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41490   std::size_t arg2 ;
41491   Dali::ImageDimensions arg3 ;
41492   Dali::FittingMode::Type arg4 ;
41493   Dali::SamplingMode::Type arg5 ;
41494   bool arg6 ;
41495   Dali::ImageDimensions *argp3 ;
41496   Dali::EncodedBufferImage result;
41497
41498   arg1 = (uint8_t *)jarg1;
41499   arg2 = (std::size_t)jarg2;
41500   argp3 = (Dali::ImageDimensions *)jarg3;
41501   if (!argp3) {
41502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41503     return 0;
41504   }
41505   arg3 = *argp3;
41506   arg4 = (Dali::FittingMode::Type)jarg4;
41507   arg5 = (Dali::SamplingMode::Type)jarg5;
41508   arg6 = jarg6 ? true : false;
41509   {
41510     try {
41511       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41512     } catch (std::out_of_range& e) {
41513       {
41514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41515       };
41516     } catch (std::exception& e) {
41517       {
41518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41519       };
41520     } catch (...) {
41521       {
41522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41523       };
41524     }
41525   }
41526   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41527   return jresult;
41528 }
41529
41530
41531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41532   void * jresult ;
41533   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41534   std::size_t arg2 ;
41535   Dali::ImageDimensions arg3 ;
41536   Dali::FittingMode::Type arg4 ;
41537   Dali::SamplingMode::Type arg5 ;
41538   Dali::ImageDimensions *argp3 ;
41539   Dali::EncodedBufferImage result;
41540
41541   arg1 = (uint8_t *)jarg1;
41542   arg2 = (std::size_t)jarg2;
41543   argp3 = (Dali::ImageDimensions *)jarg3;
41544   if (!argp3) {
41545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41546     return 0;
41547   }
41548   arg3 = *argp3;
41549   arg4 = (Dali::FittingMode::Type)jarg4;
41550   arg5 = (Dali::SamplingMode::Type)jarg5;
41551   {
41552     try {
41553       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41554     } catch (std::out_of_range& e) {
41555       {
41556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41557       };
41558     } catch (std::exception& e) {
41559       {
41560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41561       };
41562     } catch (...) {
41563       {
41564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41565       };
41566     }
41567   }
41568   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41569   return jresult;
41570 }
41571
41572
41573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41574   void * jresult ;
41575   Dali::BaseHandle arg1 ;
41576   Dali::BaseHandle *argp1 ;
41577   Dali::EncodedBufferImage result;
41578
41579   argp1 = (Dali::BaseHandle *)jarg1;
41580   if (!argp1) {
41581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41582     return 0;
41583   }
41584   arg1 = *argp1;
41585   {
41586     try {
41587       result = Dali::EncodedBufferImage::DownCast(arg1);
41588     } catch (std::out_of_range& e) {
41589       {
41590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41591       };
41592     } catch (std::exception& e) {
41593       {
41594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41595       };
41596     } catch (...) {
41597       {
41598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41599       };
41600     }
41601   }
41602   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41603   return jresult;
41604 }
41605
41606
41607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41608   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41609
41610   arg1 = (Dali::EncodedBufferImage *)jarg1;
41611   {
41612     try {
41613       delete arg1;
41614     } catch (std::out_of_range& e) {
41615       {
41616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41617       };
41618     } catch (std::exception& e) {
41619       {
41620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41621       };
41622     } catch (...) {
41623       {
41624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41625       };
41626     }
41627   }
41628 }
41629
41630
41631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41632   void * jresult ;
41633   Dali::EncodedBufferImage *arg1 = 0 ;
41634   Dali::EncodedBufferImage *result = 0 ;
41635
41636   arg1 = (Dali::EncodedBufferImage *)jarg1;
41637   if (!arg1) {
41638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41639     return 0;
41640   }
41641   {
41642     try {
41643       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41644     } catch (std::out_of_range& e) {
41645       {
41646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41647       };
41648     } catch (std::exception& e) {
41649       {
41650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41651       };
41652     } catch (...) {
41653       {
41654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41655       };
41656     }
41657   }
41658   jresult = (void *)result;
41659   return jresult;
41660 }
41661
41662
41663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
41664   void * jresult ;
41665   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41666   Dali::EncodedBufferImage *arg2 = 0 ;
41667   Dali::EncodedBufferImage *result = 0 ;
41668
41669   arg1 = (Dali::EncodedBufferImage *)jarg1;
41670   arg2 = (Dali::EncodedBufferImage *)jarg2;
41671   if (!arg2) {
41672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41673     return 0;
41674   }
41675   {
41676     try {
41677       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
41678     } catch (std::out_of_range& e) {
41679       {
41680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41681       };
41682     } catch (std::exception& e) {
41683       {
41684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41685       };
41686     } catch (...) {
41687       {
41688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41689       };
41690     }
41691   }
41692   jresult = (void *)result;
41693   return jresult;
41694 }
41695
41696
41697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
41698   void * jresult ;
41699   Dali::NativeImage *result = 0 ;
41700
41701   {
41702     try {
41703       result = (Dali::NativeImage *)new Dali::NativeImage();
41704     } catch (std::out_of_range& e) {
41705       {
41706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41707       };
41708     } catch (std::exception& e) {
41709       {
41710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41711       };
41712     } catch (...) {
41713       {
41714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41715       };
41716     }
41717   }
41718   jresult = (void *)result;
41719   return jresult;
41720 }
41721
41722
41723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
41724   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41725
41726   arg1 = (Dali::NativeImage *)jarg1;
41727   {
41728     try {
41729       delete arg1;
41730     } catch (std::out_of_range& e) {
41731       {
41732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41733       };
41734     } catch (std::exception& e) {
41735       {
41736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41737       };
41738     } catch (...) {
41739       {
41740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41741       };
41742     }
41743   }
41744 }
41745
41746
41747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
41748   void * jresult ;
41749   Dali::NativeImage *arg1 = 0 ;
41750   Dali::NativeImage *result = 0 ;
41751
41752   arg1 = (Dali::NativeImage *)jarg1;
41753   if (!arg1) {
41754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41755     return 0;
41756   }
41757   {
41758     try {
41759       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
41760     } catch (std::out_of_range& e) {
41761       {
41762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41763       };
41764     } catch (std::exception& e) {
41765       {
41766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41767       };
41768     } catch (...) {
41769       {
41770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41771       };
41772     }
41773   }
41774   jresult = (void *)result;
41775   return jresult;
41776 }
41777
41778
41779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
41780   void * jresult ;
41781   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41782   Dali::NativeImage *arg2 = 0 ;
41783   Dali::NativeImage *result = 0 ;
41784
41785   arg1 = (Dali::NativeImage *)jarg1;
41786   arg2 = (Dali::NativeImage *)jarg2;
41787   if (!arg2) {
41788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41789     return 0;
41790   }
41791   {
41792     try {
41793       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
41794     } catch (std::out_of_range& e) {
41795       {
41796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41797       };
41798     } catch (std::exception& e) {
41799       {
41800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41801       };
41802     } catch (...) {
41803       {
41804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41805       };
41806     }
41807   }
41808   jresult = (void *)result;
41809   return jresult;
41810 }
41811
41812
41813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
41814   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41815
41816   arg1 = (Dali::NativeImage *)jarg1;
41817   {
41818     try {
41819       (arg1)->CreateGlTexture();
41820     } catch (std::out_of_range& e) {
41821       {
41822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41823       };
41824     } catch (std::exception& e) {
41825       {
41826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41827       };
41828     } catch (...) {
41829       {
41830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41831       };
41832     }
41833   }
41834 }
41835
41836
41837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
41838   void * jresult ;
41839   NativeImageInterface *arg1 = 0 ;
41840   Dali::NativeImage result;
41841
41842   arg1 = (NativeImageInterface *)jarg1;
41843   if (!arg1) {
41844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
41845     return 0;
41846   }
41847   {
41848     try {
41849       result = Dali::NativeImage::New(*arg1);
41850     } catch (std::out_of_range& e) {
41851       {
41852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41853       };
41854     } catch (std::exception& e) {
41855       {
41856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41857       };
41858     } catch (...) {
41859       {
41860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41861       };
41862     }
41863   }
41864   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
41865   return jresult;
41866 }
41867
41868
41869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
41870   void * jresult ;
41871   Dali::BaseHandle arg1 ;
41872   Dali::BaseHandle *argp1 ;
41873   Dali::NativeImage result;
41874
41875   argp1 = (Dali::BaseHandle *)jarg1;
41876   if (!argp1) {
41877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41878     return 0;
41879   }
41880   arg1 = *argp1;
41881   {
41882     try {
41883       result = Dali::NativeImage::DownCast(arg1);
41884     } catch (std::out_of_range& e) {
41885       {
41886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41887       };
41888     } catch (std::exception& e) {
41889       {
41890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41891       };
41892     } catch (...) {
41893       {
41894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41895       };
41896     }
41897   }
41898   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
41899   return jresult;
41900 }
41901
41902
41903 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
41904   char * jresult ;
41905   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41906   char *result = 0 ;
41907
41908   arg1 = (Dali::NativeImage *)jarg1;
41909   {
41910     try {
41911       result = (char *)(arg1)->GetCustomFragmentPreFix();
41912     } catch (std::out_of_range& e) {
41913       {
41914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41915       };
41916     } catch (std::exception& e) {
41917       {
41918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41919       };
41920     } catch (...) {
41921       {
41922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41923       };
41924     }
41925   }
41926   jresult = SWIG_csharp_string_callback((const char *)result);
41927   return jresult;
41928 }
41929
41930
41931 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
41932   char * jresult ;
41933   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41934   char *result = 0 ;
41935
41936   arg1 = (Dali::NativeImage *)jarg1;
41937   {
41938     try {
41939       result = (char *)(arg1)->GetCustomSamplerTypename();
41940     } catch (std::out_of_range& e) {
41941       {
41942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41943       };
41944     } catch (std::exception& e) {
41945       {
41946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41947       };
41948     } catch (...) {
41949       {
41950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41951       };
41952     }
41953   }
41954   jresult = SWIG_csharp_string_callback((const char *)result);
41955   return jresult;
41956 }
41957
41958
41959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
41960   unsigned int jresult ;
41961   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
41962   bool result;
41963
41964   arg1 = (Dali::NativeImageInterface *)jarg1;
41965   {
41966     try {
41967       result = (bool)(arg1)->GlExtensionCreate();
41968     } catch (std::out_of_range& e) {
41969       {
41970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41971       };
41972     } catch (std::exception& e) {
41973       {
41974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41975       };
41976     } catch (...) {
41977       {
41978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41979       };
41980     }
41981   }
41982   jresult = result;
41983   return jresult;
41984 }
41985
41986
41987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
41988   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
41989
41990   arg1 = (Dali::NativeImageInterface *)jarg1;
41991   {
41992     try {
41993       (arg1)->GlExtensionDestroy();
41994     } catch (std::out_of_range& e) {
41995       {
41996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41997       };
41998     } catch (std::exception& e) {
41999       {
42000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42001       };
42002     } catch (...) {
42003       {
42004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42005       };
42006     }
42007   }
42008 }
42009
42010
42011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42012   unsigned int jresult ;
42013   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42014   unsigned int result;
42015
42016   arg1 = (Dali::NativeImageInterface *)jarg1;
42017   {
42018     try {
42019       result = (unsigned int)(arg1)->TargetTexture();
42020     } catch (std::out_of_range& e) {
42021       {
42022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42023       };
42024     } catch (std::exception& e) {
42025       {
42026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42027       };
42028     } catch (...) {
42029       {
42030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42031       };
42032     }
42033   }
42034   jresult = result;
42035   return jresult;
42036 }
42037
42038
42039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42040   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42041
42042   arg1 = (Dali::NativeImageInterface *)jarg1;
42043   {
42044     try {
42045       (arg1)->PrepareTexture();
42046     } catch (std::out_of_range& e) {
42047       {
42048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42049       };
42050     } catch (std::exception& e) {
42051       {
42052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42053       };
42054     } catch (...) {
42055       {
42056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42057       };
42058     }
42059   }
42060 }
42061
42062
42063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42064   unsigned int jresult ;
42065   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42066   unsigned int result;
42067
42068   arg1 = (Dali::NativeImageInterface *)jarg1;
42069   {
42070     try {
42071       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42072     } catch (std::out_of_range& e) {
42073       {
42074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42075       };
42076     } catch (std::exception& e) {
42077       {
42078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42079       };
42080     } catch (...) {
42081       {
42082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42083       };
42084     }
42085   }
42086   jresult = result;
42087   return jresult;
42088 }
42089
42090
42091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42092   unsigned int jresult ;
42093   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42094   unsigned int result;
42095
42096   arg1 = (Dali::NativeImageInterface *)jarg1;
42097   {
42098     try {
42099       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42100     } catch (std::out_of_range& e) {
42101       {
42102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42103       };
42104     } catch (std::exception& e) {
42105       {
42106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42107       };
42108     } catch (...) {
42109       {
42110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42111       };
42112     }
42113   }
42114   jresult = result;
42115   return jresult;
42116 }
42117
42118
42119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42120   unsigned int jresult ;
42121   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42122   bool result;
42123
42124   arg1 = (Dali::NativeImageInterface *)jarg1;
42125   {
42126     try {
42127       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42128     } catch (std::out_of_range& e) {
42129       {
42130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42131       };
42132     } catch (std::exception& e) {
42133       {
42134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42135       };
42136     } catch (...) {
42137       {
42138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42139       };
42140     }
42141   }
42142   jresult = result;
42143   return jresult;
42144 }
42145
42146
42147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42148   void * jresult ;
42149   std::string *arg1 = 0 ;
42150   Dali::ImageDimensions result;
42151
42152   if (!jarg1) {
42153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42154     return 0;
42155   }
42156   std::string arg1_str(jarg1);
42157   arg1 = &arg1_str;
42158   {
42159     try {
42160       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42161     } catch (std::out_of_range& e) {
42162       {
42163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42164       };
42165     } catch (std::exception& e) {
42166       {
42167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42168       };
42169     } catch (...) {
42170       {
42171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42172       };
42173     }
42174   }
42175   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42176
42177   //argout typemap for const std::string&
42178
42179   return jresult;
42180 }
42181
42182
42183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42184   void * jresult ;
42185   Dali::ResourceImage *result = 0 ;
42186
42187   {
42188     try {
42189       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42190     } catch (std::out_of_range& e) {
42191       {
42192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42193       };
42194     } catch (std::exception& e) {
42195       {
42196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42197       };
42198     } catch (...) {
42199       {
42200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42201       };
42202     }
42203   }
42204   jresult = (void *)result;
42205   return jresult;
42206 }
42207
42208
42209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42210   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42211
42212   arg1 = (Dali::ResourceImage *)jarg1;
42213   {
42214     try {
42215       delete arg1;
42216     } catch (std::out_of_range& e) {
42217       {
42218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42219       };
42220     } catch (std::exception& e) {
42221       {
42222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42223       };
42224     } catch (...) {
42225       {
42226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42227       };
42228     }
42229   }
42230 }
42231
42232
42233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42234   void * jresult ;
42235   Dali::ResourceImage *arg1 = 0 ;
42236   Dali::ResourceImage *result = 0 ;
42237
42238   arg1 = (Dali::ResourceImage *)jarg1;
42239   if (!arg1) {
42240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42241     return 0;
42242   }
42243   {
42244     try {
42245       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42246     } catch (std::out_of_range& e) {
42247       {
42248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42249       };
42250     } catch (std::exception& e) {
42251       {
42252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42253       };
42254     } catch (...) {
42255       {
42256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42257       };
42258     }
42259   }
42260   jresult = (void *)result;
42261   return jresult;
42262 }
42263
42264
42265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42266   void * jresult ;
42267   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42268   Dali::ResourceImage *arg2 = 0 ;
42269   Dali::ResourceImage *result = 0 ;
42270
42271   arg1 = (Dali::ResourceImage *)jarg1;
42272   arg2 = (Dali::ResourceImage *)jarg2;
42273   if (!arg2) {
42274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42275     return 0;
42276   }
42277   {
42278     try {
42279       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42280     } catch (std::out_of_range& e) {
42281       {
42282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42283       };
42284     } catch (std::exception& e) {
42285       {
42286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42287       };
42288     } catch (...) {
42289       {
42290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42291       };
42292     }
42293   }
42294   jresult = (void *)result;
42295   return jresult;
42296 }
42297
42298
42299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42300   void * jresult ;
42301   std::string *arg1 = 0 ;
42302   bool arg2 ;
42303   Dali::ResourceImage result;
42304
42305   if (!jarg1) {
42306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42307     return 0;
42308   }
42309   std::string arg1_str(jarg1);
42310   arg1 = &arg1_str;
42311   arg2 = jarg2 ? true : false;
42312   {
42313     try {
42314       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42315     } catch (std::out_of_range& e) {
42316       {
42317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42318       };
42319     } catch (std::exception& e) {
42320       {
42321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42322       };
42323     } catch (...) {
42324       {
42325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42326       };
42327     }
42328   }
42329   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42330
42331   //argout typemap for const std::string&
42332
42333   return jresult;
42334 }
42335
42336
42337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42338   void * jresult ;
42339   std::string *arg1 = 0 ;
42340   Dali::ResourceImage result;
42341
42342   if (!jarg1) {
42343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42344     return 0;
42345   }
42346   std::string arg1_str(jarg1);
42347   arg1 = &arg1_str;
42348   {
42349     try {
42350       result = Dali::ResourceImage::New((std::string 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 = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42366
42367   //argout typemap for const std::string&
42368
42369   return jresult;
42370 }
42371
42372
42373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42374   void * jresult ;
42375   std::string *arg1 = 0 ;
42376   Dali::ImageDimensions arg2 ;
42377   Dali::FittingMode::Type arg3 ;
42378   Dali::SamplingMode::Type arg4 ;
42379   bool arg5 ;
42380   Dali::ImageDimensions *argp2 ;
42381   Dali::ResourceImage result;
42382
42383   if (!jarg1) {
42384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42385     return 0;
42386   }
42387   std::string arg1_str(jarg1);
42388   arg1 = &arg1_str;
42389   argp2 = (Dali::ImageDimensions *)jarg2;
42390   if (!argp2) {
42391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42392     return 0;
42393   }
42394   arg2 = *argp2;
42395   arg3 = (Dali::FittingMode::Type)jarg3;
42396   arg4 = (Dali::SamplingMode::Type)jarg4;
42397   arg5 = jarg5 ? true : false;
42398   {
42399     try {
42400       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42401     } catch (std::out_of_range& e) {
42402       {
42403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42404       };
42405     } catch (std::exception& e) {
42406       {
42407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42408       };
42409     } catch (...) {
42410       {
42411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42412       };
42413     }
42414   }
42415   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42416
42417   //argout typemap for const std::string&
42418
42419   return jresult;
42420 }
42421
42422
42423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42424   void * jresult ;
42425   std::string *arg1 = 0 ;
42426   Dali::ImageDimensions arg2 ;
42427   Dali::FittingMode::Type arg3 ;
42428   Dali::SamplingMode::Type arg4 ;
42429   Dali::ImageDimensions *argp2 ;
42430   Dali::ResourceImage result;
42431
42432   if (!jarg1) {
42433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42434     return 0;
42435   }
42436   std::string arg1_str(jarg1);
42437   arg1 = &arg1_str;
42438   argp2 = (Dali::ImageDimensions *)jarg2;
42439   if (!argp2) {
42440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42441     return 0;
42442   }
42443   arg2 = *argp2;
42444   arg3 = (Dali::FittingMode::Type)jarg3;
42445   arg4 = (Dali::SamplingMode::Type)jarg4;
42446   {
42447     try {
42448       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42449     } catch (std::out_of_range& e) {
42450       {
42451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42452       };
42453     } catch (std::exception& e) {
42454       {
42455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42456       };
42457     } catch (...) {
42458       {
42459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42460       };
42461     }
42462   }
42463   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42464
42465   //argout typemap for const std::string&
42466
42467   return jresult;
42468 }
42469
42470
42471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42472   void * jresult ;
42473   std::string *arg1 = 0 ;
42474   Dali::ImageDimensions arg2 ;
42475   Dali::FittingMode::Type arg3 ;
42476   Dali::ImageDimensions *argp2 ;
42477   Dali::ResourceImage result;
42478
42479   if (!jarg1) {
42480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42481     return 0;
42482   }
42483   std::string arg1_str(jarg1);
42484   arg1 = &arg1_str;
42485   argp2 = (Dali::ImageDimensions *)jarg2;
42486   if (!argp2) {
42487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42488     return 0;
42489   }
42490   arg2 = *argp2;
42491   arg3 = (Dali::FittingMode::Type)jarg3;
42492   {
42493     try {
42494       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42495     } catch (std::out_of_range& e) {
42496       {
42497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42498       };
42499     } catch (std::exception& e) {
42500       {
42501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42502       };
42503     } catch (...) {
42504       {
42505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42506       };
42507     }
42508   }
42509   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42510
42511   //argout typemap for const std::string&
42512
42513   return jresult;
42514 }
42515
42516
42517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42518   void * jresult ;
42519   std::string *arg1 = 0 ;
42520   Dali::ImageDimensions arg2 ;
42521   Dali::ImageDimensions *argp2 ;
42522   Dali::ResourceImage result;
42523
42524   if (!jarg1) {
42525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42526     return 0;
42527   }
42528   std::string arg1_str(jarg1);
42529   arg1 = &arg1_str;
42530   argp2 = (Dali::ImageDimensions *)jarg2;
42531   if (!argp2) {
42532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42533     return 0;
42534   }
42535   arg2 = *argp2;
42536   {
42537     try {
42538       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42539     } catch (std::out_of_range& e) {
42540       {
42541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42542       };
42543     } catch (std::exception& e) {
42544       {
42545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42546       };
42547     } catch (...) {
42548       {
42549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42550       };
42551     }
42552   }
42553   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42554
42555   //argout typemap for const std::string&
42556
42557   return jresult;
42558 }
42559
42560
42561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42562   void * jresult ;
42563   Dali::BaseHandle arg1 ;
42564   Dali::BaseHandle *argp1 ;
42565   Dali::ResourceImage result;
42566
42567   argp1 = (Dali::BaseHandle *)jarg1;
42568   if (!argp1) {
42569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42570     return 0;
42571   }
42572   arg1 = *argp1;
42573   {
42574     try {
42575       result = Dali::ResourceImage::DownCast(arg1);
42576     } catch (std::out_of_range& e) {
42577       {
42578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42579       };
42580     } catch (std::exception& e) {
42581       {
42582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42583       };
42584     } catch (...) {
42585       {
42586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42587       };
42588     }
42589   }
42590   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42591   return jresult;
42592 }
42593
42594
42595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42596   int jresult ;
42597   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42598   Dali::LoadingState result;
42599
42600   arg1 = (Dali::ResourceImage *)jarg1;
42601   {
42602     try {
42603       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42604     } catch (std::out_of_range& e) {
42605       {
42606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42607       };
42608     } catch (std::exception& e) {
42609       {
42610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42611       };
42612     } catch (...) {
42613       {
42614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42615       };
42616     }
42617   }
42618   jresult = (int)result;
42619   return jresult;
42620 }
42621
42622
42623 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42624   char * jresult ;
42625   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42626   std::string result;
42627
42628   arg1 = (Dali::ResourceImage *)jarg1;
42629   {
42630     try {
42631       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42632     } catch (std::out_of_range& e) {
42633       {
42634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42635       };
42636     } catch (std::exception& e) {
42637       {
42638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42639       };
42640     } catch (...) {
42641       {
42642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42643       };
42644     }
42645   }
42646   jresult = SWIG_csharp_string_callback((&result)->c_str());
42647   return jresult;
42648 }
42649
42650
42651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42652   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42653
42654   arg1 = (Dali::ResourceImage *)jarg1;
42655   {
42656     try {
42657       (arg1)->Reload();
42658     } catch (std::out_of_range& e) {
42659       {
42660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42661       };
42662     } catch (std::exception& e) {
42663       {
42664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42665       };
42666     } catch (...) {
42667       {
42668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42669       };
42670     }
42671   }
42672 }
42673
42674
42675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
42676   void * jresult ;
42677   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42678   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
42679
42680   arg1 = (Dali::ResourceImage *)jarg1;
42681   {
42682     try {
42683       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
42684     } catch (std::out_of_range& e) {
42685       {
42686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42687       };
42688     } catch (std::exception& e) {
42689       {
42690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42691       };
42692     } catch (...) {
42693       {
42694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42695       };
42696     }
42697   }
42698   jresult = (void *)result;
42699   return jresult;
42700 }
42701
42702
42703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
42704   void * jresult ;
42705   Dali::FrameBufferImage *result = 0 ;
42706
42707   {
42708     try {
42709       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
42710     } catch (std::out_of_range& e) {
42711       {
42712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42713       };
42714     } catch (std::exception& e) {
42715       {
42716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42717       };
42718     } catch (...) {
42719       {
42720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42721       };
42722     }
42723   }
42724   jresult = (void *)result;
42725   return jresult;
42726 }
42727
42728
42729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
42730   void * jresult ;
42731   unsigned int arg1 ;
42732   unsigned int arg2 ;
42733   Dali::Pixel::Format arg3 ;
42734   Dali::RenderBuffer::Format arg4 ;
42735   Dali::FrameBufferImage result;
42736
42737   arg1 = (unsigned int)jarg1;
42738   arg2 = (unsigned int)jarg2;
42739   arg3 = (Dali::Pixel::Format)jarg3;
42740   arg4 = (Dali::RenderBuffer::Format)jarg4;
42741   {
42742     try {
42743       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
42744     } catch (std::out_of_range& e) {
42745       {
42746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42747       };
42748     } catch (std::exception& e) {
42749       {
42750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42751       };
42752     } catch (...) {
42753       {
42754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42755       };
42756     }
42757   }
42758   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42759   return jresult;
42760 }
42761
42762
42763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
42764   void * jresult ;
42765   unsigned int arg1 ;
42766   unsigned int arg2 ;
42767   Dali::Pixel::Format arg3 ;
42768   Dali::FrameBufferImage result;
42769
42770   arg1 = (unsigned int)jarg1;
42771   arg2 = (unsigned int)jarg2;
42772   arg3 = (Dali::Pixel::Format)jarg3;
42773   {
42774     try {
42775       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
42776     } catch (std::out_of_range& e) {
42777       {
42778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42779       };
42780     } catch (std::exception& e) {
42781       {
42782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42783       };
42784     } catch (...) {
42785       {
42786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42787       };
42788     }
42789   }
42790   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42791   return jresult;
42792 }
42793
42794
42795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
42796   void * jresult ;
42797   unsigned int arg1 ;
42798   unsigned int arg2 ;
42799   Dali::FrameBufferImage result;
42800
42801   arg1 = (unsigned int)jarg1;
42802   arg2 = (unsigned int)jarg2;
42803   {
42804     try {
42805       result = Dali::FrameBufferImage::New(arg1,arg2);
42806     } catch (std::out_of_range& e) {
42807       {
42808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42809       };
42810     } catch (std::exception& e) {
42811       {
42812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42813       };
42814     } catch (...) {
42815       {
42816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42817       };
42818     }
42819   }
42820   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42821   return jresult;
42822 }
42823
42824
42825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
42826   void * jresult ;
42827   unsigned int arg1 ;
42828   Dali::FrameBufferImage result;
42829
42830   arg1 = (unsigned int)jarg1;
42831   {
42832     try {
42833       result = Dali::FrameBufferImage::New(arg1);
42834     } catch (std::out_of_range& e) {
42835       {
42836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42837       };
42838     } catch (std::exception& e) {
42839       {
42840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42841       };
42842     } catch (...) {
42843       {
42844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42845       };
42846     }
42847   }
42848   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42849   return jresult;
42850 }
42851
42852
42853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
42854   void * jresult ;
42855   Dali::FrameBufferImage result;
42856
42857   {
42858     try {
42859       result = Dali::FrameBufferImage::New();
42860     } catch (std::out_of_range& e) {
42861       {
42862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42863       };
42864     } catch (std::exception& e) {
42865       {
42866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42867       };
42868     } catch (...) {
42869       {
42870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42871       };
42872     }
42873   }
42874   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42875   return jresult;
42876 }
42877
42878
42879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
42880   void * jresult ;
42881   Dali::NativeImageInterface *arg1 = 0 ;
42882   Dali::FrameBufferImage result;
42883
42884   arg1 = (Dali::NativeImageInterface *)jarg1;
42885   if (!arg1) {
42886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
42887     return 0;
42888   }
42889   {
42890     try {
42891       result = Dali::FrameBufferImage::New(*arg1);
42892     } catch (std::out_of_range& e) {
42893       {
42894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42895       };
42896     } catch (std::exception& e) {
42897       {
42898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42899       };
42900     } catch (...) {
42901       {
42902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42903       };
42904     }
42905   }
42906   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42907   return jresult;
42908 }
42909
42910
42911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
42912   void * jresult ;
42913   Dali::BaseHandle arg1 ;
42914   Dali::BaseHandle *argp1 ;
42915   Dali::FrameBufferImage result;
42916
42917   argp1 = (Dali::BaseHandle *)jarg1;
42918   if (!argp1) {
42919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42920     return 0;
42921   }
42922   arg1 = *argp1;
42923   {
42924     try {
42925       result = Dali::FrameBufferImage::DownCast(arg1);
42926     } catch (std::out_of_range& e) {
42927       {
42928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42929       };
42930     } catch (std::exception& e) {
42931       {
42932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42933       };
42934     } catch (...) {
42935       {
42936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42937       };
42938     }
42939   }
42940   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42941   return jresult;
42942 }
42943
42944
42945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
42946   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
42947
42948   arg1 = (Dali::FrameBufferImage *)jarg1;
42949   {
42950     try {
42951       delete arg1;
42952     } catch (std::out_of_range& e) {
42953       {
42954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42955       };
42956     } catch (std::exception& e) {
42957       {
42958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42959       };
42960     } catch (...) {
42961       {
42962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42963       };
42964     }
42965   }
42966 }
42967
42968
42969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
42970   void * jresult ;
42971   Dali::FrameBufferImage *arg1 = 0 ;
42972   Dali::FrameBufferImage *result = 0 ;
42973
42974   arg1 = (Dali::FrameBufferImage *)jarg1;
42975   if (!arg1) {
42976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
42977     return 0;
42978   }
42979   {
42980     try {
42981       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
42982     } catch (std::out_of_range& e) {
42983       {
42984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42985       };
42986     } catch (std::exception& e) {
42987       {
42988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42989       };
42990     } catch (...) {
42991       {
42992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42993       };
42994     }
42995   }
42996   jresult = (void *)result;
42997   return jresult;
42998 }
42999
43000
43001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43002   void * jresult ;
43003   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43004   Dali::FrameBufferImage *arg2 = 0 ;
43005   Dali::FrameBufferImage *result = 0 ;
43006
43007   arg1 = (Dali::FrameBufferImage *)jarg1;
43008   arg2 = (Dali::FrameBufferImage *)jarg2;
43009   if (!arg2) {
43010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43011     return 0;
43012   }
43013   {
43014     try {
43015       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43016     } catch (std::out_of_range& e) {
43017       {
43018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43019       };
43020     } catch (std::exception& e) {
43021       {
43022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43023       };
43024     } catch (...) {
43025       {
43026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43027       };
43028     }
43029   }
43030   jresult = (void *)result;
43031   return jresult;
43032 }
43033
43034
43035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43036   void * jresult ;
43037   Dali::NinePatchImage *result = 0 ;
43038
43039   {
43040     try {
43041       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43042     } catch (std::out_of_range& e) {
43043       {
43044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43045       };
43046     } catch (std::exception& e) {
43047       {
43048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43049       };
43050     } catch (...) {
43051       {
43052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43053       };
43054     }
43055   }
43056   jresult = (void *)result;
43057   return jresult;
43058 }
43059
43060
43061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43062   void * jresult ;
43063   std::string *arg1 = 0 ;
43064   Dali::NinePatchImage result;
43065
43066   if (!jarg1) {
43067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43068     return 0;
43069   }
43070   std::string arg1_str(jarg1);
43071   arg1 = &arg1_str;
43072   {
43073     try {
43074       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43075     } catch (std::out_of_range& e) {
43076       {
43077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43078       };
43079     } catch (std::exception& e) {
43080       {
43081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43082       };
43083     } catch (...) {
43084       {
43085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43086       };
43087     }
43088   }
43089   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43090
43091   //argout typemap for const std::string&
43092
43093   return jresult;
43094 }
43095
43096
43097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43098   void * jresult ;
43099   Dali::BaseHandle arg1 ;
43100   Dali::BaseHandle *argp1 ;
43101   Dali::NinePatchImage result;
43102
43103   argp1 = (Dali::BaseHandle *)jarg1;
43104   if (!argp1) {
43105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43106     return 0;
43107   }
43108   arg1 = *argp1;
43109   {
43110     try {
43111       result = Dali::NinePatchImage::DownCast(arg1);
43112     } catch (std::out_of_range& e) {
43113       {
43114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43115       };
43116     } catch (std::exception& e) {
43117       {
43118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43119       };
43120     } catch (...) {
43121       {
43122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43123       };
43124     }
43125   }
43126   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43127   return jresult;
43128 }
43129
43130
43131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43132   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43133
43134   arg1 = (Dali::NinePatchImage *)jarg1;
43135   {
43136     try {
43137       delete arg1;
43138     } catch (std::out_of_range& e) {
43139       {
43140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43141       };
43142     } catch (std::exception& e) {
43143       {
43144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43145       };
43146     } catch (...) {
43147       {
43148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43149       };
43150     }
43151   }
43152 }
43153
43154
43155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43156   void * jresult ;
43157   Dali::NinePatchImage *arg1 = 0 ;
43158   Dali::NinePatchImage *result = 0 ;
43159
43160   arg1 = (Dali::NinePatchImage *)jarg1;
43161   if (!arg1) {
43162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43163     return 0;
43164   }
43165   {
43166     try {
43167       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43168     } catch (std::out_of_range& e) {
43169       {
43170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43171       };
43172     } catch (std::exception& e) {
43173       {
43174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43175       };
43176     } catch (...) {
43177       {
43178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43179       };
43180     }
43181   }
43182   jresult = (void *)result;
43183   return jresult;
43184 }
43185
43186
43187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43188   void * jresult ;
43189   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43190   Dali::NinePatchImage *arg2 = 0 ;
43191   Dali::NinePatchImage *result = 0 ;
43192
43193   arg1 = (Dali::NinePatchImage *)jarg1;
43194   arg2 = (Dali::NinePatchImage *)jarg2;
43195   if (!arg2) {
43196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43197     return 0;
43198   }
43199   {
43200     try {
43201       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43202     } catch (std::out_of_range& e) {
43203       {
43204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43205       };
43206     } catch (std::exception& e) {
43207       {
43208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43209       };
43210     } catch (...) {
43211       {
43212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43213       };
43214     }
43215   }
43216   jresult = (void *)result;
43217   return jresult;
43218 }
43219
43220
43221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43222   void * jresult ;
43223   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43224   Dali::Vector4 result;
43225
43226   arg1 = (Dali::NinePatchImage *)jarg1;
43227   {
43228     try {
43229       result = (arg1)->GetStretchBorders();
43230     } catch (std::out_of_range& e) {
43231       {
43232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43233       };
43234     } catch (std::exception& e) {
43235       {
43236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43237       };
43238     } catch (...) {
43239       {
43240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43241       };
43242     }
43243   }
43244   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43245   return jresult;
43246 }
43247
43248
43249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43250   void * jresult ;
43251   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43252   Dali::NinePatchImage::StretchRanges *result = 0 ;
43253
43254   arg1 = (Dali::NinePatchImage *)jarg1;
43255   {
43256     try {
43257       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43258     } catch (std::out_of_range& e) {
43259       {
43260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43261       };
43262     } catch (std::exception& e) {
43263       {
43264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43265       };
43266     } catch (...) {
43267       {
43268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43269       };
43270     }
43271   }
43272   jresult = (void *)result;
43273   return jresult;
43274 }
43275
43276
43277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43278   void * jresult ;
43279   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43280   Dali::NinePatchImage::StretchRanges *result = 0 ;
43281
43282   arg1 = (Dali::NinePatchImage *)jarg1;
43283   {
43284     try {
43285       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43286     } catch (std::out_of_range& e) {
43287       {
43288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43289       };
43290     } catch (std::exception& e) {
43291       {
43292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43293       };
43294     } catch (...) {
43295       {
43296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43297       };
43298     }
43299   }
43300   jresult = (void *)result;
43301   return jresult;
43302 }
43303
43304
43305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43306   void * jresult ;
43307   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43308   Dali::Rect< int > result;
43309
43310   arg1 = (Dali::NinePatchImage *)jarg1;
43311   {
43312     try {
43313       result = (arg1)->GetChildRectangle();
43314     } catch (std::out_of_range& e) {
43315       {
43316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43317       };
43318     } catch (std::exception& e) {
43319       {
43320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43321       };
43322     } catch (...) {
43323       {
43324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43325       };
43326     }
43327   }
43328   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43329   return jresult;
43330 }
43331
43332
43333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43334   void * jresult ;
43335   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43336   Dali::BufferImage result;
43337
43338   arg1 = (Dali::NinePatchImage *)jarg1;
43339   {
43340     try {
43341       result = (arg1)->CreateCroppedBufferImage();
43342     } catch (std::out_of_range& e) {
43343       {
43344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43345       };
43346     } catch (std::exception& e) {
43347       {
43348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43349       };
43350     } catch (...) {
43351       {
43352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43353       };
43354     }
43355   }
43356   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43357   return jresult;
43358 }
43359
43360
43361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43362   unsigned int jresult ;
43363   std::string *arg1 = 0 ;
43364   bool result;
43365
43366   if (!jarg1) {
43367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43368     return 0;
43369   }
43370   std::string arg1_str(jarg1);
43371   arg1 = &arg1_str;
43372   {
43373     try {
43374       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43375     } catch (std::out_of_range& e) {
43376       {
43377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43378       };
43379     } catch (std::exception& e) {
43380       {
43381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43382       };
43383     } catch (...) {
43384       {
43385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43386       };
43387     }
43388   }
43389   jresult = result;
43390
43391   //argout typemap for const std::string&
43392
43393   return jresult;
43394 }
43395
43396
43397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43398   int jresult ;
43399   int result;
43400
43401   result = (int)Dali::CameraActor::Property::TYPE;
43402   jresult = (int)result;
43403   return jresult;
43404 }
43405
43406
43407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43408   int jresult ;
43409   int result;
43410
43411   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43412   jresult = (int)result;
43413   return jresult;
43414 }
43415
43416
43417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43418   int jresult ;
43419   int result;
43420
43421   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43422   jresult = (int)result;
43423   return jresult;
43424 }
43425
43426
43427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43428   int jresult ;
43429   int result;
43430
43431   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43432   jresult = (int)result;
43433   return jresult;
43434 }
43435
43436
43437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43438   int jresult ;
43439   int result;
43440
43441   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43442   jresult = (int)result;
43443   return jresult;
43444 }
43445
43446
43447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43448   int jresult ;
43449   int result;
43450
43451   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43452   jresult = (int)result;
43453   return jresult;
43454 }
43455
43456
43457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43458   int jresult ;
43459   int result;
43460
43461   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43462   jresult = (int)result;
43463   return jresult;
43464 }
43465
43466
43467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43468   int jresult ;
43469   int result;
43470
43471   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43472   jresult = (int)result;
43473   return jresult;
43474 }
43475
43476
43477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43478   int jresult ;
43479   int result;
43480
43481   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43482   jresult = (int)result;
43483   return jresult;
43484 }
43485
43486
43487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43488   int jresult ;
43489   int result;
43490
43491   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43492   jresult = (int)result;
43493   return jresult;
43494 }
43495
43496
43497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43498   int jresult ;
43499   int result;
43500
43501   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43502   jresult = (int)result;
43503   return jresult;
43504 }
43505
43506
43507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43508   int jresult ;
43509   int result;
43510
43511   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43512   jresult = (int)result;
43513   return jresult;
43514 }
43515
43516
43517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43518   int jresult ;
43519   int result;
43520
43521   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43522   jresult = (int)result;
43523   return jresult;
43524 }
43525
43526
43527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43528   int jresult ;
43529   int result;
43530
43531   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43532   jresult = (int)result;
43533   return jresult;
43534 }
43535
43536
43537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43538   void * jresult ;
43539   Dali::CameraActor::Property *result = 0 ;
43540
43541   {
43542     try {
43543       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43544     } catch (std::out_of_range& e) {
43545       {
43546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43547       };
43548     } catch (std::exception& e) {
43549       {
43550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43551       };
43552     } catch (...) {
43553       {
43554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43555       };
43556     }
43557   }
43558   jresult = (void *)result;
43559   return jresult;
43560 }
43561
43562
43563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43564   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43565
43566   arg1 = (Dali::CameraActor::Property *)jarg1;
43567   {
43568     try {
43569       delete arg1;
43570     } catch (std::out_of_range& e) {
43571       {
43572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43573       };
43574     } catch (std::exception& e) {
43575       {
43576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43577       };
43578     } catch (...) {
43579       {
43580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43581       };
43582     }
43583   }
43584 }
43585
43586
43587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43588   void * jresult ;
43589   Dali::CameraActor *result = 0 ;
43590
43591   {
43592     try {
43593       result = (Dali::CameraActor *)new Dali::CameraActor();
43594     } catch (std::out_of_range& e) {
43595       {
43596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43597       };
43598     } catch (std::exception& e) {
43599       {
43600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43601       };
43602     } catch (...) {
43603       {
43604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43605       };
43606     }
43607   }
43608   jresult = (void *)result;
43609   return jresult;
43610 }
43611
43612
43613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43614   void * jresult ;
43615   Dali::CameraActor result;
43616
43617   {
43618     try {
43619       result = Dali::CameraActor::New();
43620     } catch (std::out_of_range& e) {
43621       {
43622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43623       };
43624     } catch (std::exception& e) {
43625       {
43626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43627       };
43628     } catch (...) {
43629       {
43630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43631       };
43632     }
43633   }
43634   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43635   return jresult;
43636 }
43637
43638
43639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43640   void * jresult ;
43641   Dali::Size *arg1 = 0 ;
43642   Dali::CameraActor result;
43643
43644   arg1 = (Dali::Size *)jarg1;
43645   if (!arg1) {
43646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43647     return 0;
43648   }
43649   {
43650     try {
43651       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43652     } catch (std::out_of_range& e) {
43653       {
43654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43655       };
43656     } catch (std::exception& e) {
43657       {
43658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43659       };
43660     } catch (...) {
43661       {
43662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43663       };
43664     }
43665   }
43666   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43667   return jresult;
43668 }
43669
43670
43671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
43672   void * jresult ;
43673   Dali::BaseHandle arg1 ;
43674   Dali::BaseHandle *argp1 ;
43675   Dali::CameraActor result;
43676
43677   argp1 = (Dali::BaseHandle *)jarg1;
43678   if (!argp1) {
43679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43680     return 0;
43681   }
43682   arg1 = *argp1;
43683   {
43684     try {
43685       result = Dali::CameraActor::DownCast(arg1);
43686     } catch (std::out_of_range& e) {
43687       {
43688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43689       };
43690     } catch (std::exception& e) {
43691       {
43692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43693       };
43694     } catch (...) {
43695       {
43696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43697       };
43698     }
43699   }
43700   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43701   return jresult;
43702 }
43703
43704
43705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
43706   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43707
43708   arg1 = (Dali::CameraActor *)jarg1;
43709   {
43710     try {
43711       delete arg1;
43712     } catch (std::out_of_range& e) {
43713       {
43714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43715       };
43716     } catch (std::exception& e) {
43717       {
43718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43719       };
43720     } catch (...) {
43721       {
43722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43723       };
43724     }
43725   }
43726 }
43727
43728
43729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
43730   void * jresult ;
43731   Dali::CameraActor *arg1 = 0 ;
43732   Dali::CameraActor *result = 0 ;
43733
43734   arg1 = (Dali::CameraActor *)jarg1;
43735   if (!arg1) {
43736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43737     return 0;
43738   }
43739   {
43740     try {
43741       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
43742     } catch (std::out_of_range& e) {
43743       {
43744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43745       };
43746     } catch (std::exception& e) {
43747       {
43748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43749       };
43750     } catch (...) {
43751       {
43752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43753       };
43754     }
43755   }
43756   jresult = (void *)result;
43757   return jresult;
43758 }
43759
43760
43761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
43762   void * jresult ;
43763   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43764   Dali::CameraActor *arg2 = 0 ;
43765   Dali::CameraActor *result = 0 ;
43766
43767   arg1 = (Dali::CameraActor *)jarg1;
43768   arg2 = (Dali::CameraActor *)jarg2;
43769   if (!arg2) {
43770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43771     return 0;
43772   }
43773   {
43774     try {
43775       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
43776     } catch (std::out_of_range& e) {
43777       {
43778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43779       };
43780     } catch (std::exception& e) {
43781       {
43782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43783       };
43784     } catch (...) {
43785       {
43786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43787       };
43788     }
43789   }
43790   jresult = (void *)result;
43791   return jresult;
43792 }
43793
43794
43795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
43796   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43797   Dali::Camera::Type arg2 ;
43798
43799   arg1 = (Dali::CameraActor *)jarg1;
43800   arg2 = (Dali::Camera::Type)jarg2;
43801   {
43802     try {
43803       (arg1)->SetType(arg2);
43804     } catch (std::out_of_range& e) {
43805       {
43806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43807       };
43808     } catch (std::exception& e) {
43809       {
43810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43811       };
43812     } catch (...) {
43813       {
43814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43815       };
43816     }
43817   }
43818 }
43819
43820
43821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
43822   int jresult ;
43823   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43824   Dali::Camera::Type result;
43825
43826   arg1 = (Dali::CameraActor *)jarg1;
43827   {
43828     try {
43829       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
43830     } catch (std::out_of_range& e) {
43831       {
43832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43833       };
43834     } catch (std::exception& e) {
43835       {
43836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43837       };
43838     } catch (...) {
43839       {
43840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43841       };
43842     }
43843   }
43844   jresult = (int)result;
43845   return jresult;
43846 }
43847
43848
43849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
43850   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43851   Dali::Camera::ProjectionMode arg2 ;
43852
43853   arg1 = (Dali::CameraActor *)jarg1;
43854   arg2 = (Dali::Camera::ProjectionMode)jarg2;
43855   {
43856     try {
43857       (arg1)->SetProjectionMode(arg2);
43858     } catch (std::out_of_range& e) {
43859       {
43860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43861       };
43862     } catch (std::exception& e) {
43863       {
43864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43865       };
43866     } catch (...) {
43867       {
43868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43869       };
43870     }
43871   }
43872 }
43873
43874
43875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
43876   int jresult ;
43877   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43878   Dali::Camera::ProjectionMode result;
43879
43880   arg1 = (Dali::CameraActor *)jarg1;
43881   {
43882     try {
43883       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
43884     } catch (std::out_of_range& e) {
43885       {
43886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43887       };
43888     } catch (std::exception& e) {
43889       {
43890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43891       };
43892     } catch (...) {
43893       {
43894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43895       };
43896     }
43897   }
43898   jresult = (int)result;
43899   return jresult;
43900 }
43901
43902
43903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
43904   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43905   float arg2 ;
43906
43907   arg1 = (Dali::CameraActor *)jarg1;
43908   arg2 = (float)jarg2;
43909   {
43910     try {
43911       (arg1)->SetFieldOfView(arg2);
43912     } catch (std::out_of_range& e) {
43913       {
43914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43915       };
43916     } catch (std::exception& e) {
43917       {
43918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43919       };
43920     } catch (...) {
43921       {
43922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43923       };
43924     }
43925   }
43926 }
43927
43928
43929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
43930   float jresult ;
43931   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43932   float result;
43933
43934   arg1 = (Dali::CameraActor *)jarg1;
43935   {
43936     try {
43937       result = (float)(arg1)->GetFieldOfView();
43938     } catch (std::out_of_range& e) {
43939       {
43940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43941       };
43942     } catch (std::exception& e) {
43943       {
43944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43945       };
43946     } catch (...) {
43947       {
43948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43949       };
43950     }
43951   }
43952   jresult = result;
43953   return jresult;
43954 }
43955
43956
43957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
43958   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43959   float arg2 ;
43960
43961   arg1 = (Dali::CameraActor *)jarg1;
43962   arg2 = (float)jarg2;
43963   {
43964     try {
43965       (arg1)->SetAspectRatio(arg2);
43966     } catch (std::out_of_range& e) {
43967       {
43968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43969       };
43970     } catch (std::exception& e) {
43971       {
43972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43973       };
43974     } catch (...) {
43975       {
43976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43977       };
43978     }
43979   }
43980 }
43981
43982
43983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
43984   float jresult ;
43985   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43986   float result;
43987
43988   arg1 = (Dali::CameraActor *)jarg1;
43989   {
43990     try {
43991       result = (float)(arg1)->GetAspectRatio();
43992     } catch (std::out_of_range& e) {
43993       {
43994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43995       };
43996     } catch (std::exception& e) {
43997       {
43998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43999       };
44000     } catch (...) {
44001       {
44002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44003       };
44004     }
44005   }
44006   jresult = result;
44007   return jresult;
44008 }
44009
44010
44011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44012   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44013   float arg2 ;
44014
44015   arg1 = (Dali::CameraActor *)jarg1;
44016   arg2 = (float)jarg2;
44017   {
44018     try {
44019       (arg1)->SetNearClippingPlane(arg2);
44020     } catch (std::out_of_range& e) {
44021       {
44022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44023       };
44024     } catch (std::exception& e) {
44025       {
44026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44027       };
44028     } catch (...) {
44029       {
44030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44031       };
44032     }
44033   }
44034 }
44035
44036
44037 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44038   float jresult ;
44039   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44040   float result;
44041
44042   arg1 = (Dali::CameraActor *)jarg1;
44043   {
44044     try {
44045       result = (float)(arg1)->GetNearClippingPlane();
44046     } catch (std::out_of_range& e) {
44047       {
44048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44049       };
44050     } catch (std::exception& e) {
44051       {
44052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44053       };
44054     } catch (...) {
44055       {
44056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44057       };
44058     }
44059   }
44060   jresult = result;
44061   return jresult;
44062 }
44063
44064
44065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44066   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44067   float arg2 ;
44068
44069   arg1 = (Dali::CameraActor *)jarg1;
44070   arg2 = (float)jarg2;
44071   {
44072     try {
44073       (arg1)->SetFarClippingPlane(arg2);
44074     } catch (std::out_of_range& e) {
44075       {
44076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44077       };
44078     } catch (std::exception& e) {
44079       {
44080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44081       };
44082     } catch (...) {
44083       {
44084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44085       };
44086     }
44087   }
44088 }
44089
44090
44091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44092   float jresult ;
44093   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44094   float result;
44095
44096   arg1 = (Dali::CameraActor *)jarg1;
44097   {
44098     try {
44099       result = (float)(arg1)->GetFarClippingPlane();
44100     } catch (std::out_of_range& e) {
44101       {
44102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44103       };
44104     } catch (std::exception& e) {
44105       {
44106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44107       };
44108     } catch (...) {
44109       {
44110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44111       };
44112     }
44113   }
44114   jresult = result;
44115   return jresult;
44116 }
44117
44118
44119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44120   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44121   Dali::Vector3 *arg2 = 0 ;
44122
44123   arg1 = (Dali::CameraActor *)jarg1;
44124   arg2 = (Dali::Vector3 *)jarg2;
44125   if (!arg2) {
44126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44127     return ;
44128   }
44129   {
44130     try {
44131       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44132     } catch (std::out_of_range& e) {
44133       {
44134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44135       };
44136     } catch (std::exception& e) {
44137       {
44138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44139       };
44140     } catch (...) {
44141       {
44142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44143       };
44144     }
44145   }
44146 }
44147
44148
44149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44150   void * jresult ;
44151   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44152   Dali::Vector3 result;
44153
44154   arg1 = (Dali::CameraActor *)jarg1;
44155   {
44156     try {
44157       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44158     } catch (std::out_of_range& e) {
44159       {
44160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44161       };
44162     } catch (std::exception& e) {
44163       {
44164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44165       };
44166     } catch (...) {
44167       {
44168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44169       };
44170     }
44171   }
44172   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44173   return jresult;
44174 }
44175
44176
44177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44178   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44179   bool arg2 ;
44180
44181   arg1 = (Dali::CameraActor *)jarg1;
44182   arg2 = jarg2 ? true : false;
44183   {
44184     try {
44185       (arg1)->SetInvertYAxis(arg2);
44186     } catch (std::out_of_range& e) {
44187       {
44188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44189       };
44190     } catch (std::exception& e) {
44191       {
44192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44193       };
44194     } catch (...) {
44195       {
44196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44197       };
44198     }
44199   }
44200 }
44201
44202
44203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44204   unsigned int jresult ;
44205   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44206   bool result;
44207
44208   arg1 = (Dali::CameraActor *)jarg1;
44209   {
44210     try {
44211       result = (bool)(arg1)->GetInvertYAxis();
44212     } catch (std::out_of_range& e) {
44213       {
44214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44215       };
44216     } catch (std::exception& e) {
44217       {
44218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44219       };
44220     } catch (...) {
44221       {
44222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44223       };
44224     }
44225   }
44226   jresult = result;
44227   return jresult;
44228 }
44229
44230
44231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44232   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44233   Dali::Size *arg2 = 0 ;
44234
44235   arg1 = (Dali::CameraActor *)jarg1;
44236   arg2 = (Dali::Size *)jarg2;
44237   if (!arg2) {
44238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44239     return ;
44240   }
44241   {
44242     try {
44243       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44244     } catch (std::out_of_range& e) {
44245       {
44246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44247       };
44248     } catch (std::exception& e) {
44249       {
44250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44251       };
44252     } catch (...) {
44253       {
44254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44255       };
44256     }
44257   }
44258 }
44259
44260
44261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44262   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44263   Dali::Size *arg2 = 0 ;
44264
44265   arg1 = (Dali::CameraActor *)jarg1;
44266   arg2 = (Dali::Size *)jarg2;
44267   if (!arg2) {
44268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44269     return ;
44270   }
44271   {
44272     try {
44273       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44274     } catch (std::out_of_range& e) {
44275       {
44276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44277       };
44278     } catch (std::exception& e) {
44279       {
44280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44281       };
44282     } catch (...) {
44283       {
44284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44285       };
44286     }
44287   }
44288 }
44289
44290
44291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44292   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44293   float arg2 ;
44294   float arg3 ;
44295   float arg4 ;
44296   float arg5 ;
44297   float arg6 ;
44298   float arg7 ;
44299
44300   arg1 = (Dali::CameraActor *)jarg1;
44301   arg2 = (float)jarg2;
44302   arg3 = (float)jarg3;
44303   arg4 = (float)jarg4;
44304   arg5 = (float)jarg5;
44305   arg6 = (float)jarg6;
44306   arg7 = (float)jarg7;
44307   {
44308     try {
44309       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44310     } catch (std::out_of_range& e) {
44311       {
44312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44313       };
44314     } catch (std::exception& e) {
44315       {
44316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44317       };
44318     } catch (...) {
44319       {
44320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44321       };
44322     }
44323   }
44324 }
44325
44326
44327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44328   void * jresult ;
44329   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44330
44331   {
44332     try {
44333       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44334     } catch (std::out_of_range& e) {
44335       {
44336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44337       };
44338     } catch (std::exception& e) {
44339       {
44340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44341       };
44342     } catch (...) {
44343       {
44344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44345       };
44346     }
44347   }
44348   jresult = (void *)result;
44349   return jresult;
44350 }
44351
44352
44353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44354   void * jresult ;
44355   std::string arg1 ;
44356   Dali::Property::Value arg2 ;
44357   Dali::Property::Value *argp2 ;
44358   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44359
44360   if (!jarg1) {
44361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44362     return 0;
44363   }
44364   (&arg1)->assign(jarg1);
44365   argp2 = (Dali::Property::Value *)jarg2;
44366   if (!argp2) {
44367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44368     return 0;
44369   }
44370   arg2 = *argp2;
44371   {
44372     try {
44373       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44374     } catch (std::out_of_range& e) {
44375       {
44376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44377       };
44378     } catch (std::exception& e) {
44379       {
44380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44381       };
44382     } catch (...) {
44383       {
44384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44385       };
44386     }
44387   }
44388   jresult = (void *)result;
44389   return jresult;
44390 }
44391
44392
44393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44394   void * jresult ;
44395   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44396   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44397
44398   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44399   if (!arg1) {
44400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44401     return 0;
44402   }
44403   {
44404     try {
44405       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);
44406     } catch (std::out_of_range& e) {
44407       {
44408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44409       };
44410     } catch (std::exception& e) {
44411       {
44412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44413       };
44414     } catch (...) {
44415       {
44416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44417       };
44418     }
44419   }
44420   jresult = (void *)result;
44421   return jresult;
44422 }
44423
44424
44425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44426   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44427   std::string *arg2 = 0 ;
44428
44429   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44430   if (!jarg2) {
44431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44432     return ;
44433   }
44434   std::string arg2_str(jarg2);
44435   arg2 = &arg2_str;
44436   if (arg1) (arg1)->first = *arg2;
44437
44438   //argout typemap for const std::string&
44439
44440 }
44441
44442
44443 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44444   char * jresult ;
44445   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44446   std::string *result = 0 ;
44447
44448   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44449   result = (std::string *) & ((arg1)->first);
44450   jresult = SWIG_csharp_string_callback(result->c_str());
44451   return jresult;
44452 }
44453
44454
44455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44456   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44457   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44458
44459   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44460   arg2 = (Dali::Property::Value *)jarg2;
44461   if (arg1) (arg1)->second = *arg2;
44462 }
44463
44464
44465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44466   void * jresult ;
44467   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44468   Dali::Property::Value *result = 0 ;
44469
44470   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44471   result = (Dali::Property::Value *)& ((arg1)->second);
44472   jresult = (void *)result;
44473   return jresult;
44474 }
44475
44476
44477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44478   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44479
44480   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44481   {
44482     try {
44483       delete arg1;
44484     } catch (std::out_of_range& e) {
44485       {
44486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44487       };
44488     } catch (std::exception& e) {
44489       {
44490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44491       };
44492     } catch (...) {
44493       {
44494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44495       };
44496     }
44497   }
44498 }
44499
44500
44501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44502   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44503
44504   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44505   {
44506     try {
44507       (arg1)->clear();
44508     } catch (std::out_of_range& e) {
44509       {
44510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44511       };
44512     } catch (std::exception& e) {
44513       {
44514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44515       };
44516     } catch (...) {
44517       {
44518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44519       };
44520     }
44521   }
44522 }
44523
44524
44525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44526   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44527   Dali::TouchPoint *arg2 = 0 ;
44528
44529   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44530   arg2 = (Dali::TouchPoint *)jarg2;
44531   if (!arg2) {
44532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44533     return ;
44534   }
44535   {
44536     try {
44537       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44538     } catch (std::out_of_range& e) {
44539       {
44540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44541       };
44542     } catch (std::exception& e) {
44543       {
44544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44545       };
44546     } catch (...) {
44547       {
44548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44549       };
44550     }
44551   }
44552 }
44553
44554
44555 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44556   unsigned long jresult ;
44557   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44558   std::vector< Dali::TouchPoint >::size_type result;
44559
44560   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44561   {
44562     try {
44563       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44564     } catch (std::out_of_range& e) {
44565       {
44566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44567       };
44568     } catch (std::exception& e) {
44569       {
44570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44571       };
44572     } catch (...) {
44573       {
44574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44575       };
44576     }
44577   }
44578   jresult = (unsigned long)result;
44579   return jresult;
44580 }
44581
44582
44583 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44584   unsigned long jresult ;
44585   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44586   std::vector< Dali::TouchPoint >::size_type result;
44587
44588   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44589   {
44590     try {
44591       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44592     } catch (std::out_of_range& e) {
44593       {
44594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44595       };
44596     } catch (std::exception& e) {
44597       {
44598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44599       };
44600     } catch (...) {
44601       {
44602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44603       };
44604     }
44605   }
44606   jresult = (unsigned long)result;
44607   return jresult;
44608 }
44609
44610
44611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44612   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44613   std::vector< Dali::TouchPoint >::size_type arg2 ;
44614
44615   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44616   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44617   {
44618     try {
44619       (arg1)->reserve(arg2);
44620     } catch (std::out_of_range& e) {
44621       {
44622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44623       };
44624     } catch (std::exception& e) {
44625       {
44626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44627       };
44628     } catch (...) {
44629       {
44630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44631       };
44632     }
44633   }
44634 }
44635
44636
44637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44638   void * jresult ;
44639   std::vector< Dali::TouchPoint > *result = 0 ;
44640
44641   {
44642     try {
44643       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44644     } catch (std::out_of_range& e) {
44645       {
44646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44647       };
44648     } catch (std::exception& e) {
44649       {
44650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44651       };
44652     } catch (...) {
44653       {
44654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44655       };
44656     }
44657   }
44658   jresult = (void *)result;
44659   return jresult;
44660 }
44661
44662
44663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
44664   void * jresult ;
44665   std::vector< Dali::TouchPoint > *arg1 = 0 ;
44666   std::vector< Dali::TouchPoint > *result = 0 ;
44667
44668   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44669   if (!arg1) {
44670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44671     return 0;
44672   }
44673   {
44674     try {
44675       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
44676     } catch (std::out_of_range& e) {
44677       {
44678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44679       };
44680     } catch (std::exception& e) {
44681       {
44682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44683       };
44684     } catch (...) {
44685       {
44686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44687       };
44688     }
44689   }
44690   jresult = (void *)result;
44691   return jresult;
44692 }
44693
44694
44695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
44696   void * jresult ;
44697   int arg1 ;
44698   std::vector< Dali::TouchPoint > *result = 0 ;
44699
44700   arg1 = (int)jarg1;
44701   {
44702     try {
44703       try {
44704         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
44705       }
44706       catch(std::out_of_range &_e) {
44707         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44708         return 0;
44709       }
44710
44711     } catch (std::out_of_range& e) {
44712       {
44713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44714       };
44715     } catch (std::exception& e) {
44716       {
44717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44718       };
44719     } catch (...) {
44720       {
44721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44722       };
44723     }
44724   }
44725   jresult = (void *)result;
44726   return jresult;
44727 }
44728
44729
44730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
44731   void * jresult ;
44732   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44733   int arg2 ;
44734   SwigValueWrapper< Dali::TouchPoint > result;
44735
44736   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44737   arg2 = (int)jarg2;
44738   {
44739     try {
44740       try {
44741         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
44742       }
44743       catch(std::out_of_range &_e) {
44744         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44745         return 0;
44746       }
44747
44748     } catch (std::out_of_range& e) {
44749       {
44750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44751       };
44752     } catch (std::exception& e) {
44753       {
44754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44755       };
44756     } catch (...) {
44757       {
44758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44759       };
44760     }
44761   }
44762   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
44763   return jresult;
44764 }
44765
44766
44767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
44768   void * jresult ;
44769   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44770   int arg2 ;
44771   Dali::TouchPoint *result = 0 ;
44772
44773   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44774   arg2 = (int)jarg2;
44775   {
44776     try {
44777       try {
44778         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
44779       }
44780       catch(std::out_of_range &_e) {
44781         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44782         return 0;
44783       }
44784
44785     } catch (std::out_of_range& e) {
44786       {
44787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44788       };
44789     } catch (std::exception& e) {
44790       {
44791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44792       };
44793     } catch (...) {
44794       {
44795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44796       };
44797     }
44798   }
44799   jresult = (void *)result;
44800   return jresult;
44801 }
44802
44803
44804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
44805   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44806   int arg2 ;
44807   Dali::TouchPoint *arg3 = 0 ;
44808
44809   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44810   arg2 = (int)jarg2;
44811   arg3 = (Dali::TouchPoint *)jarg3;
44812   if (!arg3) {
44813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44814     return ;
44815   }
44816   {
44817     try {
44818       try {
44819         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
44820       }
44821       catch(std::out_of_range &_e) {
44822         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44823         return ;
44824       }
44825
44826     } catch (std::out_of_range& e) {
44827       {
44828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44829       };
44830     } catch (std::exception& e) {
44831       {
44832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44833       };
44834     } catch (...) {
44835       {
44836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44837       };
44838     }
44839   }
44840 }
44841
44842
44843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
44844   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44845   std::vector< Dali::TouchPoint > *arg2 = 0 ;
44846
44847   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44848   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
44849   if (!arg2) {
44850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44851     return ;
44852   }
44853   {
44854     try {
44855       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
44856     } catch (std::out_of_range& e) {
44857       {
44858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44859       };
44860     } catch (std::exception& e) {
44861       {
44862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44863       };
44864     } catch (...) {
44865       {
44866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44867       };
44868     }
44869   }
44870 }
44871
44872
44873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
44874   void * jresult ;
44875   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44876   int arg2 ;
44877   int arg3 ;
44878   std::vector< Dali::TouchPoint > *result = 0 ;
44879
44880   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44881   arg2 = (int)jarg2;
44882   arg3 = (int)jarg3;
44883   {
44884     try {
44885       try {
44886         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
44887       }
44888       catch(std::out_of_range &_e) {
44889         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44890         return 0;
44891       }
44892       catch(std::invalid_argument &_e) {
44893         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
44894         return 0;
44895       }
44896
44897     } catch (std::out_of_range& e) {
44898       {
44899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44900       };
44901     } catch (std::exception& e) {
44902       {
44903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44904       };
44905     } catch (...) {
44906       {
44907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44908       };
44909     }
44910   }
44911   jresult = (void *)result;
44912   return jresult;
44913 }
44914
44915
44916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
44917   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44918   int arg2 ;
44919   Dali::TouchPoint *arg3 = 0 ;
44920
44921   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44922   arg2 = (int)jarg2;
44923   arg3 = (Dali::TouchPoint *)jarg3;
44924   if (!arg3) {
44925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44926     return ;
44927   }
44928   {
44929     try {
44930       try {
44931         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
44932       }
44933       catch(std::out_of_range &_e) {
44934         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44935         return ;
44936       }
44937
44938     } catch (std::out_of_range& e) {
44939       {
44940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44941       };
44942     } catch (std::exception& e) {
44943       {
44944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44945       };
44946     } catch (...) {
44947       {
44948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44949       };
44950     }
44951   }
44952 }
44953
44954
44955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
44956   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44957   int arg2 ;
44958   std::vector< Dali::TouchPoint > *arg3 = 0 ;
44959
44960   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44961   arg2 = (int)jarg2;
44962   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
44963   if (!arg3) {
44964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44965     return ;
44966   }
44967   {
44968     try {
44969       try {
44970         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
44971       }
44972       catch(std::out_of_range &_e) {
44973         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44974         return ;
44975       }
44976
44977     } catch (std::out_of_range& e) {
44978       {
44979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44980       };
44981     } catch (std::exception& e) {
44982       {
44983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44984       };
44985     } catch (...) {
44986       {
44987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44988       };
44989     }
44990   }
44991 }
44992
44993
44994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
44995   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44996   int arg2 ;
44997
44998   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44999   arg2 = (int)jarg2;
45000   {
45001     try {
45002       try {
45003         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45004       }
45005       catch(std::out_of_range &_e) {
45006         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45007         return ;
45008       }
45009
45010     } catch (std::out_of_range& e) {
45011       {
45012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45013       };
45014     } catch (std::exception& e) {
45015       {
45016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45017       };
45018     } catch (...) {
45019       {
45020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45021       };
45022     }
45023   }
45024 }
45025
45026
45027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45028   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45029   int arg2 ;
45030   int arg3 ;
45031
45032   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45033   arg2 = (int)jarg2;
45034   arg3 = (int)jarg3;
45035   {
45036     try {
45037       try {
45038         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45039       }
45040       catch(std::out_of_range &_e) {
45041         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45042         return ;
45043       }
45044       catch(std::invalid_argument &_e) {
45045         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45046         return ;
45047       }
45048
45049     } catch (std::out_of_range& e) {
45050       {
45051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45052       };
45053     } catch (std::exception& e) {
45054       {
45055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45056       };
45057     } catch (...) {
45058       {
45059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45060       };
45061     }
45062   }
45063 }
45064
45065
45066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45067   void * jresult ;
45068   Dali::TouchPoint *arg1 = 0 ;
45069   int arg2 ;
45070   std::vector< Dali::TouchPoint > *result = 0 ;
45071
45072   arg1 = (Dali::TouchPoint *)jarg1;
45073   if (!arg1) {
45074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45075     return 0;
45076   }
45077   arg2 = (int)jarg2;
45078   {
45079     try {
45080       try {
45081         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45082       }
45083       catch(std::out_of_range &_e) {
45084         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45085         return 0;
45086       }
45087
45088     } catch (std::out_of_range& e) {
45089       {
45090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45091       };
45092     } catch (std::exception& e) {
45093       {
45094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45095       };
45096     } catch (...) {
45097       {
45098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45099       };
45100     }
45101   }
45102   jresult = (void *)result;
45103   return jresult;
45104 }
45105
45106
45107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45108   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45109
45110   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45111   {
45112     try {
45113       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45114     } catch (std::out_of_range& e) {
45115       {
45116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45117       };
45118     } catch (std::exception& e) {
45119       {
45120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45121       };
45122     } catch (...) {
45123       {
45124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45125       };
45126     }
45127   }
45128 }
45129
45130
45131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45132   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45133   int arg2 ;
45134   int arg3 ;
45135
45136   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45137   arg2 = (int)jarg2;
45138   arg3 = (int)jarg3;
45139   {
45140     try {
45141       try {
45142         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45143       }
45144       catch(std::out_of_range &_e) {
45145         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45146         return ;
45147       }
45148       catch(std::invalid_argument &_e) {
45149         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45150         return ;
45151       }
45152
45153     } catch (std::out_of_range& e) {
45154       {
45155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45156       };
45157     } catch (std::exception& e) {
45158       {
45159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45160       };
45161     } catch (...) {
45162       {
45163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45164       };
45165     }
45166   }
45167 }
45168
45169
45170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45171   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45172   int arg2 ;
45173   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45174
45175   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45176   arg2 = (int)jarg2;
45177   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45178   if (!arg3) {
45179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45180     return ;
45181   }
45182   {
45183     try {
45184       try {
45185         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45186       }
45187       catch(std::out_of_range &_e) {
45188         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45189         return ;
45190       }
45191
45192     } catch (std::out_of_range& e) {
45193       {
45194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45195       };
45196     } catch (std::exception& e) {
45197       {
45198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45199       };
45200     } catch (...) {
45201       {
45202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45203       };
45204     }
45205   }
45206 }
45207
45208
45209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45210   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45211
45212   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45213   {
45214     try {
45215       delete arg1;
45216     } catch (std::out_of_range& e) {
45217       {
45218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45219       };
45220     } catch (std::exception& e) {
45221       {
45222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45223       };
45224     } catch (...) {
45225       {
45226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45227       };
45228     }
45229   }
45230 }
45231
45232
45233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectDouble__SWIG_0() {
45234   void * jresult ;
45235   Dali::Rect< double > *result = 0 ;
45236
45237   {
45238     try {
45239       result = (Dali::Rect< double > *)new Dali::Rect< double >();
45240     } catch (std::out_of_range& e) {
45241       {
45242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45243       };
45244     } catch (std::exception& e) {
45245       {
45246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45247       };
45248     } catch (...) {
45249       {
45250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45251       };
45252     }
45253   }
45254   jresult = (void *)result;
45255   return jresult;
45256 }
45257
45258
45259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectDouble__SWIG_1(double jarg1, double jarg2, double jarg3, double jarg4) {
45260   void * jresult ;
45261   double arg1 ;
45262   double arg2 ;
45263   double arg3 ;
45264   double arg4 ;
45265   Dali::Rect< double > *result = 0 ;
45266
45267   arg1 = (double)jarg1;
45268   arg2 = (double)jarg2;
45269   arg3 = (double)jarg3;
45270   arg4 = (double)jarg4;
45271   {
45272     try {
45273       result = (Dali::Rect< double > *)new Dali::Rect< double >(arg1,arg2,arg3,arg4);
45274     } catch (std::out_of_range& e) {
45275       {
45276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45277       };
45278     } catch (std::exception& e) {
45279       {
45280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45281       };
45282     } catch (...) {
45283       {
45284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45285       };
45286     }
45287   }
45288   jresult = (void *)result;
45289   return jresult;
45290 }
45291
45292
45293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectDouble__SWIG_2(void * jarg1) {
45294   void * jresult ;
45295   Dali::Rect< double > *arg1 = 0 ;
45296   Dali::Rect< double > *result = 0 ;
45297
45298   arg1 = (Dali::Rect< double > *)jarg1;
45299   if (!arg1) {
45300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
45301     return 0;
45302   }
45303   {
45304     try {
45305       result = (Dali::Rect< double > *)new Dali::Rect< double >((Dali::Rect< double > const &)*arg1);
45306     } catch (std::out_of_range& e) {
45307       {
45308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45309       };
45310     } catch (std::exception& e) {
45311       {
45312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45313       };
45314     } catch (...) {
45315       {
45316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45317       };
45318     }
45319   }
45320   jresult = (void *)result;
45321   return jresult;
45322 }
45323
45324
45325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RectDouble_Assign(void * jarg1, void * jarg2) {
45326   void * jresult ;
45327   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45328   Dali::Rect< double > *arg2 = 0 ;
45329   Dali::Rect< double > *result = 0 ;
45330
45331   arg1 = (Dali::Rect< double > *)jarg1;
45332   arg2 = (Dali::Rect< double > *)jarg2;
45333   if (!arg2) {
45334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
45335     return 0;
45336   }
45337   {
45338     try {
45339       result = (Dali::Rect< double > *) &(arg1)->operator =((Dali::Rect< double > const &)*arg2);
45340     } catch (std::out_of_range& e) {
45341       {
45342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45343       };
45344     } catch (std::exception& e) {
45345       {
45346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45347       };
45348     } catch (...) {
45349       {
45350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45351       };
45352     }
45353   }
45354   jresult = (void *)result;
45355   return jresult;
45356 }
45357
45358
45359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_Set(void * jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
45360   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45361   double arg2 ;
45362   double arg3 ;
45363   double arg4 ;
45364   double arg5 ;
45365
45366   arg1 = (Dali::Rect< double > *)jarg1;
45367   arg2 = (double)jarg2;
45368   arg3 = (double)jarg3;
45369   arg4 = (double)jarg4;
45370   arg5 = (double)jarg5;
45371   {
45372     try {
45373       (arg1)->Set(arg2,arg3,arg4,arg5);
45374     } catch (std::out_of_range& e) {
45375       {
45376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45377       };
45378     } catch (std::exception& e) {
45379       {
45380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45381       };
45382     } catch (...) {
45383       {
45384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45385       };
45386     }
45387   }
45388 }
45389
45390
45391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectDouble_IsEmpty(void * jarg1) {
45392   unsigned int jresult ;
45393   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45394   bool result;
45395
45396   arg1 = (Dali::Rect< double > *)jarg1;
45397   {
45398     try {
45399       result = (bool)((Dali::Rect< double > const *)arg1)->IsEmpty();
45400     } catch (std::out_of_range& e) {
45401       {
45402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45403       };
45404     } catch (std::exception& e) {
45405       {
45406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45407       };
45408     } catch (...) {
45409       {
45410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45411       };
45412     }
45413   }
45414   jresult = result;
45415   return jresult;
45416 }
45417
45418
45419 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_Left(void * jarg1) {
45420   double jresult ;
45421   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45422   double result;
45423
45424   arg1 = (Dali::Rect< double > *)jarg1;
45425   {
45426     try {
45427       result = (double)((Dali::Rect< double > const *)arg1)->Left();
45428     } catch (std::out_of_range& e) {
45429       {
45430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45431       };
45432     } catch (std::exception& e) {
45433       {
45434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45435       };
45436     } catch (...) {
45437       {
45438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45439       };
45440     }
45441   }
45442   jresult = result;
45443   return jresult;
45444 }
45445
45446
45447 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_Right(void * jarg1) {
45448   double jresult ;
45449   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45450   double result;
45451
45452   arg1 = (Dali::Rect< double > *)jarg1;
45453   {
45454     try {
45455       result = (double)((Dali::Rect< double > const *)arg1)->Right();
45456     } catch (std::out_of_range& e) {
45457       {
45458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45459       };
45460     } catch (std::exception& e) {
45461       {
45462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45463       };
45464     } catch (...) {
45465       {
45466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45467       };
45468     }
45469   }
45470   jresult = result;
45471   return jresult;
45472 }
45473
45474
45475 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_Top(void * jarg1) {
45476   double jresult ;
45477   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45478   double result;
45479
45480   arg1 = (Dali::Rect< double > *)jarg1;
45481   {
45482     try {
45483       result = (double)((Dali::Rect< double > const *)arg1)->Top();
45484     } catch (std::out_of_range& e) {
45485       {
45486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45487       };
45488     } catch (std::exception& e) {
45489       {
45490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45491       };
45492     } catch (...) {
45493       {
45494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45495       };
45496     }
45497   }
45498   jresult = result;
45499   return jresult;
45500 }
45501
45502
45503 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_Bottom(void * jarg1) {
45504   double jresult ;
45505   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45506   double result;
45507
45508   arg1 = (Dali::Rect< double > *)jarg1;
45509   {
45510     try {
45511       result = (double)((Dali::Rect< double > const *)arg1)->Bottom();
45512     } catch (std::out_of_range& e) {
45513       {
45514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45515       };
45516     } catch (std::exception& e) {
45517       {
45518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45519       };
45520     } catch (...) {
45521       {
45522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45523       };
45524     }
45525   }
45526   jresult = result;
45527   return jresult;
45528 }
45529
45530
45531 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_Area(void * jarg1) {
45532   double jresult ;
45533   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45534   double result;
45535
45536   arg1 = (Dali::Rect< double > *)jarg1;
45537   {
45538     try {
45539       result = (double)((Dali::Rect< double > const *)arg1)->Area();
45540     } catch (std::out_of_range& e) {
45541       {
45542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45543       };
45544     } catch (std::exception& e) {
45545       {
45546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45547       };
45548     } catch (...) {
45549       {
45550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45551       };
45552     }
45553   }
45554   jresult = result;
45555   return jresult;
45556 }
45557
45558
45559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectDouble_Intersects(void * jarg1, void * jarg2) {
45560   unsigned int jresult ;
45561   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45562   Dali::Rect< double > *arg2 = 0 ;
45563   bool result;
45564
45565   arg1 = (Dali::Rect< double > *)jarg1;
45566   arg2 = (Dali::Rect< double > *)jarg2;
45567   if (!arg2) {
45568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
45569     return 0;
45570   }
45571   {
45572     try {
45573       result = (bool)((Dali::Rect< double > const *)arg1)->Intersects((Dali::Rect< double > const &)*arg2);
45574     } catch (std::out_of_range& e) {
45575       {
45576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45577       };
45578     } catch (std::exception& e) {
45579       {
45580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45581       };
45582     } catch (...) {
45583       {
45584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45585       };
45586     }
45587   }
45588   jresult = result;
45589   return jresult;
45590 }
45591
45592
45593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectDouble_Contains(void * jarg1, void * jarg2) {
45594   unsigned int jresult ;
45595   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45596   Dali::Rect< double > *arg2 = 0 ;
45597   bool result;
45598
45599   arg1 = (Dali::Rect< double > *)jarg1;
45600   arg2 = (Dali::Rect< double > *)jarg2;
45601   if (!arg2) {
45602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< double > const & type is null", 0);
45603     return 0;
45604   }
45605   {
45606     try {
45607       result = (bool)((Dali::Rect< double > const *)arg1)->Contains((Dali::Rect< double > const &)*arg2);
45608     } catch (std::out_of_range& e) {
45609       {
45610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45611       };
45612     } catch (std::exception& e) {
45613       {
45614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45615       };
45616     } catch (...) {
45617       {
45618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45619       };
45620     }
45621   }
45622   jresult = result;
45623   return jresult;
45624 }
45625
45626
45627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_x_set(void * jarg1, double jarg2) {
45628   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45629   double arg2 ;
45630
45631   arg1 = (Dali::Rect< double > *)jarg1;
45632   arg2 = (double)jarg2;
45633   if (arg1) (arg1)->x = arg2;
45634 }
45635
45636
45637 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_x_get(void * jarg1) {
45638   double jresult ;
45639   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45640   double result;
45641
45642   arg1 = (Dali::Rect< double > *)jarg1;
45643   result = (double) ((arg1)->x);
45644   jresult = result;
45645   return jresult;
45646 }
45647
45648
45649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_left_set(void * jarg1, double jarg2) {
45650   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45651   double arg2 ;
45652
45653   arg1 = (Dali::Rect< double > *)jarg1;
45654   arg2 = (double)jarg2;
45655   if (arg1) (arg1)->left = arg2;
45656 }
45657
45658
45659 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_left_get(void * jarg1) {
45660   double jresult ;
45661   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45662   double result;
45663
45664   arg1 = (Dali::Rect< double > *)jarg1;
45665   result = (double) ((arg1)->left);
45666   jresult = result;
45667   return jresult;
45668 }
45669
45670
45671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_y_set(void * jarg1, double jarg2) {
45672   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45673   double arg2 ;
45674
45675   arg1 = (Dali::Rect< double > *)jarg1;
45676   arg2 = (double)jarg2;
45677   if (arg1) (arg1)->y = arg2;
45678 }
45679
45680
45681 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_y_get(void * jarg1) {
45682   double jresult ;
45683   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45684   double result;
45685
45686   arg1 = (Dali::Rect< double > *)jarg1;
45687   result = (double) ((arg1)->y);
45688   jresult = result;
45689   return jresult;
45690 }
45691
45692
45693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_right_set(void * jarg1, double jarg2) {
45694   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45695   double arg2 ;
45696
45697   arg1 = (Dali::Rect< double > *)jarg1;
45698   arg2 = (double)jarg2;
45699   if (arg1) (arg1)->right = arg2;
45700 }
45701
45702
45703 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_right_get(void * jarg1) {
45704   double jresult ;
45705   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45706   double result;
45707
45708   arg1 = (Dali::Rect< double > *)jarg1;
45709   result = (double) ((arg1)->right);
45710   jresult = result;
45711   return jresult;
45712 }
45713
45714
45715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_width_set(void * jarg1, double jarg2) {
45716   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45717   double arg2 ;
45718
45719   arg1 = (Dali::Rect< double > *)jarg1;
45720   arg2 = (double)jarg2;
45721   if (arg1) (arg1)->width = arg2;
45722 }
45723
45724
45725 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_width_get(void * jarg1) {
45726   double jresult ;
45727   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45728   double result;
45729
45730   arg1 = (Dali::Rect< double > *)jarg1;
45731   result = (double) ((arg1)->width);
45732   jresult = result;
45733   return jresult;
45734 }
45735
45736
45737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_bottom_set(void * jarg1, double jarg2) {
45738   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45739   double arg2 ;
45740
45741   arg1 = (Dali::Rect< double > *)jarg1;
45742   arg2 = (double)jarg2;
45743   if (arg1) (arg1)->bottom = arg2;
45744 }
45745
45746
45747 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_bottom_get(void * jarg1) {
45748   double jresult ;
45749   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45750   double result;
45751
45752   arg1 = (Dali::Rect< double > *)jarg1;
45753   result = (double) ((arg1)->bottom);
45754   jresult = result;
45755   return jresult;
45756 }
45757
45758
45759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_height_set(void * jarg1, double jarg2) {
45760   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45761   double arg2 ;
45762
45763   arg1 = (Dali::Rect< double > *)jarg1;
45764   arg2 = (double)jarg2;
45765   if (arg1) (arg1)->height = arg2;
45766 }
45767
45768
45769 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_height_get(void * jarg1) {
45770   double jresult ;
45771   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45772   double result;
45773
45774   arg1 = (Dali::Rect< double > *)jarg1;
45775   result = (double) ((arg1)->height);
45776   jresult = result;
45777   return jresult;
45778 }
45779
45780
45781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectDouble_top_set(void * jarg1, double jarg2) {
45782   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45783   double arg2 ;
45784
45785   arg1 = (Dali::Rect< double > *)jarg1;
45786   arg2 = (double)jarg2;
45787   if (arg1) (arg1)->top = arg2;
45788 }
45789
45790
45791 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_RectDouble_top_get(void * jarg1) {
45792   double jresult ;
45793   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45794   double result;
45795
45796   arg1 = (Dali::Rect< double > *)jarg1;
45797   result = (double) ((arg1)->top);
45798   jresult = result;
45799   return jresult;
45800 }
45801
45802
45803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RectDouble(void * jarg1) {
45804   Dali::Rect< double > *arg1 = (Dali::Rect< double > *) 0 ;
45805
45806   arg1 = (Dali::Rect< double > *)jarg1;
45807   {
45808     try {
45809       delete arg1;
45810     } catch (std::out_of_range& e) {
45811       {
45812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45813       };
45814     } catch (std::exception& e) {
45815       {
45816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45817       };
45818     } catch (...) {
45819       {
45820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45821       };
45822     }
45823   }
45824 }
45825
45826
45827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectInteger__SWIG_0() {
45828   void * jresult ;
45829   Dali::Rect< int > *result = 0 ;
45830
45831   {
45832     try {
45833       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45834     } catch (std::out_of_range& e) {
45835       {
45836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45837       };
45838     } catch (std::exception& e) {
45839       {
45840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45841       };
45842     } catch (...) {
45843       {
45844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45845       };
45846     }
45847   }
45848   jresult = (void *)result;
45849   return jresult;
45850 }
45851
45852
45853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectInteger__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45854   void * jresult ;
45855   int arg1 ;
45856   int arg2 ;
45857   int arg3 ;
45858   int arg4 ;
45859   Dali::Rect< int > *result = 0 ;
45860
45861   arg1 = (int)jarg1;
45862   arg2 = (int)jarg2;
45863   arg3 = (int)jarg3;
45864   arg4 = (int)jarg4;
45865   {
45866     try {
45867       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45868     } catch (std::out_of_range& e) {
45869       {
45870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45871       };
45872     } catch (std::exception& e) {
45873       {
45874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45875       };
45876     } catch (...) {
45877       {
45878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45879       };
45880     }
45881   }
45882   jresult = (void *)result;
45883   return jresult;
45884 }
45885
45886
45887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectInteger__SWIG_2(void * jarg1) {
45888   void * jresult ;
45889   Dali::Rect< int > *arg1 = 0 ;
45890   Dali::Rect< int > *result = 0 ;
45891
45892   arg1 = (Dali::Rect< int > *)jarg1;
45893   if (!arg1) {
45894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45895     return 0;
45896   }
45897   {
45898     try {
45899       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45900     } catch (std::out_of_range& e) {
45901       {
45902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45903       };
45904     } catch (std::exception& e) {
45905       {
45906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45907       };
45908     } catch (...) {
45909       {
45910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45911       };
45912     }
45913   }
45914   jresult = (void *)result;
45915   return jresult;
45916 }
45917
45918
45919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RectInteger_Assign(void * jarg1, void * jarg2) {
45920   void * jresult ;
45921   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45922   Dali::Rect< int > *arg2 = 0 ;
45923   Dali::Rect< int > *result = 0 ;
45924
45925   arg1 = (Dali::Rect< int > *)jarg1;
45926   arg2 = (Dali::Rect< int > *)jarg2;
45927   if (!arg2) {
45928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45929     return 0;
45930   }
45931   {
45932     try {
45933       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45934     } catch (std::out_of_range& e) {
45935       {
45936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45937       };
45938     } catch (std::exception& e) {
45939       {
45940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45941       };
45942     } catch (...) {
45943       {
45944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45945       };
45946     }
45947   }
45948   jresult = (void *)result;
45949   return jresult;
45950 }
45951
45952
45953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45954   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45955   int arg2 ;
45956   int arg3 ;
45957   int arg4 ;
45958   int arg5 ;
45959
45960   arg1 = (Dali::Rect< int > *)jarg1;
45961   arg2 = (int)jarg2;
45962   arg3 = (int)jarg3;
45963   arg4 = (int)jarg4;
45964   arg5 = (int)jarg5;
45965   {
45966     try {
45967       (arg1)->Set(arg2,arg3,arg4,arg5);
45968     } catch (std::out_of_range& e) {
45969       {
45970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45971       };
45972     } catch (std::exception& e) {
45973       {
45974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45975       };
45976     } catch (...) {
45977       {
45978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45979       };
45980     }
45981   }
45982 }
45983
45984
45985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectInteger_IsEmpty(void * jarg1) {
45986   unsigned int jresult ;
45987   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45988   bool result;
45989
45990   arg1 = (Dali::Rect< int > *)jarg1;
45991   {
45992     try {
45993       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45994     } catch (std::out_of_range& e) {
45995       {
45996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45997       };
45998     } catch (std::exception& e) {
45999       {
46000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46001       };
46002     } catch (...) {
46003       {
46004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46005       };
46006     }
46007   }
46008   jresult = result;
46009   return jresult;
46010 }
46011
46012
46013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_Left(void * jarg1) {
46014   int jresult ;
46015   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46016   int result;
46017
46018   arg1 = (Dali::Rect< int > *)jarg1;
46019   {
46020     try {
46021       result = (int)((Dali::Rect< int > const *)arg1)->Left();
46022     } catch (std::out_of_range& e) {
46023       {
46024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46025       };
46026     } catch (std::exception& e) {
46027       {
46028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46029       };
46030     } catch (...) {
46031       {
46032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46033       };
46034     }
46035   }
46036   jresult = result;
46037   return jresult;
46038 }
46039
46040
46041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_Right(void * jarg1) {
46042   int jresult ;
46043   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46044   int result;
46045
46046   arg1 = (Dali::Rect< int > *)jarg1;
46047   {
46048     try {
46049       result = (int)((Dali::Rect< int > const *)arg1)->Right();
46050     } catch (std::out_of_range& e) {
46051       {
46052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46053       };
46054     } catch (std::exception& e) {
46055       {
46056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46057       };
46058     } catch (...) {
46059       {
46060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46061       };
46062     }
46063   }
46064   jresult = result;
46065   return jresult;
46066 }
46067
46068
46069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_Top(void * jarg1) {
46070   int jresult ;
46071   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46072   int result;
46073
46074   arg1 = (Dali::Rect< int > *)jarg1;
46075   {
46076     try {
46077       result = (int)((Dali::Rect< int > const *)arg1)->Top();
46078     } catch (std::out_of_range& e) {
46079       {
46080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46081       };
46082     } catch (std::exception& e) {
46083       {
46084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46085       };
46086     } catch (...) {
46087       {
46088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46089       };
46090     }
46091   }
46092   jresult = result;
46093   return jresult;
46094 }
46095
46096
46097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_Bottom(void * jarg1) {
46098   int jresult ;
46099   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46100   int result;
46101
46102   arg1 = (Dali::Rect< int > *)jarg1;
46103   {
46104     try {
46105       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
46106     } catch (std::out_of_range& e) {
46107       {
46108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46109       };
46110     } catch (std::exception& e) {
46111       {
46112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46113       };
46114     } catch (...) {
46115       {
46116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46117       };
46118     }
46119   }
46120   jresult = result;
46121   return jresult;
46122 }
46123
46124
46125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_Area(void * jarg1) {
46126   int jresult ;
46127   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46128   int result;
46129
46130   arg1 = (Dali::Rect< int > *)jarg1;
46131   {
46132     try {
46133       result = (int)((Dali::Rect< int > const *)arg1)->Area();
46134     } catch (std::out_of_range& e) {
46135       {
46136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46137       };
46138     } catch (std::exception& e) {
46139       {
46140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46141       };
46142     } catch (...) {
46143       {
46144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46145       };
46146     }
46147   }
46148   jresult = result;
46149   return jresult;
46150 }
46151
46152
46153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectInteger_Intersects(void * jarg1, void * jarg2) {
46154   unsigned int jresult ;
46155   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46156   Dali::Rect< int > *arg2 = 0 ;
46157   bool result;
46158
46159   arg1 = (Dali::Rect< int > *)jarg1;
46160   arg2 = (Dali::Rect< int > *)jarg2;
46161   if (!arg2) {
46162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46163     return 0;
46164   }
46165   {
46166     try {
46167       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
46168     } catch (std::out_of_range& e) {
46169       {
46170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46171       };
46172     } catch (std::exception& e) {
46173       {
46174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46175       };
46176     } catch (...) {
46177       {
46178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46179       };
46180     }
46181   }
46182   jresult = result;
46183   return jresult;
46184 }
46185
46186
46187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectInteger_Contains(void * jarg1, void * jarg2) {
46188   unsigned int jresult ;
46189   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46190   Dali::Rect< int > *arg2 = 0 ;
46191   bool result;
46192
46193   arg1 = (Dali::Rect< int > *)jarg1;
46194   arg2 = (Dali::Rect< int > *)jarg2;
46195   if (!arg2) {
46196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46197     return 0;
46198   }
46199   {
46200     try {
46201       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
46202     } catch (std::out_of_range& e) {
46203       {
46204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46205       };
46206     } catch (std::exception& e) {
46207       {
46208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46209       };
46210     } catch (...) {
46211       {
46212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46213       };
46214     }
46215   }
46216   jresult = result;
46217   return jresult;
46218 }
46219
46220
46221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_x_set(void * jarg1, int jarg2) {
46222   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46223   int arg2 ;
46224
46225   arg1 = (Dali::Rect< int > *)jarg1;
46226   arg2 = (int)jarg2;
46227   if (arg1) (arg1)->x = arg2;
46228 }
46229
46230
46231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_x_get(void * jarg1) {
46232   int jresult ;
46233   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46234   int result;
46235
46236   arg1 = (Dali::Rect< int > *)jarg1;
46237   result = (int) ((arg1)->x);
46238   jresult = result;
46239   return jresult;
46240 }
46241
46242
46243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_left_set(void * jarg1, int jarg2) {
46244   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46245   int arg2 ;
46246
46247   arg1 = (Dali::Rect< int > *)jarg1;
46248   arg2 = (int)jarg2;
46249   if (arg1) (arg1)->left = arg2;
46250 }
46251
46252
46253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_left_get(void * jarg1) {
46254   int jresult ;
46255   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46256   int result;
46257
46258   arg1 = (Dali::Rect< int > *)jarg1;
46259   result = (int) ((arg1)->left);
46260   jresult = result;
46261   return jresult;
46262 }
46263
46264
46265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_y_set(void * jarg1, int jarg2) {
46266   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46267   int arg2 ;
46268
46269   arg1 = (Dali::Rect< int > *)jarg1;
46270   arg2 = (int)jarg2;
46271   if (arg1) (arg1)->y = arg2;
46272 }
46273
46274
46275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_y_get(void * jarg1) {
46276   int jresult ;
46277   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46278   int result;
46279
46280   arg1 = (Dali::Rect< int > *)jarg1;
46281   result = (int) ((arg1)->y);
46282   jresult = result;
46283   return jresult;
46284 }
46285
46286
46287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_right_set(void * jarg1, int jarg2) {
46288   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46289   int arg2 ;
46290
46291   arg1 = (Dali::Rect< int > *)jarg1;
46292   arg2 = (int)jarg2;
46293   if (arg1) (arg1)->right = arg2;
46294 }
46295
46296
46297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_right_get(void * jarg1) {
46298   int jresult ;
46299   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46300   int result;
46301
46302   arg1 = (Dali::Rect< int > *)jarg1;
46303   result = (int) ((arg1)->right);
46304   jresult = result;
46305   return jresult;
46306 }
46307
46308
46309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_width_set(void * jarg1, int jarg2) {
46310   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46311   int arg2 ;
46312
46313   arg1 = (Dali::Rect< int > *)jarg1;
46314   arg2 = (int)jarg2;
46315   if (arg1) (arg1)->width = arg2;
46316 }
46317
46318
46319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_width_get(void * jarg1) {
46320   int jresult ;
46321   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46322   int result;
46323
46324   arg1 = (Dali::Rect< int > *)jarg1;
46325   result = (int) ((arg1)->width);
46326   jresult = result;
46327   return jresult;
46328 }
46329
46330
46331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_bottom_set(void * jarg1, int jarg2) {
46332   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46333   int arg2 ;
46334
46335   arg1 = (Dali::Rect< int > *)jarg1;
46336   arg2 = (int)jarg2;
46337   if (arg1) (arg1)->bottom = arg2;
46338 }
46339
46340
46341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_bottom_get(void * jarg1) {
46342   int jresult ;
46343   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46344   int result;
46345
46346   arg1 = (Dali::Rect< int > *)jarg1;
46347   result = (int) ((arg1)->bottom);
46348   jresult = result;
46349   return jresult;
46350 }
46351
46352
46353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_height_set(void * jarg1, int jarg2) {
46354   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46355   int arg2 ;
46356
46357   arg1 = (Dali::Rect< int > *)jarg1;
46358   arg2 = (int)jarg2;
46359   if (arg1) (arg1)->height = arg2;
46360 }
46361
46362
46363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_height_get(void * jarg1) {
46364   int jresult ;
46365   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46366   int result;
46367
46368   arg1 = (Dali::Rect< int > *)jarg1;
46369   result = (int) ((arg1)->height);
46370   jresult = result;
46371   return jresult;
46372 }
46373
46374
46375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectInteger_top_set(void * jarg1, int jarg2) {
46376   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46377   int arg2 ;
46378
46379   arg1 = (Dali::Rect< int > *)jarg1;
46380   arg2 = (int)jarg2;
46381   if (arg1) (arg1)->top = arg2;
46382 }
46383
46384
46385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RectInteger_top_get(void * jarg1) {
46386   int jresult ;
46387   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46388   int result;
46389
46390   arg1 = (Dali::Rect< int > *)jarg1;
46391   result = (int) ((arg1)->top);
46392   jresult = result;
46393   return jresult;
46394 }
46395
46396
46397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RectInteger(void * jarg1) {
46398   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46399
46400   arg1 = (Dali::Rect< int > *)jarg1;
46401   {
46402     try {
46403       delete arg1;
46404     } catch (std::out_of_range& e) {
46405       {
46406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46407       };
46408     } catch (std::exception& e) {
46409       {
46410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46411       };
46412     } catch (...) {
46413       {
46414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46415       };
46416     }
46417   }
46418 }
46419
46420
46421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectUnsignedInteger__SWIG_0() {
46422   void * jresult ;
46423   Dali::Rect< unsigned int > *result = 0 ;
46424
46425   {
46426     try {
46427       result = (Dali::Rect< unsigned int > *)new Dali::Rect< unsigned int >();
46428     } catch (std::out_of_range& e) {
46429       {
46430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46431       };
46432     } catch (std::exception& e) {
46433       {
46434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46435       };
46436     } catch (...) {
46437       {
46438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46439       };
46440     }
46441   }
46442   jresult = (void *)result;
46443   return jresult;
46444 }
46445
46446
46447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectUnsignedInteger__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
46448   void * jresult ;
46449   unsigned int arg1 ;
46450   unsigned int arg2 ;
46451   unsigned int arg3 ;
46452   unsigned int arg4 ;
46453   Dali::Rect< unsigned int > *result = 0 ;
46454
46455   arg1 = (unsigned int)jarg1;
46456   arg2 = (unsigned int)jarg2;
46457   arg3 = (unsigned int)jarg3;
46458   arg4 = (unsigned int)jarg4;
46459   {
46460     try {
46461       result = (Dali::Rect< unsigned int > *)new Dali::Rect< unsigned int >(arg1,arg2,arg3,arg4);
46462     } catch (std::out_of_range& e) {
46463       {
46464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46465       };
46466     } catch (std::exception& e) {
46467       {
46468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46469       };
46470     } catch (...) {
46471       {
46472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46473       };
46474     }
46475   }
46476   jresult = (void *)result;
46477   return jresult;
46478 }
46479
46480
46481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectUnsignedInteger__SWIG_2(void * jarg1) {
46482   void * jresult ;
46483   Dali::Rect< unsigned int > *arg1 = 0 ;
46484   Dali::Rect< unsigned int > *result = 0 ;
46485
46486   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46487   if (!arg1) {
46488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
46489     return 0;
46490   }
46491   {
46492     try {
46493       result = (Dali::Rect< unsigned int > *)new Dali::Rect< unsigned int >((Dali::Rect< unsigned int > const &)*arg1);
46494     } catch (std::out_of_range& e) {
46495       {
46496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46497       };
46498     } catch (std::exception& e) {
46499       {
46500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46501       };
46502     } catch (...) {
46503       {
46504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46505       };
46506     }
46507   }
46508   jresult = (void *)result;
46509   return jresult;
46510 }
46511
46512
46513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Assign(void * jarg1, void * jarg2) {
46514   void * jresult ;
46515   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46516   Dali::Rect< unsigned int > *arg2 = 0 ;
46517   Dali::Rect< unsigned int > *result = 0 ;
46518
46519   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46520   arg2 = (Dali::Rect< unsigned int > *)jarg2;
46521   if (!arg2) {
46522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
46523     return 0;
46524   }
46525   {
46526     try {
46527       result = (Dali::Rect< unsigned int > *) &(arg1)->operator =((Dali::Rect< unsigned int > const &)*arg2);
46528     } catch (std::out_of_range& e) {
46529       {
46530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46531       };
46532     } catch (std::exception& e) {
46533       {
46534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46535       };
46536     } catch (...) {
46537       {
46538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46539       };
46540     }
46541   }
46542   jresult = (void *)result;
46543   return jresult;
46544 }
46545
46546
46547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Set(void * jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, unsigned int jarg5) {
46548   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46549   unsigned int arg2 ;
46550   unsigned int arg3 ;
46551   unsigned int arg4 ;
46552   unsigned int arg5 ;
46553
46554   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46555   arg2 = (unsigned int)jarg2;
46556   arg3 = (unsigned int)jarg3;
46557   arg4 = (unsigned int)jarg4;
46558   arg5 = (unsigned int)jarg5;
46559   {
46560     try {
46561       (arg1)->Set(arg2,arg3,arg4,arg5);
46562     } catch (std::out_of_range& e) {
46563       {
46564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46565       };
46566     } catch (std::exception& e) {
46567       {
46568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46569       };
46570     } catch (...) {
46571       {
46572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46573       };
46574     }
46575   }
46576 }
46577
46578
46579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_IsEmpty(void * jarg1) {
46580   unsigned int jresult ;
46581   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46582   bool result;
46583
46584   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46585   {
46586     try {
46587       result = (bool)((Dali::Rect< unsigned int > const *)arg1)->IsEmpty();
46588     } catch (std::out_of_range& e) {
46589       {
46590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46591       };
46592     } catch (std::exception& e) {
46593       {
46594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46595       };
46596     } catch (...) {
46597       {
46598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46599       };
46600     }
46601   }
46602   jresult = result;
46603   return jresult;
46604 }
46605
46606
46607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Left(void * jarg1) {
46608   unsigned int jresult ;
46609   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46610   unsigned int result;
46611
46612   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46613   {
46614     try {
46615       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Left();
46616     } catch (std::out_of_range& e) {
46617       {
46618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46619       };
46620     } catch (std::exception& e) {
46621       {
46622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46623       };
46624     } catch (...) {
46625       {
46626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46627       };
46628     }
46629   }
46630   jresult = result;
46631   return jresult;
46632 }
46633
46634
46635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Right(void * jarg1) {
46636   unsigned int jresult ;
46637   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46638   unsigned int result;
46639
46640   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46641   {
46642     try {
46643       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Right();
46644     } catch (std::out_of_range& e) {
46645       {
46646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46647       };
46648     } catch (std::exception& e) {
46649       {
46650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46651       };
46652     } catch (...) {
46653       {
46654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46655       };
46656     }
46657   }
46658   jresult = result;
46659   return jresult;
46660 }
46661
46662
46663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Top(void * jarg1) {
46664   unsigned int jresult ;
46665   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46666   unsigned int result;
46667
46668   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46669   {
46670     try {
46671       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Top();
46672     } catch (std::out_of_range& e) {
46673       {
46674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46675       };
46676     } catch (std::exception& e) {
46677       {
46678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46679       };
46680     } catch (...) {
46681       {
46682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46683       };
46684     }
46685   }
46686   jresult = result;
46687   return jresult;
46688 }
46689
46690
46691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Bottom(void * jarg1) {
46692   unsigned int jresult ;
46693   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46694   unsigned int result;
46695
46696   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46697   {
46698     try {
46699       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Bottom();
46700     } catch (std::out_of_range& e) {
46701       {
46702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46703       };
46704     } catch (std::exception& e) {
46705       {
46706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46707       };
46708     } catch (...) {
46709       {
46710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46711       };
46712     }
46713   }
46714   jresult = result;
46715   return jresult;
46716 }
46717
46718
46719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Area(void * jarg1) {
46720   unsigned int jresult ;
46721   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46722   unsigned int result;
46723
46724   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46725   {
46726     try {
46727       result = (unsigned int)((Dali::Rect< unsigned int > const *)arg1)->Area();
46728     } catch (std::out_of_range& e) {
46729       {
46730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46731       };
46732     } catch (std::exception& e) {
46733       {
46734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46735       };
46736     } catch (...) {
46737       {
46738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46739       };
46740     }
46741   }
46742   jresult = result;
46743   return jresult;
46744 }
46745
46746
46747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Intersects(void * jarg1, void * jarg2) {
46748   unsigned int jresult ;
46749   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46750   Dali::Rect< unsigned int > *arg2 = 0 ;
46751   bool result;
46752
46753   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46754   arg2 = (Dali::Rect< unsigned int > *)jarg2;
46755   if (!arg2) {
46756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
46757     return 0;
46758   }
46759   {
46760     try {
46761       result = (bool)((Dali::Rect< unsigned int > const *)arg1)->Intersects((Dali::Rect< unsigned int > const &)*arg2);
46762     } catch (std::out_of_range& e) {
46763       {
46764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46765       };
46766     } catch (std::exception& e) {
46767       {
46768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46769       };
46770     } catch (...) {
46771       {
46772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46773       };
46774     }
46775   }
46776   jresult = result;
46777   return jresult;
46778 }
46779
46780
46781 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_Contains(void * jarg1, void * jarg2) {
46782   unsigned int jresult ;
46783   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46784   Dali::Rect< unsigned int > *arg2 = 0 ;
46785   bool result;
46786
46787   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46788   arg2 = (Dali::Rect< unsigned int > *)jarg2;
46789   if (!arg2) {
46790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< unsigned int > const & type is null", 0);
46791     return 0;
46792   }
46793   {
46794     try {
46795       result = (bool)((Dali::Rect< unsigned int > const *)arg1)->Contains((Dali::Rect< unsigned int > const &)*arg2);
46796     } catch (std::out_of_range& e) {
46797       {
46798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46799       };
46800     } catch (std::exception& e) {
46801       {
46802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46803       };
46804     } catch (...) {
46805       {
46806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46807       };
46808     }
46809   }
46810   jresult = result;
46811   return jresult;
46812 }
46813
46814
46815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_x_set(void * jarg1, unsigned int jarg2) {
46816   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46817   unsigned int arg2 ;
46818
46819   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46820   arg2 = (unsigned int)jarg2;
46821   if (arg1) (arg1)->x = arg2;
46822 }
46823
46824
46825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_x_get(void * jarg1) {
46826   unsigned int jresult ;
46827   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46828   unsigned int result;
46829
46830   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46831   result = (unsigned int) ((arg1)->x);
46832   jresult = result;
46833   return jresult;
46834 }
46835
46836
46837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_left_set(void * jarg1, unsigned int jarg2) {
46838   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46839   unsigned int arg2 ;
46840
46841   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46842   arg2 = (unsigned int)jarg2;
46843   if (arg1) (arg1)->left = arg2;
46844 }
46845
46846
46847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_left_get(void * jarg1) {
46848   unsigned int jresult ;
46849   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46850   unsigned int result;
46851
46852   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46853   result = (unsigned int) ((arg1)->left);
46854   jresult = result;
46855   return jresult;
46856 }
46857
46858
46859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_y_set(void * jarg1, unsigned int jarg2) {
46860   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46861   unsigned int arg2 ;
46862
46863   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46864   arg2 = (unsigned int)jarg2;
46865   if (arg1) (arg1)->y = arg2;
46866 }
46867
46868
46869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_y_get(void * jarg1) {
46870   unsigned int jresult ;
46871   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46872   unsigned int result;
46873
46874   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46875   result = (unsigned int) ((arg1)->y);
46876   jresult = result;
46877   return jresult;
46878 }
46879
46880
46881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_right_set(void * jarg1, unsigned int jarg2) {
46882   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46883   unsigned int arg2 ;
46884
46885   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46886   arg2 = (unsigned int)jarg2;
46887   if (arg1) (arg1)->right = arg2;
46888 }
46889
46890
46891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_right_get(void * jarg1) {
46892   unsigned int jresult ;
46893   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46894   unsigned int result;
46895
46896   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46897   result = (unsigned int) ((arg1)->right);
46898   jresult = result;
46899   return jresult;
46900 }
46901
46902
46903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_width_set(void * jarg1, unsigned int jarg2) {
46904   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46905   unsigned int arg2 ;
46906
46907   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46908   arg2 = (unsigned int)jarg2;
46909   if (arg1) (arg1)->width = arg2;
46910 }
46911
46912
46913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_width_get(void * jarg1) {
46914   unsigned int jresult ;
46915   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46916   unsigned int result;
46917
46918   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46919   result = (unsigned int) ((arg1)->width);
46920   jresult = result;
46921   return jresult;
46922 }
46923
46924
46925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_bottom_set(void * jarg1, unsigned int jarg2) {
46926   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46927   unsigned int arg2 ;
46928
46929   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46930   arg2 = (unsigned int)jarg2;
46931   if (arg1) (arg1)->bottom = arg2;
46932 }
46933
46934
46935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_bottom_get(void * jarg1) {
46936   unsigned int jresult ;
46937   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46938   unsigned int result;
46939
46940   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46941   result = (unsigned int) ((arg1)->bottom);
46942   jresult = result;
46943   return jresult;
46944 }
46945
46946
46947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_height_set(void * jarg1, unsigned int jarg2) {
46948   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46949   unsigned int arg2 ;
46950
46951   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46952   arg2 = (unsigned int)jarg2;
46953   if (arg1) (arg1)->height = arg2;
46954 }
46955
46956
46957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_height_get(void * jarg1) {
46958   unsigned int jresult ;
46959   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46960   unsigned int result;
46961
46962   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46963   result = (unsigned int) ((arg1)->height);
46964   jresult = result;
46965   return jresult;
46966 }
46967
46968
46969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_top_set(void * jarg1, unsigned int jarg2) {
46970   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46971   unsigned int arg2 ;
46972
46973   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46974   arg2 = (unsigned int)jarg2;
46975   if (arg1) (arg1)->top = arg2;
46976 }
46977
46978
46979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectUnsignedInteger_top_get(void * jarg1) {
46980   unsigned int jresult ;
46981   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46982   unsigned int result;
46983
46984   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46985   result = (unsigned int) ((arg1)->top);
46986   jresult = result;
46987   return jresult;
46988 }
46989
46990
46991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RectUnsignedInteger(void * jarg1) {
46992   Dali::Rect< unsigned int > *arg1 = (Dali::Rect< unsigned int > *) 0 ;
46993
46994   arg1 = (Dali::Rect< unsigned int > *)jarg1;
46995   {
46996     try {
46997       delete arg1;
46998     } catch (std::out_of_range& e) {
46999       {
47000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47001       };
47002     } catch (std::exception& e) {
47003       {
47004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47005       };
47006     } catch (...) {
47007       {
47008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47009       };
47010     }
47011   }
47012 }
47013
47014
47015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectFloat__SWIG_0() {
47016   void * jresult ;
47017   Dali::Rect< float > *result = 0 ;
47018
47019   {
47020     try {
47021       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47022     } catch (std::out_of_range& e) {
47023       {
47024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47025       };
47026     } catch (std::exception& e) {
47027       {
47028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47029       };
47030     } catch (...) {
47031       {
47032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47033       };
47034     }
47035   }
47036   jresult = (void *)result;
47037   return jresult;
47038 }
47039
47040
47041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectFloat__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47042   void * jresult ;
47043   float arg1 ;
47044   float arg2 ;
47045   float arg3 ;
47046   float arg4 ;
47047   Dali::Rect< float > *result = 0 ;
47048
47049   arg1 = (float)jarg1;
47050   arg2 = (float)jarg2;
47051   arg3 = (float)jarg3;
47052   arg4 = (float)jarg4;
47053   {
47054     try {
47055       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47056     } catch (std::out_of_range& e) {
47057       {
47058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47059       };
47060     } catch (std::exception& e) {
47061       {
47062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47063       };
47064     } catch (...) {
47065       {
47066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47067       };
47068     }
47069   }
47070   jresult = (void *)result;
47071   return jresult;
47072 }
47073
47074
47075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RectFloat__SWIG_2(void * jarg1) {
47076   void * jresult ;
47077   Dali::Rect< float > *arg1 = 0 ;
47078   Dali::Rect< float > *result = 0 ;
47079
47080   arg1 = (Dali::Rect< float > *)jarg1;
47081   if (!arg1) {
47082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47083     return 0;
47084   }
47085   {
47086     try {
47087       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47088     } catch (std::out_of_range& e) {
47089       {
47090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47091       };
47092     } catch (std::exception& e) {
47093       {
47094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47095       };
47096     } catch (...) {
47097       {
47098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47099       };
47100     }
47101   }
47102   jresult = (void *)result;
47103   return jresult;
47104 }
47105
47106
47107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RectFloat_Assign(void * jarg1, void * jarg2) {
47108   void * jresult ;
47109   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47110   Dali::Rect< float > *arg2 = 0 ;
47111   Dali::Rect< float > *result = 0 ;
47112
47113   arg1 = (Dali::Rect< float > *)jarg1;
47114   arg2 = (Dali::Rect< float > *)jarg2;
47115   if (!arg2) {
47116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47117     return 0;
47118   }
47119   {
47120     try {
47121       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47122     } catch (std::out_of_range& e) {
47123       {
47124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47125       };
47126     } catch (std::exception& e) {
47127       {
47128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47129       };
47130     } catch (...) {
47131       {
47132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47133       };
47134     }
47135   }
47136   jresult = (void *)result;
47137   return jresult;
47138 }
47139
47140
47141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47142   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47143   float arg2 ;
47144   float arg3 ;
47145   float arg4 ;
47146   float arg5 ;
47147
47148   arg1 = (Dali::Rect< float > *)jarg1;
47149   arg2 = (float)jarg2;
47150   arg3 = (float)jarg3;
47151   arg4 = (float)jarg4;
47152   arg5 = (float)jarg5;
47153   {
47154     try {
47155       (arg1)->Set(arg2,arg3,arg4,arg5);
47156     } catch (std::out_of_range& e) {
47157       {
47158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47159       };
47160     } catch (std::exception& e) {
47161       {
47162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47163       };
47164     } catch (...) {
47165       {
47166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47167       };
47168     }
47169   }
47170 }
47171
47172
47173 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectFloat_IsEmpty(void * jarg1) {
47174   unsigned int jresult ;
47175   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47176   bool result;
47177
47178   arg1 = (Dali::Rect< float > *)jarg1;
47179   {
47180     try {
47181       result = (bool)((Dali::Rect< float > const *)arg1)->IsEmpty();
47182     } catch (std::out_of_range& e) {
47183       {
47184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47185       };
47186     } catch (std::exception& e) {
47187       {
47188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47189       };
47190     } catch (...) {
47191       {
47192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47193       };
47194     }
47195   }
47196   jresult = result;
47197   return jresult;
47198 }
47199
47200
47201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_Left(void * jarg1) {
47202   float jresult ;
47203   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47204   float result;
47205
47206   arg1 = (Dali::Rect< float > *)jarg1;
47207   {
47208     try {
47209       result = (float)((Dali::Rect< float > const *)arg1)->Left();
47210     } catch (std::out_of_range& e) {
47211       {
47212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47213       };
47214     } catch (std::exception& e) {
47215       {
47216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47217       };
47218     } catch (...) {
47219       {
47220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47221       };
47222     }
47223   }
47224   jresult = result;
47225   return jresult;
47226 }
47227
47228
47229 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_Right(void * jarg1) {
47230   float jresult ;
47231   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47232   float result;
47233
47234   arg1 = (Dali::Rect< float > *)jarg1;
47235   {
47236     try {
47237       result = (float)((Dali::Rect< float > const *)arg1)->Right();
47238     } catch (std::out_of_range& e) {
47239       {
47240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47241       };
47242     } catch (std::exception& e) {
47243       {
47244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47245       };
47246     } catch (...) {
47247       {
47248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47249       };
47250     }
47251   }
47252   jresult = result;
47253   return jresult;
47254 }
47255
47256
47257 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_Top(void * jarg1) {
47258   float jresult ;
47259   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47260   float result;
47261
47262   arg1 = (Dali::Rect< float > *)jarg1;
47263   {
47264     try {
47265       result = (float)((Dali::Rect< float > const *)arg1)->Top();
47266     } catch (std::out_of_range& e) {
47267       {
47268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47269       };
47270     } catch (std::exception& e) {
47271       {
47272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47273       };
47274     } catch (...) {
47275       {
47276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47277       };
47278     }
47279   }
47280   jresult = result;
47281   return jresult;
47282 }
47283
47284
47285 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_Bottom(void * jarg1) {
47286   float jresult ;
47287   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47288   float result;
47289
47290   arg1 = (Dali::Rect< float > *)jarg1;
47291   {
47292     try {
47293       result = (float)((Dali::Rect< float > const *)arg1)->Bottom();
47294     } catch (std::out_of_range& e) {
47295       {
47296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47297       };
47298     } catch (std::exception& e) {
47299       {
47300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47301       };
47302     } catch (...) {
47303       {
47304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47305       };
47306     }
47307   }
47308   jresult = result;
47309   return jresult;
47310 }
47311
47312
47313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_Area(void * jarg1) {
47314   float jresult ;
47315   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47316   float result;
47317
47318   arg1 = (Dali::Rect< float > *)jarg1;
47319   {
47320     try {
47321       result = (float)((Dali::Rect< float > const *)arg1)->Area();
47322     } catch (std::out_of_range& e) {
47323       {
47324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47325       };
47326     } catch (std::exception& e) {
47327       {
47328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47329       };
47330     } catch (...) {
47331       {
47332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47333       };
47334     }
47335   }
47336   jresult = result;
47337   return jresult;
47338 }
47339
47340
47341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectFloat_Intersects(void * jarg1, void * jarg2) {
47342   unsigned int jresult ;
47343   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47344   Dali::Rect< float > *arg2 = 0 ;
47345   bool result;
47346
47347   arg1 = (Dali::Rect< float > *)jarg1;
47348   arg2 = (Dali::Rect< float > *)jarg2;
47349   if (!arg2) {
47350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47351     return 0;
47352   }
47353   {
47354     try {
47355       result = (bool)((Dali::Rect< float > const *)arg1)->Intersects((Dali::Rect< float > const &)*arg2);
47356     } catch (std::out_of_range& e) {
47357       {
47358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47359       };
47360     } catch (std::exception& e) {
47361       {
47362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47363       };
47364     } catch (...) {
47365       {
47366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47367       };
47368     }
47369   }
47370   jresult = result;
47371   return jresult;
47372 }
47373
47374
47375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RectFloat_Contains(void * jarg1, void * jarg2) {
47376   unsigned int jresult ;
47377   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47378   Dali::Rect< float > *arg2 = 0 ;
47379   bool result;
47380
47381   arg1 = (Dali::Rect< float > *)jarg1;
47382   arg2 = (Dali::Rect< float > *)jarg2;
47383   if (!arg2) {
47384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47385     return 0;
47386   }
47387   {
47388     try {
47389       result = (bool)((Dali::Rect< float > const *)arg1)->Contains((Dali::Rect< float > const &)*arg2);
47390     } catch (std::out_of_range& e) {
47391       {
47392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47393       };
47394     } catch (std::exception& e) {
47395       {
47396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47397       };
47398     } catch (...) {
47399       {
47400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47401       };
47402     }
47403   }
47404   jresult = result;
47405   return jresult;
47406 }
47407
47408
47409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_x_set(void * jarg1, float jarg2) {
47410   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47411   float arg2 ;
47412
47413   arg1 = (Dali::Rect< float > *)jarg1;
47414   arg2 = (float)jarg2;
47415   if (arg1) (arg1)->x = arg2;
47416 }
47417
47418
47419 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_x_get(void * jarg1) {
47420   float jresult ;
47421   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47422   float result;
47423
47424   arg1 = (Dali::Rect< float > *)jarg1;
47425   result = (float) ((arg1)->x);
47426   jresult = result;
47427   return jresult;
47428 }
47429
47430
47431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_left_set(void * jarg1, float jarg2) {
47432   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47433   float arg2 ;
47434
47435   arg1 = (Dali::Rect< float > *)jarg1;
47436   arg2 = (float)jarg2;
47437   if (arg1) (arg1)->left = arg2;
47438 }
47439
47440
47441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_left_get(void * jarg1) {
47442   float jresult ;
47443   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47444   float result;
47445
47446   arg1 = (Dali::Rect< float > *)jarg1;
47447   result = (float) ((arg1)->left);
47448   jresult = result;
47449   return jresult;
47450 }
47451
47452
47453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_y_set(void * jarg1, float jarg2) {
47454   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47455   float arg2 ;
47456
47457   arg1 = (Dali::Rect< float > *)jarg1;
47458   arg2 = (float)jarg2;
47459   if (arg1) (arg1)->y = arg2;
47460 }
47461
47462
47463 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_y_get(void * jarg1) {
47464   float jresult ;
47465   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47466   float result;
47467
47468   arg1 = (Dali::Rect< float > *)jarg1;
47469   result = (float) ((arg1)->y);
47470   jresult = result;
47471   return jresult;
47472 }
47473
47474
47475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_right_set(void * jarg1, float jarg2) {
47476   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47477   float arg2 ;
47478
47479   arg1 = (Dali::Rect< float > *)jarg1;
47480   arg2 = (float)jarg2;
47481   if (arg1) (arg1)->right = arg2;
47482 }
47483
47484
47485 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_right_get(void * jarg1) {
47486   float jresult ;
47487   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47488   float result;
47489
47490   arg1 = (Dali::Rect< float > *)jarg1;
47491   result = (float) ((arg1)->right);
47492   jresult = result;
47493   return jresult;
47494 }
47495
47496
47497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_width_set(void * jarg1, float jarg2) {
47498   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47499   float arg2 ;
47500
47501   arg1 = (Dali::Rect< float > *)jarg1;
47502   arg2 = (float)jarg2;
47503   if (arg1) (arg1)->width = arg2;
47504 }
47505
47506
47507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_width_get(void * jarg1) {
47508   float jresult ;
47509   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47510   float result;
47511
47512   arg1 = (Dali::Rect< float > *)jarg1;
47513   result = (float) ((arg1)->width);
47514   jresult = result;
47515   return jresult;
47516 }
47517
47518
47519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_bottom_set(void * jarg1, float jarg2) {
47520   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47521   float arg2 ;
47522
47523   arg1 = (Dali::Rect< float > *)jarg1;
47524   arg2 = (float)jarg2;
47525   if (arg1) (arg1)->bottom = arg2;
47526 }
47527
47528
47529 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_bottom_get(void * jarg1) {
47530   float jresult ;
47531   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47532   float result;
47533
47534   arg1 = (Dali::Rect< float > *)jarg1;
47535   result = (float) ((arg1)->bottom);
47536   jresult = result;
47537   return jresult;
47538 }
47539
47540
47541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_height_set(void * jarg1, float jarg2) {
47542   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47543   float arg2 ;
47544
47545   arg1 = (Dali::Rect< float > *)jarg1;
47546   arg2 = (float)jarg2;
47547   if (arg1) (arg1)->height = arg2;
47548 }
47549
47550
47551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_height_get(void * jarg1) {
47552   float jresult ;
47553   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47554   float result;
47555
47556   arg1 = (Dali::Rect< float > *)jarg1;
47557   result = (float) ((arg1)->height);
47558   jresult = result;
47559   return jresult;
47560 }
47561
47562
47563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RectFloat_top_set(void * jarg1, float jarg2) {
47564   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47565   float arg2 ;
47566
47567   arg1 = (Dali::Rect< float > *)jarg1;
47568   arg2 = (float)jarg2;
47569   if (arg1) (arg1)->top = arg2;
47570 }
47571
47572
47573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RectFloat_top_get(void * jarg1) {
47574   float jresult ;
47575   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47576   float result;
47577
47578   arg1 = (Dali::Rect< float > *)jarg1;
47579   result = (float) ((arg1)->top);
47580   jresult = result;
47581   return jresult;
47582 }
47583
47584
47585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RectFloat(void * jarg1) {
47586   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47587
47588   arg1 = (Dali::Rect< float > *)jarg1;
47589   {
47590     try {
47591       delete arg1;
47592     } catch (std::out_of_range& e) {
47593       {
47594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47595       };
47596     } catch (std::exception& e) {
47597       {
47598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47599       };
47600     } catch (...) {
47601       {
47602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47603       };
47604     }
47605   }
47606 }
47607
47608
47609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
47610   int jresult ;
47611   int result;
47612
47613   result = (int)Dali::Vector< int >::BaseType;
47614   jresult = (int)result;
47615   return jresult;
47616 }
47617
47618
47619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
47620   void * jresult ;
47621   Dali::Vector< int > *result = 0 ;
47622
47623   {
47624     try {
47625       result = (Dali::Vector< int > *)new Dali::Vector< int >();
47626     } catch (std::out_of_range& e) {
47627       {
47628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47629       };
47630     } catch (std::exception& e) {
47631       {
47632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47633       };
47634     } catch (...) {
47635       {
47636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47637       };
47638     }
47639   }
47640   jresult = (void *)result;
47641   return jresult;
47642 }
47643
47644
47645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
47646   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47647
47648   arg1 = (Dali::Vector< int > *)jarg1;
47649   {
47650     try {
47651       delete arg1;
47652     } catch (std::out_of_range& e) {
47653       {
47654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47655       };
47656     } catch (std::exception& e) {
47657       {
47658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47659       };
47660     } catch (...) {
47661       {
47662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47663       };
47664     }
47665   }
47666 }
47667
47668
47669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
47670   void * jresult ;
47671   Dali::Vector< int > *arg1 = 0 ;
47672   Dali::Vector< int > *result = 0 ;
47673
47674   arg1 = (Dali::Vector< int > *)jarg1;
47675   if (!arg1) {
47676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47677     return 0;
47678   }
47679   {
47680     try {
47681       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
47682     } catch (std::out_of_range& e) {
47683       {
47684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47685       };
47686     } catch (std::exception& e) {
47687       {
47688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47689       };
47690     } catch (...) {
47691       {
47692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47693       };
47694     }
47695   }
47696   jresult = (void *)result;
47697   return jresult;
47698 }
47699
47700
47701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
47702   void * jresult ;
47703   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47704   Dali::Vector< int > *arg2 = 0 ;
47705   Dali::Vector< int > *result = 0 ;
47706
47707   arg1 = (Dali::Vector< int > *)jarg1;
47708   arg2 = (Dali::Vector< int > *)jarg2;
47709   if (!arg2) {
47710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47711     return 0;
47712   }
47713   {
47714     try {
47715       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
47716     } catch (std::out_of_range& e) {
47717       {
47718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47719       };
47720     } catch (std::exception& e) {
47721       {
47722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47723       };
47724     } catch (...) {
47725       {
47726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47727       };
47728     }
47729   }
47730   jresult = (void *)result;
47731   return jresult;
47732 }
47733
47734
47735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
47736   void * jresult ;
47737   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47738   Dali::Vector< int >::Iterator result;
47739
47740   arg1 = (Dali::Vector< int > *)jarg1;
47741   {
47742     try {
47743       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
47744     } catch (std::out_of_range& e) {
47745       {
47746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47747       };
47748     } catch (std::exception& e) {
47749       {
47750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47751       };
47752     } catch (...) {
47753       {
47754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47755       };
47756     }
47757   }
47758   jresult = (void *)result;
47759   return jresult;
47760 }
47761
47762
47763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
47764   void * jresult ;
47765   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47766   Dali::Vector< int >::Iterator result;
47767
47768   arg1 = (Dali::Vector< int > *)jarg1;
47769   {
47770     try {
47771       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
47772     } catch (std::out_of_range& e) {
47773       {
47774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47775       };
47776     } catch (std::exception& e) {
47777       {
47778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47779       };
47780     } catch (...) {
47781       {
47782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47783       };
47784     }
47785   }
47786   jresult = (void *)result;
47787   return jresult;
47788 }
47789
47790
47791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47792   void * jresult ;
47793   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47794   Dali::Vector< int >::SizeType arg2 ;
47795   Dali::Vector< int >::ItemType *result = 0 ;
47796
47797   arg1 = (Dali::Vector< int > *)jarg1;
47798   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47799   {
47800     try {
47801       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
47802     } catch (std::out_of_range& e) {
47803       {
47804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47805       };
47806     } catch (std::exception& e) {
47807       {
47808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47809       };
47810     } catch (...) {
47811       {
47812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47813       };
47814     }
47815   }
47816   jresult = (void *)result;
47817   return jresult;
47818 }
47819
47820
47821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
47822   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47823   Dali::Vector< int >::ItemType *arg2 = 0 ;
47824   Dali::Vector< int >::ItemType temp2 ;
47825
47826   arg1 = (Dali::Vector< int > *)jarg1;
47827   temp2 = (Dali::Vector< int >::ItemType)jarg2;
47828   arg2 = &temp2;
47829   {
47830     try {
47831       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
47832     } catch (std::out_of_range& e) {
47833       {
47834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47835       };
47836     } catch (std::exception& e) {
47837       {
47838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47839       };
47840     } catch (...) {
47841       {
47842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47843       };
47844     }
47845   }
47846 }
47847
47848
47849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
47850   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47851   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47852   Dali::Vector< int >::ItemType *arg3 = 0 ;
47853   Dali::Vector< int >::ItemType temp3 ;
47854
47855   arg1 = (Dali::Vector< int > *)jarg1;
47856   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47857   temp3 = (Dali::Vector< int >::ItemType)jarg3;
47858   arg3 = &temp3;
47859   {
47860     try {
47861       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
47862     } catch (std::out_of_range& e) {
47863       {
47864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47865       };
47866     } catch (std::exception& e) {
47867       {
47868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47869       };
47870     } catch (...) {
47871       {
47872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47873       };
47874     }
47875   }
47876 }
47877
47878
47879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47880   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47881   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47882   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
47883   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
47884
47885   arg1 = (Dali::Vector< int > *)jarg1;
47886   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47887   arg3 = (Dali::Vector< int >::Iterator)jarg3;
47888   arg4 = (Dali::Vector< int >::Iterator)jarg4;
47889   {
47890     try {
47891       (arg1)->Insert(arg2,arg3,arg4);
47892     } catch (std::out_of_range& e) {
47893       {
47894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47895       };
47896     } catch (std::exception& e) {
47897       {
47898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47899       };
47900     } catch (...) {
47901       {
47902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47903       };
47904     }
47905   }
47906 }
47907
47908
47909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
47910   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47911   Dali::Vector< int >::SizeType arg2 ;
47912
47913   arg1 = (Dali::Vector< int > *)jarg1;
47914   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47915   {
47916     try {
47917       (arg1)->Reserve(arg2);
47918     } catch (std::out_of_range& e) {
47919       {
47920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47921       };
47922     } catch (std::exception& e) {
47923       {
47924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47925       };
47926     } catch (...) {
47927       {
47928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47929       };
47930     }
47931   }
47932 }
47933
47934
47935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47936   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47937   Dali::Vector< int >::SizeType arg2 ;
47938
47939   arg1 = (Dali::Vector< int > *)jarg1;
47940   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47941   {
47942     try {
47943       (arg1)->Resize(arg2);
47944     } catch (std::out_of_range& e) {
47945       {
47946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47947       };
47948     } catch (std::exception& e) {
47949       {
47950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47951       };
47952     } catch (...) {
47953       {
47954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47955       };
47956     }
47957   }
47958 }
47959
47960
47961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
47962   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47963   Dali::Vector< int >::SizeType arg2 ;
47964   Dali::Vector< int >::ItemType *arg3 = 0 ;
47965   Dali::Vector< int >::ItemType temp3 ;
47966
47967   arg1 = (Dali::Vector< int > *)jarg1;
47968   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47969   temp3 = (Dali::Vector< int >::ItemType)jarg3;
47970   arg3 = &temp3;
47971   {
47972     try {
47973       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
47974     } catch (std::out_of_range& e) {
47975       {
47976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47977       };
47978     } catch (std::exception& e) {
47979       {
47980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47981       };
47982     } catch (...) {
47983       {
47984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47985       };
47986     }
47987   }
47988 }
47989
47990
47991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
47992   void * jresult ;
47993   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47994   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47995   Dali::Vector< int >::Iterator result;
47996
47997   arg1 = (Dali::Vector< int > *)jarg1;
47998   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47999   {
48000     try {
48001       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48002     } catch (std::out_of_range& e) {
48003       {
48004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48005       };
48006     } catch (std::exception& e) {
48007       {
48008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48009       };
48010     } catch (...) {
48011       {
48012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48013       };
48014     }
48015   }
48016   jresult = (void *)result;
48017   return jresult;
48018 }
48019
48020
48021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48022   void * jresult ;
48023   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48024   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48025   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48026   Dali::Vector< int >::Iterator result;
48027
48028   arg1 = (Dali::Vector< int > *)jarg1;
48029   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48030   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48031   {
48032     try {
48033       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48034     } catch (std::out_of_range& e) {
48035       {
48036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48037       };
48038     } catch (std::exception& e) {
48039       {
48040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48041       };
48042     } catch (...) {
48043       {
48044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48045       };
48046     }
48047   }
48048   jresult = (void *)result;
48049   return jresult;
48050 }
48051
48052
48053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48054   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48055   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48056
48057   arg1 = (Dali::Vector< int > *)jarg1;
48058   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48059   {
48060     try {
48061       (arg1)->Remove(arg2);
48062     } catch (std::out_of_range& e) {
48063       {
48064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48065       };
48066     } catch (std::exception& e) {
48067       {
48068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48069       };
48070     } catch (...) {
48071       {
48072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48073       };
48074     }
48075   }
48076 }
48077
48078
48079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48080   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48081   Dali::Vector< int > *arg2 = 0 ;
48082
48083   arg1 = (Dali::Vector< int > *)jarg1;
48084   arg2 = (Dali::Vector< int > *)jarg2;
48085   if (!arg2) {
48086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48087     return ;
48088   }
48089   {
48090     try {
48091       (arg1)->Swap(*arg2);
48092     } catch (std::out_of_range& e) {
48093       {
48094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48095       };
48096     } catch (std::exception& e) {
48097       {
48098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48099       };
48100     } catch (...) {
48101       {
48102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48103       };
48104     }
48105   }
48106 }
48107
48108
48109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48110   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48111
48112   arg1 = (Dali::Vector< int > *)jarg1;
48113   {
48114     try {
48115       (arg1)->Clear();
48116     } catch (std::out_of_range& e) {
48117       {
48118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48119       };
48120     } catch (std::exception& e) {
48121       {
48122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48123       };
48124     } catch (...) {
48125       {
48126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48127       };
48128     }
48129   }
48130 }
48131
48132
48133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48134   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48135
48136   arg1 = (Dali::Vector< int > *)jarg1;
48137   {
48138     try {
48139       (arg1)->Release();
48140     } catch (std::out_of_range& e) {
48141       {
48142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48143       };
48144     } catch (std::exception& e) {
48145       {
48146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48147       };
48148     } catch (...) {
48149       {
48150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48151       };
48152     }
48153   }
48154 }
48155
48156
48157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48158   int jresult ;
48159   int result;
48160
48161   result = (int)Dali::Vector< float >::BaseType;
48162   jresult = (int)result;
48163   return jresult;
48164 }
48165
48166
48167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48168   void * jresult ;
48169   Dali::Vector< float > *result = 0 ;
48170
48171   {
48172     try {
48173       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48174     } catch (std::out_of_range& e) {
48175       {
48176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48177       };
48178     } catch (std::exception& e) {
48179       {
48180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48181       };
48182     } catch (...) {
48183       {
48184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48185       };
48186     }
48187   }
48188   jresult = (void *)result;
48189   return jresult;
48190 }
48191
48192
48193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48194   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48195
48196   arg1 = (Dali::Vector< float > *)jarg1;
48197   {
48198     try {
48199       delete arg1;
48200     } catch (std::out_of_range& e) {
48201       {
48202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48203       };
48204     } catch (std::exception& e) {
48205       {
48206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48207       };
48208     } catch (...) {
48209       {
48210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48211       };
48212     }
48213   }
48214 }
48215
48216
48217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48218   void * jresult ;
48219   Dali::Vector< float > *arg1 = 0 ;
48220   Dali::Vector< float > *result = 0 ;
48221
48222   arg1 = (Dali::Vector< float > *)jarg1;
48223   if (!arg1) {
48224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48225     return 0;
48226   }
48227   {
48228     try {
48229       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48230     } catch (std::out_of_range& e) {
48231       {
48232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48233       };
48234     } catch (std::exception& e) {
48235       {
48236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48237       };
48238     } catch (...) {
48239       {
48240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48241       };
48242     }
48243   }
48244   jresult = (void *)result;
48245   return jresult;
48246 }
48247
48248
48249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48250   void * jresult ;
48251   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48252   Dali::Vector< float > *arg2 = 0 ;
48253   Dali::Vector< float > *result = 0 ;
48254
48255   arg1 = (Dali::Vector< float > *)jarg1;
48256   arg2 = (Dali::Vector< float > *)jarg2;
48257   if (!arg2) {
48258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48259     return 0;
48260   }
48261   {
48262     try {
48263       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48264     } catch (std::out_of_range& e) {
48265       {
48266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48267       };
48268     } catch (std::exception& e) {
48269       {
48270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48271       };
48272     } catch (...) {
48273       {
48274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48275       };
48276     }
48277   }
48278   jresult = (void *)result;
48279   return jresult;
48280 }
48281
48282
48283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48284   void * jresult ;
48285   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48286   Dali::Vector< float >::Iterator result;
48287
48288   arg1 = (Dali::Vector< float > *)jarg1;
48289   {
48290     try {
48291       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48292     } catch (std::out_of_range& e) {
48293       {
48294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48295       };
48296     } catch (std::exception& e) {
48297       {
48298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48299       };
48300     } catch (...) {
48301       {
48302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48303       };
48304     }
48305   }
48306   jresult = (void *)result;
48307   return jresult;
48308 }
48309
48310
48311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48312   void * jresult ;
48313   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48314   Dali::Vector< float >::Iterator result;
48315
48316   arg1 = (Dali::Vector< float > *)jarg1;
48317   {
48318     try {
48319       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48320     } catch (std::out_of_range& e) {
48321       {
48322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48323       };
48324     } catch (std::exception& e) {
48325       {
48326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48327       };
48328     } catch (...) {
48329       {
48330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48331       };
48332     }
48333   }
48334   jresult = (void *)result;
48335   return jresult;
48336 }
48337
48338
48339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48340   void * jresult ;
48341   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48342   Dali::Vector< float >::SizeType arg2 ;
48343   Dali::Vector< float >::ItemType *result = 0 ;
48344
48345   arg1 = (Dali::Vector< float > *)jarg1;
48346   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48347   {
48348     try {
48349       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48350     } catch (std::out_of_range& e) {
48351       {
48352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48353       };
48354     } catch (std::exception& e) {
48355       {
48356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48357       };
48358     } catch (...) {
48359       {
48360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48361       };
48362     }
48363   }
48364   jresult = (void *)result;
48365   return jresult;
48366 }
48367
48368
48369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48370   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48371   Dali::Vector< float >::ItemType *arg2 = 0 ;
48372   Dali::Vector< float >::ItemType temp2 ;
48373
48374   arg1 = (Dali::Vector< float > *)jarg1;
48375   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48376   arg2 = &temp2;
48377   {
48378     try {
48379       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48380     } catch (std::out_of_range& e) {
48381       {
48382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48383       };
48384     } catch (std::exception& e) {
48385       {
48386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48387       };
48388     } catch (...) {
48389       {
48390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48391       };
48392     }
48393   }
48394 }
48395
48396
48397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48398   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48399   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48400   Dali::Vector< float >::ItemType *arg3 = 0 ;
48401   Dali::Vector< float >::ItemType temp3 ;
48402
48403   arg1 = (Dali::Vector< float > *)jarg1;
48404   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48405   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48406   arg3 = &temp3;
48407   {
48408     try {
48409       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48410     } catch (std::out_of_range& e) {
48411       {
48412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48413       };
48414     } catch (std::exception& e) {
48415       {
48416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48417       };
48418     } catch (...) {
48419       {
48420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48421       };
48422     }
48423   }
48424 }
48425
48426
48427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48428   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48429   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48430   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48431   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
48432
48433   arg1 = (Dali::Vector< float > *)jarg1;
48434   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48435   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48436   arg4 = (Dali::Vector< float >::Iterator)jarg4;
48437   {
48438     try {
48439       (arg1)->Insert(arg2,arg3,arg4);
48440     } catch (std::out_of_range& e) {
48441       {
48442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48443       };
48444     } catch (std::exception& e) {
48445       {
48446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48447       };
48448     } catch (...) {
48449       {
48450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48451       };
48452     }
48453   }
48454 }
48455
48456
48457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
48458   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48459   Dali::Vector< float >::SizeType arg2 ;
48460
48461   arg1 = (Dali::Vector< float > *)jarg1;
48462   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48463   {
48464     try {
48465       (arg1)->Reserve(arg2);
48466     } catch (std::out_of_range& e) {
48467       {
48468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48469       };
48470     } catch (std::exception& e) {
48471       {
48472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48473       };
48474     } catch (...) {
48475       {
48476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48477       };
48478     }
48479   }
48480 }
48481
48482
48483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48484   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48485   Dali::Vector< float >::SizeType arg2 ;
48486
48487   arg1 = (Dali::Vector< float > *)jarg1;
48488   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48489   {
48490     try {
48491       (arg1)->Resize(arg2);
48492     } catch (std::out_of_range& e) {
48493       {
48494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48495       };
48496     } catch (std::exception& e) {
48497       {
48498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48499       };
48500     } catch (...) {
48501       {
48502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48503       };
48504     }
48505   }
48506 }
48507
48508
48509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
48510   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48511   Dali::Vector< float >::SizeType arg2 ;
48512   Dali::Vector< float >::ItemType *arg3 = 0 ;
48513   Dali::Vector< float >::ItemType temp3 ;
48514
48515   arg1 = (Dali::Vector< float > *)jarg1;
48516   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48517   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48518   arg3 = &temp3;
48519   {
48520     try {
48521       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48522     } catch (std::out_of_range& e) {
48523       {
48524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48525       };
48526     } catch (std::exception& e) {
48527       {
48528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48529       };
48530     } catch (...) {
48531       {
48532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48533       };
48534     }
48535   }
48536 }
48537
48538
48539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
48540   void * jresult ;
48541   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48542   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48543   Dali::Vector< float >::Iterator result;
48544
48545   arg1 = (Dali::Vector< float > *)jarg1;
48546   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48547   {
48548     try {
48549       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
48550     } catch (std::out_of_range& e) {
48551       {
48552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48553       };
48554     } catch (std::exception& e) {
48555       {
48556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48557       };
48558     } catch (...) {
48559       {
48560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48561       };
48562     }
48563   }
48564   jresult = (void *)result;
48565   return jresult;
48566 }
48567
48568
48569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48570   void * jresult ;
48571   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48572   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48573   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48574   Dali::Vector< float >::Iterator result;
48575
48576   arg1 = (Dali::Vector< float > *)jarg1;
48577   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48578   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48579   {
48580     try {
48581       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
48582     } catch (std::out_of_range& e) {
48583       {
48584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48585       };
48586     } catch (std::exception& e) {
48587       {
48588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48589       };
48590     } catch (...) {
48591       {
48592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48593       };
48594     }
48595   }
48596   jresult = (void *)result;
48597   return jresult;
48598 }
48599
48600
48601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
48602   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48603   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48604
48605   arg1 = (Dali::Vector< float > *)jarg1;
48606   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48607   {
48608     try {
48609       (arg1)->Remove(arg2);
48610     } catch (std::out_of_range& e) {
48611       {
48612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48613       };
48614     } catch (std::exception& e) {
48615       {
48616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48617       };
48618     } catch (...) {
48619       {
48620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48621       };
48622     }
48623   }
48624 }
48625
48626
48627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
48628   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48629   Dali::Vector< float > *arg2 = 0 ;
48630
48631   arg1 = (Dali::Vector< float > *)jarg1;
48632   arg2 = (Dali::Vector< float > *)jarg2;
48633   if (!arg2) {
48634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
48635     return ;
48636   }
48637   {
48638     try {
48639       (arg1)->Swap(*arg2);
48640     } catch (std::out_of_range& e) {
48641       {
48642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48643       };
48644     } catch (std::exception& e) {
48645       {
48646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48647       };
48648     } catch (...) {
48649       {
48650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48651       };
48652     }
48653   }
48654 }
48655
48656
48657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
48658   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48659
48660   arg1 = (Dali::Vector< float > *)jarg1;
48661   {
48662     try {
48663       (arg1)->Clear();
48664     } catch (std::out_of_range& e) {
48665       {
48666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48667       };
48668     } catch (std::exception& e) {
48669       {
48670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48671       };
48672     } catch (...) {
48673       {
48674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48675       };
48676     }
48677   }
48678 }
48679
48680
48681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
48682   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48683
48684   arg1 = (Dali::Vector< float > *)jarg1;
48685   {
48686     try {
48687       (arg1)->Release();
48688     } catch (std::out_of_range& e) {
48689       {
48690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48691       };
48692     } catch (std::exception& e) {
48693       {
48694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48695       };
48696     } catch (...) {
48697       {
48698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48699       };
48700     }
48701   }
48702 }
48703
48704
48705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
48706   int jresult ;
48707   int result;
48708
48709   result = (int)Dali::Vector< unsigned char >::BaseType;
48710   jresult = (int)result;
48711   return jresult;
48712 }
48713
48714
48715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
48716   void * jresult ;
48717   Dali::Vector< unsigned char > *result = 0 ;
48718
48719   {
48720     try {
48721       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
48722     } catch (std::out_of_range& e) {
48723       {
48724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48725       };
48726     } catch (std::exception& e) {
48727       {
48728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48729       };
48730     } catch (...) {
48731       {
48732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48733       };
48734     }
48735   }
48736   jresult = (void *)result;
48737   return jresult;
48738 }
48739
48740
48741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
48742   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48743
48744   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48745   {
48746     try {
48747       delete arg1;
48748     } catch (std::out_of_range& e) {
48749       {
48750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48751       };
48752     } catch (std::exception& e) {
48753       {
48754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48755       };
48756     } catch (...) {
48757       {
48758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48759       };
48760     }
48761   }
48762 }
48763
48764
48765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
48766   void * jresult ;
48767   Dali::Vector< unsigned char > *arg1 = 0 ;
48768   Dali::Vector< unsigned char > *result = 0 ;
48769
48770   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48771   if (!arg1) {
48772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
48773     return 0;
48774   }
48775   {
48776     try {
48777       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
48778     } catch (std::out_of_range& e) {
48779       {
48780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48781       };
48782     } catch (std::exception& e) {
48783       {
48784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48785       };
48786     } catch (...) {
48787       {
48788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48789       };
48790     }
48791   }
48792   jresult = (void *)result;
48793   return jresult;
48794 }
48795
48796
48797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
48798   void * jresult ;
48799   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48800   Dali::Vector< unsigned char > *arg2 = 0 ;
48801   Dali::Vector< unsigned char > *result = 0 ;
48802
48803   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48804   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48805   if (!arg2) {
48806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
48807     return 0;
48808   }
48809   {
48810     try {
48811       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
48812     } catch (std::out_of_range& e) {
48813       {
48814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48815       };
48816     } catch (std::exception& e) {
48817       {
48818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48819       };
48820     } catch (...) {
48821       {
48822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48823       };
48824     }
48825   }
48826   jresult = (void *)result;
48827   return jresult;
48828 }
48829
48830
48831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
48832   void * jresult ;
48833   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48834   Dali::Vector< unsigned char >::Iterator result;
48835
48836   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48837   {
48838     try {
48839       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
48840     } catch (std::out_of_range& e) {
48841       {
48842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48843       };
48844     } catch (std::exception& e) {
48845       {
48846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48847       };
48848     } catch (...) {
48849       {
48850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48851       };
48852     }
48853   }
48854   jresult = (void *)result;
48855   return jresult;
48856 }
48857
48858
48859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
48860   void * jresult ;
48861   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48862   Dali::Vector< unsigned char >::Iterator result;
48863
48864   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48865   {
48866     try {
48867       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
48868     } catch (std::out_of_range& e) {
48869       {
48870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48871       };
48872     } catch (std::exception& e) {
48873       {
48874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48875       };
48876     } catch (...) {
48877       {
48878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48879       };
48880     }
48881   }
48882   jresult = (void *)result;
48883   return jresult;
48884 }
48885
48886
48887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48888   void * jresult ;
48889   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48890   Dali::Vector< unsigned char >::SizeType arg2 ;
48891   Dali::Vector< unsigned char >::ItemType *result = 0 ;
48892
48893   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48894   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
48895   {
48896     try {
48897       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
48898     } catch (std::out_of_range& e) {
48899       {
48900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48901       };
48902     } catch (std::exception& e) {
48903       {
48904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48905       };
48906     } catch (...) {
48907       {
48908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48909       };
48910     }
48911   }
48912   jresult = (void *)result;
48913   return jresult;
48914 }
48915
48916
48917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
48918   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48919   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
48920   Dali::Vector< unsigned char >::ItemType temp2 ;
48921
48922   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48923   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
48924   arg2 = &temp2;
48925   {
48926     try {
48927       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
48928     } catch (std::out_of_range& e) {
48929       {
48930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48931       };
48932     } catch (std::exception& e) {
48933       {
48934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48935       };
48936     } catch (...) {
48937       {
48938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48939       };
48940     }
48941   }
48942 }
48943
48944
48945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
48946   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48947   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48948   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
48949   Dali::Vector< unsigned char >::ItemType temp3 ;
48950
48951   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48952   arg2 = jarg2;
48953   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
48954   arg3 = &temp3;
48955   {
48956     try {
48957       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
48958     } catch (std::out_of_range& e) {
48959       {
48960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48961       };
48962     } catch (std::exception& e) {
48963       {
48964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48965       };
48966     } catch (...) {
48967       {
48968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48969       };
48970     }
48971   }
48972
48973
48974 }
48975
48976
48977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
48978   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48979   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48980   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48981   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48982
48983   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48984   arg2 = jarg2;
48985   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48986   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
48987   {
48988     try {
48989       (arg1)->Insert(arg2,arg3,arg4);
48990     } catch (std::out_of_range& e) {
48991       {
48992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48993       };
48994     } catch (std::exception& e) {
48995       {
48996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48997       };
48998     } catch (...) {
48999       {
49000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49001       };
49002     }
49003   }
49004
49005
49006 }
49007
49008
49009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49010   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49011   Dali::Vector< unsigned char >::SizeType arg2 ;
49012
49013   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49014   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49015   {
49016     try {
49017       (arg1)->Reserve(arg2);
49018     } catch (std::out_of_range& e) {
49019       {
49020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49021       };
49022     } catch (std::exception& e) {
49023       {
49024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49025       };
49026     } catch (...) {
49027       {
49028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49029       };
49030     }
49031   }
49032 }
49033
49034
49035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49036   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49037   Dali::Vector< unsigned char >::SizeType arg2 ;
49038
49039   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49040   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49041   {
49042     try {
49043       (arg1)->Resize(arg2);
49044     } catch (std::out_of_range& e) {
49045       {
49046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49047       };
49048     } catch (std::exception& e) {
49049       {
49050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49051       };
49052     } catch (...) {
49053       {
49054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49055       };
49056     }
49057   }
49058 }
49059
49060
49061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49062   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49063   Dali::Vector< unsigned char >::SizeType arg2 ;
49064   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49065   Dali::Vector< unsigned char >::ItemType temp3 ;
49066
49067   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49068   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49069   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49070   arg3 = &temp3;
49071   {
49072     try {
49073       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49074     } catch (std::out_of_range& e) {
49075       {
49076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49077       };
49078     } catch (std::exception& e) {
49079       {
49080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49081       };
49082     } catch (...) {
49083       {
49084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49085       };
49086     }
49087   }
49088 }
49089
49090
49091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49092   void * jresult ;
49093   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49094   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49095   Dali::Vector< unsigned char >::Iterator result;
49096
49097   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49098   arg2 = jarg2;
49099   {
49100     try {
49101       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49102     } catch (std::out_of_range& e) {
49103       {
49104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49105       };
49106     } catch (std::exception& e) {
49107       {
49108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49109       };
49110     } catch (...) {
49111       {
49112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49113       };
49114     }
49115   }
49116   jresult = (void *)result;
49117
49118
49119   return jresult;
49120 }
49121
49122
49123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49124   void * jresult ;
49125   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49126   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49127   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49128   Dali::Vector< unsigned char >::Iterator result;
49129
49130   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49131   arg2 = jarg2;
49132   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49133   {
49134     try {
49135       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49136     } catch (std::out_of_range& e) {
49137       {
49138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49139       };
49140     } catch (std::exception& e) {
49141       {
49142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49143       };
49144     } catch (...) {
49145       {
49146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49147       };
49148     }
49149   }
49150   jresult = (void *)result;
49151
49152
49153   return jresult;
49154 }
49155
49156
49157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49158   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49159   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49160
49161   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49162   arg2 = jarg2;
49163   {
49164     try {
49165       (arg1)->Remove(arg2);
49166     } catch (std::out_of_range& e) {
49167       {
49168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49169       };
49170     } catch (std::exception& e) {
49171       {
49172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49173       };
49174     } catch (...) {
49175       {
49176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49177       };
49178     }
49179   }
49180
49181
49182 }
49183
49184
49185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49186   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49187   Dali::Vector< unsigned char > *arg2 = 0 ;
49188
49189   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49190   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49191   if (!arg2) {
49192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49193     return ;
49194   }
49195   {
49196     try {
49197       (arg1)->Swap(*arg2);
49198     } catch (std::out_of_range& e) {
49199       {
49200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49201       };
49202     } catch (std::exception& e) {
49203       {
49204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49205       };
49206     } catch (...) {
49207       {
49208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49209       };
49210     }
49211   }
49212 }
49213
49214
49215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
49216   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49217
49218   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49219   {
49220     try {
49221       (arg1)->Clear();
49222     } catch (std::out_of_range& e) {
49223       {
49224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49225       };
49226     } catch (std::exception& e) {
49227       {
49228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49229       };
49230     } catch (...) {
49231       {
49232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49233       };
49234     }
49235   }
49236 }
49237
49238
49239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49240   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49241
49242   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49243   {
49244     try {
49245       (arg1)->Release();
49246     } catch (std::out_of_range& e) {
49247       {
49248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49249       };
49250     } catch (std::exception& e) {
49251       {
49252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49253       };
49254     } catch (...) {
49255       {
49256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49257       };
49258     }
49259   }
49260 }
49261
49262
49263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
49264   int jresult ;
49265   int result;
49266
49267   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
49268   jresult = (int)result;
49269   return jresult;
49270 }
49271
49272
49273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
49274   void * jresult ;
49275   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49276
49277   {
49278     try {
49279       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
49280     } catch (std::out_of_range& e) {
49281       {
49282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49283       };
49284     } catch (std::exception& e) {
49285       {
49286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49287       };
49288     } catch (...) {
49289       {
49290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49291       };
49292     }
49293   }
49294   jresult = (void *)result;
49295   return jresult;
49296 }
49297
49298
49299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
49300   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49301
49302   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49303   {
49304     try {
49305       delete arg1;
49306     } catch (std::out_of_range& e) {
49307       {
49308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49309       };
49310     } catch (std::exception& e) {
49311       {
49312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49313       };
49314     } catch (...) {
49315       {
49316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49317       };
49318     }
49319   }
49320 }
49321
49322
49323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
49324   void * jresult ;
49325   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
49326   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49327
49328   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49329   if (!arg1) {
49330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49331     return 0;
49332   }
49333   {
49334     try {
49335       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
49336     } catch (std::out_of_range& e) {
49337       {
49338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49339       };
49340     } catch (std::exception& e) {
49341       {
49342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49343       };
49344     } catch (...) {
49345       {
49346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49347       };
49348     }
49349   }
49350   jresult = (void *)result;
49351   return jresult;
49352 }
49353
49354
49355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
49356   void * jresult ;
49357   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49358   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49359   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49360
49361   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49362   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49363   if (!arg2) {
49364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49365     return 0;
49366   }
49367   {
49368     try {
49369       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
49370     } catch (std::out_of_range& e) {
49371       {
49372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49373       };
49374     } catch (std::exception& e) {
49375       {
49376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49377       };
49378     } catch (...) {
49379       {
49380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49381       };
49382     }
49383   }
49384   jresult = (void *)result;
49385   return jresult;
49386 }
49387
49388
49389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
49390   void * jresult ;
49391   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49392   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49393
49394   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49395   {
49396     try {
49397       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
49398     } catch (std::out_of_range& e) {
49399       {
49400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49401       };
49402     } catch (std::exception& e) {
49403       {
49404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49405       };
49406     } catch (...) {
49407       {
49408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49409       };
49410     }
49411   }
49412   jresult = (void *)result;
49413   return jresult;
49414 }
49415
49416
49417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
49418   void * jresult ;
49419   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49420   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49421
49422   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49423   {
49424     try {
49425       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
49426     } catch (std::out_of_range& e) {
49427       {
49428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49429       };
49430     } catch (std::exception& e) {
49431       {
49432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49433       };
49434     } catch (...) {
49435       {
49436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49437       };
49438     }
49439   }
49440   jresult = (void *)result;
49441   return jresult;
49442 }
49443
49444
49445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49446   void * jresult ;
49447   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49448   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49449   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
49450
49451   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49452   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49453   {
49454     try {
49455       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
49456     } catch (std::out_of_range& e) {
49457       {
49458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49459       };
49460     } catch (std::exception& e) {
49461       {
49462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49463       };
49464     } catch (...) {
49465       {
49466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49467       };
49468     }
49469   }
49470   jresult = (void *)result;
49471   return jresult;
49472 }
49473
49474
49475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
49476   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49477   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
49478
49479   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49480   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
49481   if (!arg2) {
49482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49483     return ;
49484   }
49485   {
49486     try {
49487       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
49488     } catch (std::out_of_range& e) {
49489       {
49490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49491       };
49492     } catch (std::exception& e) {
49493       {
49494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49495       };
49496     } catch (...) {
49497       {
49498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49499       };
49500     }
49501   }
49502 }
49503
49504
49505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
49506   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49507   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49508   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49509
49510   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49511   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49512   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49513   if (!arg3) {
49514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49515     return ;
49516   }
49517   {
49518     try {
49519       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49520     } catch (std::out_of_range& e) {
49521       {
49522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49523       };
49524     } catch (std::exception& e) {
49525       {
49526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49527       };
49528     } catch (...) {
49529       {
49530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49531       };
49532     }
49533   }
49534 }
49535
49536
49537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49538   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49539   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49540   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49541   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49542
49543   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49544   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49545   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
49546   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
49547   {
49548     try {
49549       (arg1)->Insert(arg2,arg3,arg4);
49550     } catch (std::out_of_range& e) {
49551       {
49552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49553       };
49554     } catch (std::exception& e) {
49555       {
49556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49557       };
49558     } catch (...) {
49559       {
49560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49561       };
49562     }
49563   }
49564 }
49565
49566
49567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
49568   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49569   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49570
49571   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49572   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49573   {
49574     try {
49575       (arg1)->Reserve(arg2);
49576     } catch (std::out_of_range& e) {
49577       {
49578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49579       };
49580     } catch (std::exception& e) {
49581       {
49582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49583       };
49584     } catch (...) {
49585       {
49586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49587       };
49588     }
49589   }
49590 }
49591
49592
49593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49594   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49595   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49596
49597   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49598   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49599   {
49600     try {
49601       (arg1)->Resize(arg2);
49602     } catch (std::out_of_range& e) {
49603       {
49604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49605       };
49606     } catch (std::exception& e) {
49607       {
49608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49609       };
49610     } catch (...) {
49611       {
49612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49613       };
49614     }
49615   }
49616 }
49617
49618
49619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
49620   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49621   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49622   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49623
49624   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49625   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49626   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49627   if (!arg3) {
49628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49629     return ;
49630   }
49631   {
49632     try {
49633       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49634     } catch (std::out_of_range& e) {
49635       {
49636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49637       };
49638     } catch (std::exception& e) {
49639       {
49640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49641       };
49642     } catch (...) {
49643       {
49644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49645       };
49646     }
49647   }
49648 }
49649
49650
49651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
49652   void * jresult ;
49653   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49654   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49655   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49656
49657   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49658   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49659   {
49660     try {
49661       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
49662     } catch (std::out_of_range& e) {
49663       {
49664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49665       };
49666     } catch (std::exception& e) {
49667       {
49668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49669       };
49670     } catch (...) {
49671       {
49672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49673       };
49674     }
49675   }
49676   jresult = (void *)result;
49677   return jresult;
49678 }
49679
49680
49681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
49682   void * jresult ;
49683   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49684   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49685   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49686   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49687
49688   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49689   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49690   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
49691   {
49692     try {
49693       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
49694     } catch (std::out_of_range& e) {
49695       {
49696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49697       };
49698     } catch (std::exception& e) {
49699       {
49700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49701       };
49702     } catch (...) {
49703       {
49704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49705       };
49706     }
49707   }
49708   jresult = (void *)result;
49709   return jresult;
49710 }
49711
49712
49713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
49714   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49715   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49716
49717   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49718   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49719   {
49720     try {
49721       (arg1)->Remove(arg2);
49722     } catch (std::out_of_range& e) {
49723       {
49724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49725       };
49726     } catch (std::exception& e) {
49727       {
49728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49729       };
49730     } catch (...) {
49731       {
49732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49733       };
49734     }
49735   }
49736 }
49737
49738
49739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
49740   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49741   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49742
49743   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49744   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49745   if (!arg2) {
49746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
49747     return ;
49748   }
49749   {
49750     try {
49751       (arg1)->Swap(*arg2);
49752     } catch (std::out_of_range& e) {
49753       {
49754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49755       };
49756     } catch (std::exception& e) {
49757       {
49758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49759       };
49760     } catch (...) {
49761       {
49762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49763       };
49764     }
49765   }
49766 }
49767
49768
49769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
49770   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49771
49772   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49773   {
49774     try {
49775       (arg1)->Clear();
49776     } catch (std::out_of_range& e) {
49777       {
49778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49779       };
49780     } catch (std::exception& e) {
49781       {
49782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49783       };
49784     } catch (...) {
49785       {
49786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49787       };
49788     }
49789   }
49790 }
49791
49792
49793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
49794   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49795
49796   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49797   {
49798     try {
49799       (arg1)->Release();
49800     } catch (std::out_of_range& e) {
49801       {
49802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49803       };
49804     } catch (std::exception& e) {
49805       {
49806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49807       };
49808     } catch (...) {
49809       {
49810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49811       };
49812     }
49813   }
49814 }
49815
49816
49817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
49818   void * jresult ;
49819   Dali::Signal< void () > *result = 0 ;
49820
49821   {
49822     try {
49823       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
49824     } catch (std::out_of_range& e) {
49825       {
49826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49827       };
49828     } catch (std::exception& e) {
49829       {
49830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49831       };
49832     } catch (...) {
49833       {
49834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49835       };
49836     }
49837   }
49838   jresult = (void *)result;
49839   return jresult;
49840 }
49841
49842
49843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
49844   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49845
49846   arg1 = (Dali::Signal< void () > *)jarg1;
49847   {
49848     try {
49849       delete arg1;
49850     } catch (std::out_of_range& e) {
49851       {
49852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49853       };
49854     } catch (std::exception& e) {
49855       {
49856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49857       };
49858     } catch (...) {
49859       {
49860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49861       };
49862     }
49863   }
49864 }
49865
49866
49867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
49868   unsigned int jresult ;
49869   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49870   bool result;
49871
49872   arg1 = (Dali::Signal< void () > *)jarg1;
49873   {
49874     try {
49875       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
49876     } catch (std::out_of_range& e) {
49877       {
49878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49879       };
49880     } catch (std::exception& e) {
49881       {
49882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49883       };
49884     } catch (...) {
49885       {
49886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49887       };
49888     }
49889   }
49890   jresult = result;
49891   return jresult;
49892 }
49893
49894
49895 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
49896   unsigned long jresult ;
49897   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49898   std::size_t result;
49899
49900   arg1 = (Dali::Signal< void () > *)jarg1;
49901   {
49902     try {
49903       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
49904     } catch (std::out_of_range& e) {
49905       {
49906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49907       };
49908     } catch (std::exception& e) {
49909       {
49910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49911       };
49912     } catch (...) {
49913       {
49914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49915       };
49916     }
49917   }
49918   jresult = (unsigned long)result;
49919   return jresult;
49920 }
49921
49922
49923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
49924   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49925   void (*arg2)() = (void (*)()) 0 ;
49926
49927   arg1 = (Dali::Signal< void () > *)jarg1;
49928   arg2 = (void (*)())jarg2;
49929   {
49930     try {
49931       (arg1)->Connect(arg2);
49932     } catch (std::out_of_range& e) {
49933       {
49934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49935       };
49936     } catch (std::exception& e) {
49937       {
49938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49939       };
49940     } catch (...) {
49941       {
49942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49943       };
49944     }
49945   }
49946 }
49947
49948
49949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
49950   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49951   void (*arg2)() = (void (*)()) 0 ;
49952
49953   arg1 = (Dali::Signal< void () > *)jarg1;
49954   arg2 = (void (*)())jarg2;
49955   {
49956     try {
49957       (arg1)->Disconnect(arg2);
49958     } catch (std::out_of_range& e) {
49959       {
49960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49961       };
49962     } catch (std::exception& e) {
49963       {
49964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49965       };
49966     } catch (...) {
49967       {
49968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49969       };
49970     }
49971   }
49972 }
49973
49974
49975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
49976   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
49977   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
49978   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
49979
49980   arg1 = (Dali::Signal< void () > *)jarg1;
49981   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
49982   arg3 = (Dali::FunctorDelegate *)jarg3;
49983   {
49984     try {
49985       (arg1)->Connect(arg2,arg3);
49986     } catch (std::out_of_range& e) {
49987       {
49988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49989       };
49990     } catch (std::exception& e) {
49991       {
49992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49993       };
49994     } catch (...) {
49995       {
49996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49997       };
49998     }
49999   }
50000 }
50001
50002
50003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50004   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50005
50006   arg1 = (Dali::Signal< void () > *)jarg1;
50007   {
50008     try {
50009       (arg1)->Emit();
50010     } catch (std::out_of_range& e) {
50011       {
50012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50013       };
50014     } catch (std::exception& e) {
50015       {
50016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50017       };
50018     } catch (...) {
50019       {
50020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50021       };
50022     }
50023   }
50024 }
50025
50026
50027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BoolSignal() {
50028   void * jresult ;
50029   Dali::Signal< bool () > *result = 0 ;
50030
50031   {
50032     try {
50033       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
50034     } catch (std::out_of_range& e) {
50035       {
50036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50037       };
50038     } catch (std::exception& e) {
50039       {
50040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50041       };
50042     } catch (...) {
50043       {
50044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50045       };
50046     }
50047   }
50048   jresult = (void *)result;
50049   return jresult;
50050 }
50051
50052
50053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BoolSignal(void * jarg1) {
50054   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50055
50056   arg1 = (Dali::Signal< bool () > *)jarg1;
50057   {
50058     try {
50059       delete arg1;
50060     } catch (std::out_of_range& e) {
50061       {
50062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50063       };
50064     } catch (std::exception& e) {
50065       {
50066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50067       };
50068     } catch (...) {
50069       {
50070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50071       };
50072     }
50073   }
50074 }
50075
50076
50077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BoolSignal_Empty(void * jarg1) {
50078   unsigned int jresult ;
50079   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50080   bool result;
50081
50082   arg1 = (Dali::Signal< bool () > *)jarg1;
50083   {
50084     try {
50085       result = (bool)((Dali::Signal< bool () > const *)arg1)->Empty();
50086     } catch (std::out_of_range& e) {
50087       {
50088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50089       };
50090     } catch (std::exception& e) {
50091       {
50092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50093       };
50094     } catch (...) {
50095       {
50096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50097       };
50098     }
50099   }
50100   jresult = result;
50101   return jresult;
50102 }
50103
50104
50105 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_BoolSignal_GetConnectionCount(void * jarg1) {
50106   unsigned long jresult ;
50107   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50108   std::size_t result;
50109
50110   arg1 = (Dali::Signal< bool () > *)jarg1;
50111   {
50112     try {
50113       result = ((Dali::Signal< bool () > const *)arg1)->GetConnectionCount();
50114     } catch (std::out_of_range& e) {
50115       {
50116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50117       };
50118     } catch (std::exception& e) {
50119       {
50120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50121       };
50122     } catch (...) {
50123       {
50124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50125       };
50126     }
50127   }
50128   jresult = (unsigned long)result;
50129   return jresult;
50130 }
50131
50132
50133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BoolSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50134   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50135   bool (*arg2)() = (bool (*)()) 0 ;
50136
50137   arg1 = (Dali::Signal< bool () > *)jarg1;
50138   arg2 = (bool (*)())jarg2;
50139   {
50140     try {
50141       (arg1)->Connect(arg2);
50142     } catch (std::out_of_range& e) {
50143       {
50144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50145       };
50146     } catch (std::exception& e) {
50147       {
50148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50149       };
50150     } catch (...) {
50151       {
50152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50153       };
50154     }
50155   }
50156 }
50157
50158
50159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BoolSignal_Disconnect(void * jarg1, void * jarg2) {
50160   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50161   bool (*arg2)() = (bool (*)()) 0 ;
50162
50163   arg1 = (Dali::Signal< bool () > *)jarg1;
50164   arg2 = (bool (*)())jarg2;
50165   {
50166     try {
50167       (arg1)->Disconnect(arg2);
50168     } catch (std::out_of_range& e) {
50169       {
50170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50171       };
50172     } catch (std::exception& e) {
50173       {
50174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50175       };
50176     } catch (...) {
50177       {
50178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50179       };
50180     }
50181   }
50182 }
50183
50184
50185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BoolSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50186   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50187   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50188   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50189
50190   arg1 = (Dali::Signal< bool () > *)jarg1;
50191   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50192   arg3 = (Dali::FunctorDelegate *)jarg3;
50193   {
50194     try {
50195       (arg1)->Connect(arg2,arg3);
50196     } catch (std::out_of_range& e) {
50197       {
50198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50199       };
50200     } catch (std::exception& e) {
50201       {
50202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50203       };
50204     } catch (...) {
50205       {
50206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50207       };
50208     }
50209   }
50210 }
50211
50212
50213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BoolSignal_Emit(void * jarg1) {
50214   unsigned int jresult ;
50215   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
50216   bool result;
50217
50218   arg1 = (Dali::Signal< bool () > *)jarg1;
50219   {
50220     try {
50221       result = (bool)(arg1)->Emit();
50222     } catch (std::out_of_range& e) {
50223       {
50224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50225       };
50226     } catch (std::exception& e) {
50227       {
50228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50229       };
50230     } catch (...) {
50231       {
50232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50233       };
50234     }
50235   }
50236   jresult = result;
50237   return jresult;
50238 }
50239
50240
50241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50242   unsigned int jresult ;
50243   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50244   bool result;
50245
50246   arg1 = (Dali::Signal< void (float) > *)jarg1;
50247   {
50248     try {
50249       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50250     } catch (std::out_of_range& e) {
50251       {
50252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50253       };
50254     } catch (std::exception& e) {
50255       {
50256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50257       };
50258     } catch (...) {
50259       {
50260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50261       };
50262     }
50263   }
50264   jresult = result;
50265   return jresult;
50266 }
50267
50268
50269 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50270   unsigned long jresult ;
50271   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50272   std::size_t result;
50273
50274   arg1 = (Dali::Signal< void (float) > *)jarg1;
50275   {
50276     try {
50277       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50278     } catch (std::out_of_range& e) {
50279       {
50280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50281       };
50282     } catch (std::exception& e) {
50283       {
50284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50285       };
50286     } catch (...) {
50287       {
50288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50289       };
50290     }
50291   }
50292   jresult = (unsigned long)result;
50293   return jresult;
50294 }
50295
50296
50297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50298   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50299   void (*arg2)(float) = (void (*)(float)) 0 ;
50300
50301   arg1 = (Dali::Signal< void (float) > *)jarg1;
50302   arg2 = (void (*)(float))jarg2;
50303   {
50304     try {
50305       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50306     } catch (std::out_of_range& e) {
50307       {
50308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50309       };
50310     } catch (std::exception& e) {
50311       {
50312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50313       };
50314     } catch (...) {
50315       {
50316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50317       };
50318     }
50319   }
50320 }
50321
50322
50323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
50324   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50325   void (*arg2)(float) = (void (*)(float)) 0 ;
50326
50327   arg1 = (Dali::Signal< void (float) > *)jarg1;
50328   arg2 = (void (*)(float))jarg2;
50329   {
50330     try {
50331       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
50332     } catch (std::out_of_range& e) {
50333       {
50334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50335       };
50336     } catch (std::exception& e) {
50337       {
50338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50339       };
50340     } catch (...) {
50341       {
50342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50343       };
50344     }
50345   }
50346 }
50347
50348
50349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
50350   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50351   float arg2 ;
50352
50353   arg1 = (Dali::Signal< void (float) > *)jarg1;
50354   arg2 = (float)jarg2;
50355   {
50356     try {
50357       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
50358     } catch (std::out_of_range& e) {
50359       {
50360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50361       };
50362     } catch (std::exception& e) {
50363       {
50364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50365       };
50366     } catch (...) {
50367       {
50368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50369       };
50370     }
50371   }
50372 }
50373
50374
50375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
50376   void * jresult ;
50377   Dali::Signal< void (float) > *result = 0 ;
50378
50379   {
50380     try {
50381       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
50382     } catch (std::out_of_range& e) {
50383       {
50384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50385       };
50386     } catch (std::exception& e) {
50387       {
50388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50389       };
50390     } catch (...) {
50391       {
50392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50393       };
50394     }
50395   }
50396   jresult = (void *)result;
50397   return jresult;
50398 }
50399
50400
50401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
50402   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50403
50404   arg1 = (Dali::Signal< void (float) > *)jarg1;
50405   {
50406     try {
50407       delete arg1;
50408     } catch (std::out_of_range& e) {
50409       {
50410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50411       };
50412     } catch (std::exception& e) {
50413       {
50414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50415       };
50416     } catch (...) {
50417       {
50418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50419       };
50420     }
50421   }
50422 }
50423
50424
50425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
50426   unsigned int jresult ;
50427   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50428   bool result;
50429
50430   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50431   {
50432     try {
50433       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50434     } catch (std::out_of_range& e) {
50435       {
50436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50437       };
50438     } catch (std::exception& e) {
50439       {
50440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50441       };
50442     } catch (...) {
50443       {
50444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50445       };
50446     }
50447   }
50448   jresult = result;
50449   return jresult;
50450 }
50451
50452
50453 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
50454   unsigned long jresult ;
50455   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50456   std::size_t result;
50457
50458   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50459   {
50460     try {
50461       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50462     } catch (std::out_of_range& e) {
50463       {
50464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50465       };
50466     } catch (std::exception& e) {
50467       {
50468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50469       };
50470     } catch (...) {
50471       {
50472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50473       };
50474     }
50475   }
50476   jresult = (unsigned long)result;
50477   return jresult;
50478 }
50479
50480
50481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
50482   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50483   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50484
50485   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50486   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50487   {
50488     try {
50489       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
50490     } catch (std::out_of_range& e) {
50491       {
50492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50493       };
50494     } catch (std::exception& e) {
50495       {
50496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50497       };
50498     } catch (...) {
50499       {
50500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50501       };
50502     }
50503   }
50504 }
50505
50506
50507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
50508   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50509   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50510
50511   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50512   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50513   {
50514     try {
50515       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
50516     } catch (std::out_of_range& e) {
50517       {
50518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50519       };
50520     } catch (std::exception& e) {
50521       {
50522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50523       };
50524     } catch (...) {
50525       {
50526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50527       };
50528     }
50529   }
50530 }
50531
50532
50533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
50534   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50535   Dali::BaseHandle arg2 ;
50536   Dali::BaseHandle *argp2 ;
50537
50538   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50539   argp2 = (Dali::BaseHandle *)jarg2;
50540   if (!argp2) {
50541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50542     return ;
50543   }
50544   arg2 = *argp2;
50545   {
50546     try {
50547       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
50548     } catch (std::out_of_range& e) {
50549       {
50550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50551       };
50552     } catch (std::exception& e) {
50553       {
50554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50555       };
50556     } catch (...) {
50557       {
50558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50559       };
50560     }
50561   }
50562 }
50563
50564
50565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
50566   void * jresult ;
50567   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
50568
50569   {
50570     try {
50571       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
50572     } catch (std::out_of_range& e) {
50573       {
50574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50575       };
50576     } catch (std::exception& e) {
50577       {
50578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50579       };
50580     } catch (...) {
50581       {
50582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50583       };
50584     }
50585   }
50586   jresult = (void *)result;
50587   return jresult;
50588 }
50589
50590
50591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
50592   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50593
50594   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50595   {
50596     try {
50597       delete arg1;
50598     } catch (std::out_of_range& e) {
50599       {
50600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50601       };
50602     } catch (std::exception& e) {
50603       {
50604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50605       };
50606     } catch (...) {
50607       {
50608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50609       };
50610     }
50611   }
50612 }
50613
50614
50615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
50616   unsigned int jresult ;
50617   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50618   bool result;
50619
50620   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50621   {
50622     try {
50623       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50624     } catch (std::out_of_range& e) {
50625       {
50626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50627       };
50628     } catch (std::exception& e) {
50629       {
50630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50631       };
50632     } catch (...) {
50633       {
50634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50635       };
50636     }
50637   }
50638   jresult = result;
50639   return jresult;
50640 }
50641
50642
50643 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
50644   unsigned long jresult ;
50645   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50646   std::size_t result;
50647
50648   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50649   {
50650     try {
50651       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50652     } catch (std::out_of_range& e) {
50653       {
50654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50655       };
50656     } catch (std::exception& e) {
50657       {
50658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50659       };
50660     } catch (...) {
50661       {
50662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50663       };
50664     }
50665   }
50666   jresult = (unsigned long)result;
50667   return jresult;
50668 }
50669
50670
50671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
50672   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50673   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
50674
50675   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50676   arg2 = (void (*)(Dali::RefObject const *))jarg2;
50677   {
50678     try {
50679       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
50680     } catch (std::out_of_range& e) {
50681       {
50682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50683       };
50684     } catch (std::exception& e) {
50685       {
50686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50687       };
50688     } catch (...) {
50689       {
50690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50691       };
50692     }
50693   }
50694 }
50695
50696
50697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
50698   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50699   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
50700
50701   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50702   arg2 = (void (*)(Dali::RefObject const *))jarg2;
50703   {
50704     try {
50705       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
50706     } catch (std::out_of_range& e) {
50707       {
50708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50709       };
50710     } catch (std::exception& e) {
50711       {
50712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50713       };
50714     } catch (...) {
50715       {
50716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50717       };
50718     }
50719   }
50720 }
50721
50722
50723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
50724   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50725   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
50726
50727   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50728   arg2 = (Dali::RefObject *)jarg2;
50729   {
50730     try {
50731       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
50732     } catch (std::out_of_range& e) {
50733       {
50734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50735       };
50736     } catch (std::exception& e) {
50737       {
50738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50739       };
50740     } catch (...) {
50741       {
50742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50743       };
50744     }
50745   }
50746 }
50747
50748
50749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
50750   void * jresult ;
50751   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
50752
50753   {
50754     try {
50755       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
50756     } catch (std::out_of_range& e) {
50757       {
50758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50759       };
50760     } catch (std::exception& e) {
50761       {
50762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50763       };
50764     } catch (...) {
50765       {
50766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50767       };
50768     }
50769   }
50770   jresult = (void *)result;
50771   return jresult;
50772 }
50773
50774
50775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
50776   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50777
50778   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50779   {
50780     try {
50781       delete arg1;
50782     } catch (std::out_of_range& e) {
50783       {
50784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50785       };
50786     } catch (std::exception& e) {
50787       {
50788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50789       };
50790     } catch (...) {
50791       {
50792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50793       };
50794     }
50795   }
50796 }
50797
50798
50799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
50800   unsigned int jresult ;
50801   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50802   bool result;
50803
50804   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50805   {
50806     try {
50807       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
50808     } catch (std::out_of_range& e) {
50809       {
50810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50811       };
50812     } catch (std::exception& e) {
50813       {
50814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50815       };
50816     } catch (...) {
50817       {
50818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50819       };
50820     }
50821   }
50822   jresult = result;
50823   return jresult;
50824 }
50825
50826
50827 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
50828   unsigned long jresult ;
50829   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50830   std::size_t result;
50831
50832   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50833   {
50834     try {
50835       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
50836     } catch (std::out_of_range& e) {
50837       {
50838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50839       };
50840     } catch (std::exception& e) {
50841       {
50842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50843       };
50844     } catch (...) {
50845       {
50846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50847       };
50848     }
50849   }
50850   jresult = (unsigned long)result;
50851   return jresult;
50852 }
50853
50854
50855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
50856   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50857   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
50858
50859   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50860   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
50861   {
50862     try {
50863       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
50864     } catch (std::out_of_range& e) {
50865       {
50866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50867       };
50868     } catch (std::exception& e) {
50869       {
50870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50871       };
50872     } catch (...) {
50873       {
50874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50875       };
50876     }
50877   }
50878 }
50879
50880
50881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
50882   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50883   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
50884
50885   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50886   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
50887   {
50888     try {
50889       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
50890     } catch (std::out_of_range& e) {
50891       {
50892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50893       };
50894     } catch (std::exception& e) {
50895       {
50896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50897       };
50898     } catch (...) {
50899       {
50900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50901       };
50902     }
50903   }
50904 }
50905
50906
50907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
50908   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50909   Dali::PropertyNotification *arg2 = 0 ;
50910
50911   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50912   arg2 = (Dali::PropertyNotification *)jarg2;
50913   if (!arg2) {
50914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
50915     return ;
50916   }
50917   {
50918     try {
50919       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
50920     } catch (std::out_of_range& e) {
50921       {
50922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50923       };
50924     } catch (std::exception& e) {
50925       {
50926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50927       };
50928     } catch (...) {
50929       {
50930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50931       };
50932     }
50933   }
50934 }
50935
50936
50937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
50938   void * jresult ;
50939   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
50940
50941   {
50942     try {
50943       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
50944     } catch (std::out_of_range& e) {
50945       {
50946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50947       };
50948     } catch (std::exception& e) {
50949       {
50950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50951       };
50952     } catch (...) {
50953       {
50954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50955       };
50956     }
50957   }
50958   jresult = (void *)result;
50959   return jresult;
50960 }
50961
50962
50963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
50964   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
50965
50966   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
50967   {
50968     try {
50969       delete arg1;
50970     } catch (std::out_of_range& e) {
50971       {
50972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50973       };
50974     } catch (std::exception& e) {
50975       {
50976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50977       };
50978     } catch (...) {
50979       {
50980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50981       };
50982     }
50983   }
50984 }
50985
50986
50987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
50988   unsigned int jresult ;
50989   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
50990   bool result;
50991
50992   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
50993   {
50994     try {
50995       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
50996     } catch (std::out_of_range& e) {
50997       {
50998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50999       };
51000     } catch (std::exception& e) {
51001       {
51002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51003       };
51004     } catch (...) {
51005       {
51006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51007       };
51008     }
51009   }
51010   jresult = result;
51011   return jresult;
51012 }
51013
51014
51015 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
51016   unsigned long jresult ;
51017   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51018   std::size_t result;
51019
51020   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51021   {
51022     try {
51023       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
51024     } catch (std::out_of_range& e) {
51025       {
51026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51027       };
51028     } catch (std::exception& e) {
51029       {
51030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51031       };
51032     } catch (...) {
51033       {
51034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51035       };
51036     }
51037   }
51038   jresult = (unsigned long)result;
51039   return jresult;
51040 }
51041
51042
51043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
51044   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51045   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
51046
51047   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51048   arg2 = (void (*)(Dali::Image))jarg2;
51049   {
51050     try {
51051       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
51052     } catch (std::out_of_range& e) {
51053       {
51054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51055       };
51056     } catch (std::exception& e) {
51057       {
51058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51059       };
51060     } catch (...) {
51061       {
51062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51063       };
51064     }
51065   }
51066 }
51067
51068
51069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
51070   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51071   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
51072
51073   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51074   arg2 = (void (*)(Dali::Image))jarg2;
51075   {
51076     try {
51077       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
51078     } catch (std::out_of_range& e) {
51079       {
51080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51081       };
51082     } catch (std::exception& e) {
51083       {
51084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51085       };
51086     } catch (...) {
51087       {
51088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51089       };
51090     }
51091   }
51092 }
51093
51094
51095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
51096   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51097   Dali::Image arg2 ;
51098   Dali::Image *argp2 ;
51099
51100   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51101   argp2 = (Dali::Image *)jarg2;
51102   if (!argp2) {
51103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
51104     return ;
51105   }
51106   arg2 = *argp2;
51107   {
51108     try {
51109       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
51110     } catch (std::out_of_range& e) {
51111       {
51112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51113       };
51114     } catch (std::exception& e) {
51115       {
51116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51117       };
51118     } catch (...) {
51119       {
51120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51121       };
51122     }
51123   }
51124 }
51125
51126
51127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
51128   void * jresult ;
51129   Dali::Signal< void (Dali::Image) > *result = 0 ;
51130
51131   {
51132     try {
51133       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
51134     } catch (std::out_of_range& e) {
51135       {
51136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51137       };
51138     } catch (std::exception& e) {
51139       {
51140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51141       };
51142     } catch (...) {
51143       {
51144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51145       };
51146     }
51147   }
51148   jresult = (void *)result;
51149   return jresult;
51150 }
51151
51152
51153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
51154   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
51155
51156   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
51157   {
51158     try {
51159       delete arg1;
51160     } catch (std::out_of_range& e) {
51161       {
51162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51163       };
51164     } catch (std::exception& e) {
51165       {
51166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51167       };
51168     } catch (...) {
51169       {
51170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51171       };
51172     }
51173   }
51174 }
51175
51176
51177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51178   void * jresult ;
51179   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51180
51181   {
51182     try {
51183       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51184     } catch (std::out_of_range& e) {
51185       {
51186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51187       };
51188     } catch (std::exception& e) {
51189       {
51190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51191       };
51192     } catch (...) {
51193       {
51194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51195       };
51196     }
51197   }
51198   jresult = (void *)result;
51199   return jresult;
51200 }
51201
51202
51203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51204   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51205
51206   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51207   {
51208     try {
51209       delete arg1;
51210     } catch (std::out_of_range& e) {
51211       {
51212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51213       };
51214     } catch (std::exception& e) {
51215       {
51216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51217       };
51218     } catch (...) {
51219       {
51220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51221       };
51222     }
51223   }
51224 }
51225
51226
51227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51228   unsigned int jresult ;
51229   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51230   bool result;
51231
51232   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51233   {
51234     try {
51235       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);
51236     } catch (std::out_of_range& e) {
51237       {
51238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51239       };
51240     } catch (std::exception& e) {
51241       {
51242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51243       };
51244     } catch (...) {
51245       {
51246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51247       };
51248     }
51249   }
51250   jresult = result;
51251   return jresult;
51252 }
51253
51254
51255 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51256   unsigned long jresult ;
51257   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51258   std::size_t result;
51259
51260   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51261   {
51262     try {
51263       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);
51264     } catch (std::out_of_range& e) {
51265       {
51266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51267       };
51268     } catch (std::exception& e) {
51269       {
51270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51271       };
51272     } catch (...) {
51273       {
51274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51275       };
51276     }
51277   }
51278   jresult = (unsigned long)result;
51279   return jresult;
51280 }
51281
51282
51283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51284   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51285   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51286
51287   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51288   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51289   {
51290     try {
51291       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51292     } catch (std::out_of_range& e) {
51293       {
51294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51295       };
51296     } catch (std::exception& e) {
51297       {
51298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51299       };
51300     } catch (...) {
51301       {
51302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51303       };
51304     }
51305   }
51306 }
51307
51308
51309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51310   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51311   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51312
51313   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51314   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51315   {
51316     try {
51317       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51318     } catch (std::out_of_range& e) {
51319       {
51320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51321       };
51322     } catch (std::exception& e) {
51323       {
51324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51325       };
51326     } catch (...) {
51327       {
51328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51329       };
51330     }
51331   }
51332 }
51333
51334
51335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51336   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51337   Dali::Actor arg2 ;
51338   Dali::LongPressGesture *arg3 = 0 ;
51339   Dali::Actor *argp2 ;
51340
51341   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51342   argp2 = (Dali::Actor *)jarg2;
51343   if (!argp2) {
51344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51345     return ;
51346   }
51347   arg2 = *argp2;
51348   arg3 = (Dali::LongPressGesture *)jarg3;
51349   if (!arg3) {
51350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
51351     return ;
51352   }
51353   {
51354     try {
51355       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
51356     } catch (std::out_of_range& e) {
51357       {
51358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51359       };
51360     } catch (std::exception& e) {
51361       {
51362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51363       };
51364     } catch (...) {
51365       {
51366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51367       };
51368     }
51369   }
51370 }
51371
51372
51373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
51374   void * jresult ;
51375   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
51376
51377   {
51378     try {
51379       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
51380     } catch (std::out_of_range& e) {
51381       {
51382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51383       };
51384     } catch (std::exception& e) {
51385       {
51386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51387       };
51388     } catch (...) {
51389       {
51390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51391       };
51392     }
51393   }
51394   jresult = (void *)result;
51395   return jresult;
51396 }
51397
51398
51399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
51400   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51401
51402   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51403   {
51404     try {
51405       delete arg1;
51406     } catch (std::out_of_range& e) {
51407       {
51408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51409       };
51410     } catch (std::exception& e) {
51411       {
51412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51413       };
51414     } catch (...) {
51415       {
51416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51417       };
51418     }
51419   }
51420 }
51421
51422
51423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
51424   unsigned int jresult ;
51425   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51426   bool result;
51427
51428   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51429   {
51430     try {
51431       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);
51432     } catch (std::out_of_range& e) {
51433       {
51434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51435       };
51436     } catch (std::exception& e) {
51437       {
51438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51439       };
51440     } catch (...) {
51441       {
51442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51443       };
51444     }
51445   }
51446   jresult = result;
51447   return jresult;
51448 }
51449
51450
51451 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
51452   unsigned long jresult ;
51453   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51454   std::size_t result;
51455
51456   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51457   {
51458     try {
51459       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);
51460     } catch (std::out_of_range& e) {
51461       {
51462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51463       };
51464     } catch (std::exception& e) {
51465       {
51466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51467       };
51468     } catch (...) {
51469       {
51470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51471       };
51472     }
51473   }
51474   jresult = (unsigned long)result;
51475   return jresult;
51476 }
51477
51478
51479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
51480   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51481   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51482
51483   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51484   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51485   {
51486     try {
51487       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51488     } catch (std::out_of_range& e) {
51489       {
51490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51491       };
51492     } catch (std::exception& e) {
51493       {
51494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51495       };
51496     } catch (...) {
51497       {
51498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51499       };
51500     }
51501   }
51502 }
51503
51504
51505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
51506   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51507   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51508
51509   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51510   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51511   {
51512     try {
51513       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51514     } catch (std::out_of_range& e) {
51515       {
51516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51517       };
51518     } catch (std::exception& e) {
51519       {
51520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51521       };
51522     } catch (...) {
51523       {
51524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51525       };
51526     }
51527   }
51528 }
51529
51530
51531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51532   unsigned int jresult ;
51533   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51534   Dali::Actor arg2 ;
51535   Dali::TouchData *arg3 = 0 ;
51536   Dali::Actor *argp2 ;
51537   bool result;
51538
51539   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51540   argp2 = (Dali::Actor *)jarg2;
51541   if (!argp2) {
51542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51543     return 0;
51544   }
51545   arg2 = *argp2;
51546   arg3 = (Dali::TouchData *)jarg3;
51547   if (!arg3) {
51548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51549     return 0;
51550   }
51551   {
51552     try {
51553       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
51554     } catch (std::out_of_range& e) {
51555       {
51556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51557       };
51558     } catch (std::exception& e) {
51559       {
51560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51561       };
51562     } catch (...) {
51563       {
51564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51565       };
51566     }
51567   }
51568   jresult = result;
51569   return jresult;
51570 }
51571
51572
51573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
51574   void * jresult ;
51575   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
51576
51577   {
51578     try {
51579       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
51580     } catch (std::out_of_range& e) {
51581       {
51582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51583       };
51584     } catch (std::exception& e) {
51585       {
51586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51587       };
51588     } catch (...) {
51589       {
51590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51591       };
51592     }
51593   }
51594   jresult = (void *)result;
51595   return jresult;
51596 }
51597
51598
51599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
51600   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51601
51602   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51603   {
51604     try {
51605       delete arg1;
51606     } catch (std::out_of_range& e) {
51607       {
51608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51609       };
51610     } catch (std::exception& e) {
51611       {
51612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51613       };
51614     } catch (...) {
51615       {
51616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51617       };
51618     }
51619   }
51620 }
51621
51622
51623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
51624   unsigned int jresult ;
51625   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51626   bool result;
51627
51628   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51629   {
51630     try {
51631       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);
51632     } catch (std::out_of_range& e) {
51633       {
51634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51635       };
51636     } catch (std::exception& e) {
51637       {
51638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51639       };
51640     } catch (...) {
51641       {
51642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51643       };
51644     }
51645   }
51646   jresult = result;
51647   return jresult;
51648 }
51649
51650
51651 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
51652   unsigned long jresult ;
51653   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51654   std::size_t result;
51655
51656   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51657   {
51658     try {
51659       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);
51660     } catch (std::out_of_range& e) {
51661       {
51662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51663       };
51664     } catch (std::exception& e) {
51665       {
51666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51667       };
51668     } catch (...) {
51669       {
51670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51671       };
51672     }
51673   }
51674   jresult = (unsigned long)result;
51675   return jresult;
51676 }
51677
51678
51679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
51680   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51681   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51682
51683   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51684   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51685   {
51686     try {
51687       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51688     } catch (std::out_of_range& e) {
51689       {
51690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51691       };
51692     } catch (std::exception& e) {
51693       {
51694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51695       };
51696     } catch (...) {
51697       {
51698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51699       };
51700     }
51701   }
51702 }
51703
51704
51705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
51706   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51707   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51708
51709   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51710   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51711   {
51712     try {
51713       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51714     } catch (std::out_of_range& e) {
51715       {
51716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51717       };
51718     } catch (std::exception& e) {
51719       {
51720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51721       };
51722     } catch (...) {
51723       {
51724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51725       };
51726     }
51727   }
51728 }
51729
51730
51731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51732   unsigned int jresult ;
51733   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51734   Dali::Actor arg2 ;
51735   Dali::HoverEvent *arg3 = 0 ;
51736   Dali::Actor *argp2 ;
51737   bool result;
51738
51739   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51740   argp2 = (Dali::Actor *)jarg2;
51741   if (!argp2) {
51742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51743     return 0;
51744   }
51745   arg2 = *argp2;
51746   arg3 = (Dali::HoverEvent *)jarg3;
51747   if (!arg3) {
51748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
51749     return 0;
51750   }
51751   {
51752     try {
51753       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
51754     } catch (std::out_of_range& e) {
51755       {
51756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51757       };
51758     } catch (std::exception& e) {
51759       {
51760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51761       };
51762     } catch (...) {
51763       {
51764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51765       };
51766     }
51767   }
51768   jresult = result;
51769   return jresult;
51770 }
51771
51772
51773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
51774   void * jresult ;
51775   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
51776
51777   {
51778     try {
51779       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
51780     } catch (std::out_of_range& e) {
51781       {
51782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51783       };
51784     } catch (std::exception& e) {
51785       {
51786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51787       };
51788     } catch (...) {
51789       {
51790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51791       };
51792     }
51793   }
51794   jresult = (void *)result;
51795   return jresult;
51796 }
51797
51798
51799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
51800   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51801
51802   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51803   {
51804     try {
51805       delete arg1;
51806     } catch (std::out_of_range& e) {
51807       {
51808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51809       };
51810     } catch (std::exception& e) {
51811       {
51812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51813       };
51814     } catch (...) {
51815       {
51816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51817       };
51818     }
51819   }
51820 }
51821
51822
51823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
51824   unsigned int jresult ;
51825   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51826   bool result;
51827
51828   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51829   {
51830     try {
51831       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);
51832     } catch (std::out_of_range& e) {
51833       {
51834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51835       };
51836     } catch (std::exception& e) {
51837       {
51838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51839       };
51840     } catch (...) {
51841       {
51842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51843       };
51844     }
51845   }
51846   jresult = result;
51847   return jresult;
51848 }
51849
51850
51851 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
51852   unsigned long jresult ;
51853   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51854   std::size_t result;
51855
51856   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51857   {
51858     try {
51859       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);
51860     } catch (std::out_of_range& e) {
51861       {
51862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51863       };
51864     } catch (std::exception& e) {
51865       {
51866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51867       };
51868     } catch (...) {
51869       {
51870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51871       };
51872     }
51873   }
51874   jresult = (unsigned long)result;
51875   return jresult;
51876 }
51877
51878
51879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
51880   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51881   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
51882
51883   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51884   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
51885   {
51886     try {
51887       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51888     } catch (std::out_of_range& e) {
51889       {
51890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51891       };
51892     } catch (std::exception& e) {
51893       {
51894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51895       };
51896     } catch (...) {
51897       {
51898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51899       };
51900     }
51901   }
51902 }
51903
51904
51905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51906   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51907   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
51908
51909   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51910   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
51911   {
51912     try {
51913       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51914     } catch (std::out_of_range& e) {
51915       {
51916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51917       };
51918     } catch (std::exception& e) {
51919       {
51920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51921       };
51922     } catch (...) {
51923       {
51924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51925       };
51926     }
51927   }
51928 }
51929
51930
51931 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51932   unsigned int jresult ;
51933   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
51934   Dali::Actor arg2 ;
51935   Dali::WheelEvent *arg3 = 0 ;
51936   Dali::Actor *argp2 ;
51937   bool result;
51938
51939   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
51940   argp2 = (Dali::Actor *)jarg2;
51941   if (!argp2) {
51942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51943     return 0;
51944   }
51945   arg2 = *argp2;
51946   arg3 = (Dali::WheelEvent *)jarg3;
51947   if (!arg3) {
51948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51949     return 0;
51950   }
51951   {
51952     try {
51953       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
51954     } catch (std::out_of_range& e) {
51955       {
51956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51957       };
51958     } catch (std::exception& e) {
51959       {
51960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51961       };
51962     } catch (...) {
51963       {
51964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51965       };
51966     }
51967   }
51968   jresult = result;
51969   return jresult;
51970 }
51971
51972
51973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
51974   void * jresult ;
51975   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
51976
51977   {
51978     try {
51979       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
51980     } catch (std::out_of_range& e) {
51981       {
51982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51983       };
51984     } catch (std::exception& e) {
51985       {
51986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51987       };
51988     } catch (...) {
51989       {
51990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51991       };
51992     }
51993   }
51994   jresult = (void *)result;
51995   return jresult;
51996 }
51997
51998
51999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52000   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52001
52002   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52003   {
52004     try {
52005       delete arg1;
52006     } catch (std::out_of_range& e) {
52007       {
52008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52009       };
52010     } catch (std::exception& e) {
52011       {
52012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52013       };
52014     } catch (...) {
52015       {
52016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52017       };
52018     }
52019   }
52020 }
52021
52022
52023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52024   unsigned int jresult ;
52025   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52026   bool result;
52027
52028   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52029   {
52030     try {
52031       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52032     } catch (std::out_of_range& e) {
52033       {
52034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52035       };
52036     } catch (std::exception& e) {
52037       {
52038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52039       };
52040     } catch (...) {
52041       {
52042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52043       };
52044     }
52045   }
52046   jresult = result;
52047   return jresult;
52048 }
52049
52050
52051 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52052   unsigned long jresult ;
52053   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52054   std::size_t result;
52055
52056   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52057   {
52058     try {
52059       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52060     } catch (std::out_of_range& e) {
52061       {
52062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52063       };
52064     } catch (std::exception& e) {
52065       {
52066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52067       };
52068     } catch (...) {
52069       {
52070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52071       };
52072     }
52073   }
52074   jresult = (unsigned long)result;
52075   return jresult;
52076 }
52077
52078
52079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52080   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52081   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52082
52083   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52084   arg2 = (void (*)(Dali::Actor))jarg2;
52085   {
52086     try {
52087       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52088     } catch (std::out_of_range& e) {
52089       {
52090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52091       };
52092     } catch (std::exception& e) {
52093       {
52094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52095       };
52096     } catch (...) {
52097       {
52098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52099       };
52100     }
52101   }
52102 }
52103
52104
52105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52106   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52107   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52108
52109   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52110   arg2 = (void (*)(Dali::Actor))jarg2;
52111   {
52112     try {
52113       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52114     } catch (std::out_of_range& e) {
52115       {
52116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52117       };
52118     } catch (std::exception& e) {
52119       {
52120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52121       };
52122     } catch (...) {
52123       {
52124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52125       };
52126     }
52127   }
52128 }
52129
52130
52131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52132   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52133   Dali::Actor arg2 ;
52134   Dali::Actor *argp2 ;
52135
52136   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52137   argp2 = (Dali::Actor *)jarg2;
52138   if (!argp2) {
52139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52140     return ;
52141   }
52142   arg2 = *argp2;
52143   {
52144     try {
52145       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52146     } catch (std::out_of_range& e) {
52147       {
52148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52149       };
52150     } catch (std::exception& e) {
52151       {
52152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52153       };
52154     } catch (...) {
52155       {
52156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52157       };
52158     }
52159   }
52160 }
52161
52162
52163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52164   void * jresult ;
52165   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52166
52167   {
52168     try {
52169       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52170     } catch (std::out_of_range& e) {
52171       {
52172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52173       };
52174     } catch (std::exception& e) {
52175       {
52176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52177       };
52178     } catch (...) {
52179       {
52180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52181       };
52182     }
52183   }
52184   jresult = (void *)result;
52185   return jresult;
52186 }
52187
52188
52189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
52190   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52191
52192   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52193   {
52194     try {
52195       delete arg1;
52196     } catch (std::out_of_range& e) {
52197       {
52198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52199       };
52200     } catch (std::exception& e) {
52201       {
52202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52203       };
52204     } catch (...) {
52205       {
52206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52207       };
52208     }
52209   }
52210 }
52211
52212
52213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
52214   unsigned int jresult ;
52215   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52216   bool result;
52217
52218   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52219   {
52220     try {
52221       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52222     } catch (std::out_of_range& e) {
52223       {
52224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52225       };
52226     } catch (std::exception& e) {
52227       {
52228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52229       };
52230     } catch (...) {
52231       {
52232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52233       };
52234     }
52235   }
52236   jresult = result;
52237   return jresult;
52238 }
52239
52240
52241 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
52242   unsigned long jresult ;
52243   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52244   std::size_t result;
52245
52246   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52247   {
52248     try {
52249       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52250     } catch (std::out_of_range& e) {
52251       {
52252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52253       };
52254     } catch (std::exception& e) {
52255       {
52256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52257       };
52258     } catch (...) {
52259       {
52260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52261       };
52262     }
52263   }
52264   jresult = (unsigned long)result;
52265   return jresult;
52266 }
52267
52268
52269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
52270   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52271   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52272
52273   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52274   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52275   {
52276     try {
52277       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52278     } catch (std::out_of_range& e) {
52279       {
52280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52281       };
52282     } catch (std::exception& e) {
52283       {
52284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52285       };
52286     } catch (...) {
52287       {
52288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52289       };
52290     }
52291   }
52292 }
52293
52294
52295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
52296   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52297   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52298
52299   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52300   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52301   {
52302     try {
52303       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52304     } catch (std::out_of_range& e) {
52305       {
52306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52307       };
52308     } catch (std::exception& e) {
52309       {
52310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52311       };
52312     } catch (...) {
52313       {
52314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52315       };
52316     }
52317   }
52318 }
52319
52320
52321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
52322   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52323   Dali::KeyEvent *arg2 = 0 ;
52324
52325   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52326   arg2 = (Dali::KeyEvent *)jarg2;
52327   if (!arg2) {
52328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
52329     return ;
52330   }
52331   {
52332     try {
52333       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
52334     } catch (std::out_of_range& e) {
52335       {
52336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52337       };
52338     } catch (std::exception& e) {
52339       {
52340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52341       };
52342     } catch (...) {
52343       {
52344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52345       };
52346     }
52347   }
52348 }
52349
52350
52351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
52352   void * jresult ;
52353   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
52354
52355   {
52356     try {
52357       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
52358     } catch (std::out_of_range& e) {
52359       {
52360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52361       };
52362     } catch (std::exception& e) {
52363       {
52364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52365       };
52366     } catch (...) {
52367       {
52368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52369       };
52370     }
52371   }
52372   jresult = (void *)result;
52373   return jresult;
52374 }
52375
52376
52377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
52378   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52379
52380   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52381   {
52382     try {
52383       delete arg1;
52384     } catch (std::out_of_range& e) {
52385       {
52386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52387       };
52388     } catch (std::exception& e) {
52389       {
52390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52391       };
52392     } catch (...) {
52393       {
52394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52395       };
52396     }
52397   }
52398 }
52399
52400
52401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
52402   unsigned int jresult ;
52403   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52404   bool result;
52405
52406   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52407   {
52408     try {
52409       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
52410     } catch (std::out_of_range& e) {
52411       {
52412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52413       };
52414     } catch (std::exception& e) {
52415       {
52416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52417       };
52418     } catch (...) {
52419       {
52420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52421       };
52422     }
52423   }
52424   jresult = result;
52425   return jresult;
52426 }
52427
52428
52429 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
52430   unsigned long jresult ;
52431   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52432   std::size_t result;
52433
52434   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52435   {
52436     try {
52437       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
52438     } catch (std::out_of_range& e) {
52439       {
52440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52441       };
52442     } catch (std::exception& e) {
52443       {
52444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52445       };
52446     } catch (...) {
52447       {
52448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52449       };
52450     }
52451   }
52452   jresult = (unsigned long)result;
52453   return jresult;
52454 }
52455
52456
52457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
52458   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52459   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
52460
52461   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52462   arg2 = (void (*)(Dali::TouchData const &))jarg2;
52463   {
52464     try {
52465       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52466     } catch (std::out_of_range& e) {
52467       {
52468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52469       };
52470     } catch (std::exception& e) {
52471       {
52472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52473       };
52474     } catch (...) {
52475       {
52476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52477       };
52478     }
52479   }
52480 }
52481
52482
52483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
52484   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52485   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
52486
52487   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52488   arg2 = (void (*)(Dali::TouchData const &))jarg2;
52489   {
52490     try {
52491       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52492     } catch (std::out_of_range& e) {
52493       {
52494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52495       };
52496     } catch (std::exception& e) {
52497       {
52498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52499       };
52500     } catch (...) {
52501       {
52502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52503       };
52504     }
52505   }
52506 }
52507
52508
52509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
52510   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52511   Dali::TouchData *arg2 = 0 ;
52512
52513   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52514   arg2 = (Dali::TouchData *)jarg2;
52515   if (!arg2) {
52516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
52517     return ;
52518   }
52519   {
52520     try {
52521       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
52522     } catch (std::out_of_range& e) {
52523       {
52524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52525       };
52526     } catch (std::exception& e) {
52527       {
52528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52529       };
52530     } catch (...) {
52531       {
52532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52533       };
52534     }
52535   }
52536 }
52537
52538
52539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
52540   void * jresult ;
52541   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
52542
52543   {
52544     try {
52545       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
52546     } catch (std::out_of_range& e) {
52547       {
52548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52549       };
52550     } catch (std::exception& e) {
52551       {
52552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52553       };
52554     } catch (...) {
52555       {
52556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52557       };
52558     }
52559   }
52560   jresult = (void *)result;
52561   return jresult;
52562 }
52563
52564
52565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
52566   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52567
52568   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52569   {
52570     try {
52571       delete arg1;
52572     } catch (std::out_of_range& e) {
52573       {
52574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52575       };
52576     } catch (std::exception& e) {
52577       {
52578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52579       };
52580     } catch (...) {
52581       {
52582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52583       };
52584     }
52585   }
52586 }
52587
52588
52589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
52590   unsigned int jresult ;
52591   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52592   bool result;
52593
52594   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52595   {
52596     try {
52597       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
52598     } catch (std::out_of_range& e) {
52599       {
52600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52601       };
52602     } catch (std::exception& e) {
52603       {
52604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52605       };
52606     } catch (...) {
52607       {
52608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52609       };
52610     }
52611   }
52612   jresult = result;
52613   return jresult;
52614 }
52615
52616
52617 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
52618   unsigned long jresult ;
52619   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52620   std::size_t result;
52621
52622   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52623   {
52624     try {
52625       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
52626     } catch (std::out_of_range& e) {
52627       {
52628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52629       };
52630     } catch (std::exception& e) {
52631       {
52632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52633       };
52634     } catch (...) {
52635       {
52636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52637       };
52638     }
52639   }
52640   jresult = (unsigned long)result;
52641   return jresult;
52642 }
52643
52644
52645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
52646   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52647   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
52648
52649   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52650   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
52651   {
52652     try {
52653       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52654     } catch (std::out_of_range& e) {
52655       {
52656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52657       };
52658     } catch (std::exception& e) {
52659       {
52660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52661       };
52662     } catch (...) {
52663       {
52664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52665       };
52666     }
52667   }
52668 }
52669
52670
52671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52672   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52673   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
52674
52675   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52676   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
52677   {
52678     try {
52679       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52680     } catch (std::out_of_range& e) {
52681       {
52682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52683       };
52684     } catch (std::exception& e) {
52685       {
52686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52687       };
52688     } catch (...) {
52689       {
52690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52691       };
52692     }
52693   }
52694 }
52695
52696
52697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
52698   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52699   Dali::WheelEvent *arg2 = 0 ;
52700
52701   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52702   arg2 = (Dali::WheelEvent *)jarg2;
52703   if (!arg2) {
52704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52705     return ;
52706   }
52707   {
52708     try {
52709       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
52710     } catch (std::out_of_range& e) {
52711       {
52712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52713       };
52714     } catch (std::exception& e) {
52715       {
52716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52717       };
52718     } catch (...) {
52719       {
52720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52721       };
52722     }
52723   }
52724 }
52725
52726
52727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
52728   void * jresult ;
52729   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
52730
52731   {
52732     try {
52733       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
52734     } catch (std::out_of_range& e) {
52735       {
52736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52737       };
52738     } catch (std::exception& e) {
52739       {
52740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52741       };
52742     } catch (...) {
52743       {
52744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52745       };
52746     }
52747   }
52748   jresult = (void *)result;
52749   return jresult;
52750 }
52751
52752
52753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
52754   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52755
52756   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52757   {
52758     try {
52759       delete arg1;
52760     } catch (std::out_of_range& e) {
52761       {
52762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52763       };
52764     } catch (std::exception& e) {
52765       {
52766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52767       };
52768     } catch (...) {
52769       {
52770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52771       };
52772     }
52773   }
52774 }
52775
52776
52777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
52778   void * jresult ;
52779   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
52780
52781   {
52782     try {
52783       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
52784     } catch (std::out_of_range& e) {
52785       {
52786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52787       };
52788     } catch (std::exception& e) {
52789       {
52790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52791       };
52792     } catch (...) {
52793       {
52794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52795       };
52796     }
52797   }
52798   jresult = (void *)result;
52799   return jresult;
52800 }
52801
52802
52803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
52804   void * jresult ;
52805   Dali::Radian arg1 ;
52806   Dali::Radian arg2 ;
52807   Dali::Radian *argp1 ;
52808   Dali::Radian *argp2 ;
52809   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
52810
52811   argp1 = (Dali::Radian *)jarg1;
52812   if (!argp1) {
52813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
52814     return 0;
52815   }
52816   arg1 = *argp1;
52817   argp2 = (Dali::Radian *)jarg2;
52818   if (!argp2) {
52819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
52820     return 0;
52821   }
52822   arg2 = *argp2;
52823   {
52824     try {
52825       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
52826     } catch (std::out_of_range& e) {
52827       {
52828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52829       };
52830     } catch (std::exception& e) {
52831       {
52832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52833       };
52834     } catch (...) {
52835       {
52836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52837       };
52838     }
52839   }
52840   jresult = (void *)result;
52841   return jresult;
52842 }
52843
52844
52845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
52846   void * jresult ;
52847   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
52848   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
52849
52850   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52851   if (!arg1) {
52852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
52853     return 0;
52854   }
52855   {
52856     try {
52857       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
52858     } catch (std::out_of_range& e) {
52859       {
52860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52861       };
52862     } catch (std::exception& e) {
52863       {
52864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52865       };
52866     } catch (...) {
52867       {
52868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52869       };
52870     }
52871   }
52872   jresult = (void *)result;
52873   return jresult;
52874 }
52875
52876
52877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
52878   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52879   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
52880
52881   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52882   arg2 = (Dali::Radian *)jarg2;
52883   if (arg1) (arg1)->first = *arg2;
52884 }
52885
52886
52887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
52888   void * jresult ;
52889   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52890   Dali::Radian *result = 0 ;
52891
52892   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52893   result = (Dali::Radian *)& ((arg1)->first);
52894   jresult = (void *)result;
52895   return jresult;
52896 }
52897
52898
52899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
52900   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52901   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
52902
52903   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52904   arg2 = (Dali::Radian *)jarg2;
52905   if (arg1) (arg1)->second = *arg2;
52906 }
52907
52908
52909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
52910   void * jresult ;
52911   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52912   Dali::Radian *result = 0 ;
52913
52914   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52915   result = (Dali::Radian *)& ((arg1)->second);
52916   jresult = (void *)result;
52917   return jresult;
52918 }
52919
52920
52921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
52922   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
52923
52924   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
52925   {
52926     try {
52927       delete arg1;
52928     } catch (std::out_of_range& e) {
52929       {
52930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52931       };
52932     } catch (std::exception& e) {
52933       {
52934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52935       };
52936     } catch (...) {
52937       {
52938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52939       };
52940     }
52941   }
52942 }
52943
52944
52945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
52946   unsigned int jresult ;
52947   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
52948   bool result;
52949
52950   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
52951   {
52952     try {
52953       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);
52954     } catch (std::out_of_range& e) {
52955       {
52956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52957       };
52958     } catch (std::exception& e) {
52959       {
52960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52961       };
52962     } catch (...) {
52963       {
52964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52965       };
52966     }
52967   }
52968   jresult = result;
52969   return jresult;
52970 }
52971
52972
52973 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52974   unsigned long jresult ;
52975   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
52976   std::size_t result;
52977
52978   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
52979   {
52980     try {
52981       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);
52982     } catch (std::out_of_range& e) {
52983       {
52984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52985       };
52986     } catch (std::exception& e) {
52987       {
52988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52989       };
52990     } catch (...) {
52991       {
52992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52993       };
52994     }
52995   }
52996   jresult = (unsigned long)result;
52997   return jresult;
52998 }
52999
53000
53001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53002   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53003   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53004
53005   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53006   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53007   {
53008     try {
53009       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53010     } catch (std::out_of_range& e) {
53011       {
53012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53013       };
53014     } catch (std::exception& e) {
53015       {
53016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53017       };
53018     } catch (...) {
53019       {
53020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53021       };
53022     }
53023   }
53024 }
53025
53026
53027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53028   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53029   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53030
53031   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53032   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53033   {
53034     try {
53035       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53036     } catch (std::out_of_range& e) {
53037       {
53038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53039       };
53040     } catch (std::exception& e) {
53041       {
53042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53043       };
53044     } catch (...) {
53045       {
53046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53047       };
53048     }
53049   }
53050 }
53051
53052
53053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53054   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53055   Dali::Actor arg2 ;
53056   Dali::PanGesture *arg3 = 0 ;
53057   Dali::Actor *argp2 ;
53058
53059   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53060   argp2 = (Dali::Actor *)jarg2;
53061   if (!argp2) {
53062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53063     return ;
53064   }
53065   arg2 = *argp2;
53066   arg3 = (Dali::PanGesture *)jarg3;
53067   if (!arg3) {
53068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
53069     return ;
53070   }
53071   {
53072     try {
53073       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
53074     } catch (std::out_of_range& e) {
53075       {
53076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53077       };
53078     } catch (std::exception& e) {
53079       {
53080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53081       };
53082     } catch (...) {
53083       {
53084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53085       };
53086     }
53087   }
53088 }
53089
53090
53091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
53092   void * jresult ;
53093   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
53094
53095   {
53096     try {
53097       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
53098     } catch (std::out_of_range& e) {
53099       {
53100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53101       };
53102     } catch (std::exception& e) {
53103       {
53104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53105       };
53106     } catch (...) {
53107       {
53108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53109       };
53110     }
53111   }
53112   jresult = (void *)result;
53113   return jresult;
53114 }
53115
53116
53117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
53118   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53119
53120   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53121   {
53122     try {
53123       delete arg1;
53124     } catch (std::out_of_range& e) {
53125       {
53126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53127       };
53128     } catch (std::exception& e) {
53129       {
53130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53131       };
53132     } catch (...) {
53133       {
53134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53135       };
53136     }
53137   }
53138 }
53139
53140
53141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
53142   unsigned int jresult ;
53143   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53144   bool result;
53145
53146   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53147   {
53148     try {
53149       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);
53150     } catch (std::out_of_range& e) {
53151       {
53152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53153       };
53154     } catch (std::exception& e) {
53155       {
53156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53157       };
53158     } catch (...) {
53159       {
53160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53161       };
53162     }
53163   }
53164   jresult = result;
53165   return jresult;
53166 }
53167
53168
53169 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53170   unsigned long jresult ;
53171   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53172   std::size_t result;
53173
53174   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53175   {
53176     try {
53177       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);
53178     } catch (std::out_of_range& e) {
53179       {
53180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53181       };
53182     } catch (std::exception& e) {
53183       {
53184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53185       };
53186     } catch (...) {
53187       {
53188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53189       };
53190     }
53191   }
53192   jresult = (unsigned long)result;
53193   return jresult;
53194 }
53195
53196
53197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53198   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53199   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53200
53201   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53202   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53203   {
53204     try {
53205       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53206     } catch (std::out_of_range& e) {
53207       {
53208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53209       };
53210     } catch (std::exception& e) {
53211       {
53212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53213       };
53214     } catch (...) {
53215       {
53216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53217       };
53218     }
53219   }
53220 }
53221
53222
53223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53224   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53225   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53226
53227   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53228   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53229   {
53230     try {
53231       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53232     } catch (std::out_of_range& e) {
53233       {
53234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53235       };
53236     } catch (std::exception& e) {
53237       {
53238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53239       };
53240     } catch (...) {
53241       {
53242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53243       };
53244     }
53245   }
53246 }
53247
53248
53249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53250   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53251   Dali::Actor arg2 ;
53252   Dali::PinchGesture *arg3 = 0 ;
53253   Dali::Actor *argp2 ;
53254
53255   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53256   argp2 = (Dali::Actor *)jarg2;
53257   if (!argp2) {
53258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53259     return ;
53260   }
53261   arg2 = *argp2;
53262   arg3 = (Dali::PinchGesture *)jarg3;
53263   if (!arg3) {
53264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
53265     return ;
53266   }
53267   {
53268     try {
53269       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
53270     } catch (std::out_of_range& e) {
53271       {
53272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53273       };
53274     } catch (std::exception& e) {
53275       {
53276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53277       };
53278     } catch (...) {
53279       {
53280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53281       };
53282     }
53283   }
53284 }
53285
53286
53287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
53288   void * jresult ;
53289   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
53290
53291   {
53292     try {
53293       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
53294     } catch (std::out_of_range& e) {
53295       {
53296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53297       };
53298     } catch (std::exception& e) {
53299       {
53300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53301       };
53302     } catch (...) {
53303       {
53304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53305       };
53306     }
53307   }
53308   jresult = (void *)result;
53309   return jresult;
53310 }
53311
53312
53313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
53314   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53315
53316   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53317   {
53318     try {
53319       delete arg1;
53320     } catch (std::out_of_range& e) {
53321       {
53322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53323       };
53324     } catch (std::exception& e) {
53325       {
53326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53327       };
53328     } catch (...) {
53329       {
53330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53331       };
53332     }
53333   }
53334 }
53335
53336
53337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
53338   unsigned int jresult ;
53339   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53340   bool result;
53341
53342   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53343   {
53344     try {
53345       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);
53346     } catch (std::out_of_range& e) {
53347       {
53348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53349       };
53350     } catch (std::exception& e) {
53351       {
53352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53353       };
53354     } catch (...) {
53355       {
53356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53357       };
53358     }
53359   }
53360   jresult = result;
53361   return jresult;
53362 }
53363
53364
53365 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53366   unsigned long jresult ;
53367   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53368   std::size_t result;
53369
53370   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53371   {
53372     try {
53373       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);
53374     } catch (std::out_of_range& e) {
53375       {
53376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53377       };
53378     } catch (std::exception& e) {
53379       {
53380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53381       };
53382     } catch (...) {
53383       {
53384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53385       };
53386     }
53387   }
53388   jresult = (unsigned long)result;
53389   return jresult;
53390 }
53391
53392
53393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53394   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53395   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53396
53397   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53398   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53399   {
53400     try {
53401       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53402     } catch (std::out_of_range& e) {
53403       {
53404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53405       };
53406     } catch (std::exception& e) {
53407       {
53408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53409       };
53410     } catch (...) {
53411       {
53412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53413       };
53414     }
53415   }
53416 }
53417
53418
53419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53420   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53421   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53422
53423   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53424   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53425   {
53426     try {
53427       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53428     } catch (std::out_of_range& e) {
53429       {
53430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53431       };
53432     } catch (std::exception& e) {
53433       {
53434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53435       };
53436     } catch (...) {
53437       {
53438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53439       };
53440     }
53441   }
53442 }
53443
53444
53445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53446   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53447   Dali::Actor arg2 ;
53448   Dali::TapGesture *arg3 = 0 ;
53449   Dali::Actor *argp2 ;
53450
53451   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53452   argp2 = (Dali::Actor *)jarg2;
53453   if (!argp2) {
53454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53455     return ;
53456   }
53457   arg2 = *argp2;
53458   arg3 = (Dali::TapGesture *)jarg3;
53459   if (!arg3) {
53460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
53461     return ;
53462   }
53463   {
53464     try {
53465       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
53466     } catch (std::out_of_range& e) {
53467       {
53468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53469       };
53470     } catch (std::exception& e) {
53471       {
53472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53473       };
53474     } catch (...) {
53475       {
53476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53477       };
53478     }
53479   }
53480 }
53481
53482
53483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
53484   void * jresult ;
53485   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
53486
53487   {
53488     try {
53489       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
53490     } catch (std::out_of_range& e) {
53491       {
53492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53493       };
53494     } catch (std::exception& e) {
53495       {
53496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53497       };
53498     } catch (...) {
53499       {
53500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53501       };
53502     }
53503   }
53504   jresult = (void *)result;
53505   return jresult;
53506 }
53507
53508
53509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
53510   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53511
53512   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53513   {
53514     try {
53515       delete arg1;
53516     } catch (std::out_of_range& e) {
53517       {
53518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53519       };
53520     } catch (std::exception& e) {
53521       {
53522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53523       };
53524     } catch (...) {
53525       {
53526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53527       };
53528     }
53529   }
53530 }
53531
53532
53533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
53534   unsigned int jresult ;
53535   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53536   bool result;
53537
53538   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53539   {
53540     try {
53541       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
53542     } catch (std::out_of_range& e) {
53543       {
53544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53545       };
53546     } catch (std::exception& e) {
53547       {
53548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53549       };
53550     } catch (...) {
53551       {
53552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53553       };
53554     }
53555   }
53556   jresult = result;
53557   return jresult;
53558 }
53559
53560
53561 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
53562   unsigned long jresult ;
53563   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53564   std::size_t result;
53565
53566   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53567   {
53568     try {
53569       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
53570     } catch (std::out_of_range& e) {
53571       {
53572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53573       };
53574     } catch (std::exception& e) {
53575       {
53576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53577       };
53578     } catch (...) {
53579       {
53580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53581       };
53582     }
53583   }
53584   jresult = (unsigned long)result;
53585   return jresult;
53586 }
53587
53588
53589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
53590   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53591   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
53592
53593   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53594   arg2 = (void (*)(Dali::Animation &))jarg2;
53595   {
53596     try {
53597       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
53598     } catch (std::out_of_range& e) {
53599       {
53600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53601       };
53602     } catch (std::exception& e) {
53603       {
53604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53605       };
53606     } catch (...) {
53607       {
53608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53609       };
53610     }
53611   }
53612 }
53613
53614
53615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
53616   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53617   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
53618
53619   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53620   arg2 = (void (*)(Dali::Animation &))jarg2;
53621   {
53622     try {
53623       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
53624     } catch (std::out_of_range& e) {
53625       {
53626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53627       };
53628     } catch (std::exception& e) {
53629       {
53630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53631       };
53632     } catch (...) {
53633       {
53634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53635       };
53636     }
53637   }
53638 }
53639
53640
53641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
53642   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53643   Dali::Animation *arg2 = 0 ;
53644
53645   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53646   arg2 = (Dali::Animation *)jarg2;
53647   if (!arg2) {
53648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
53649     return ;
53650   }
53651   {
53652     try {
53653       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
53654     } catch (std::out_of_range& e) {
53655       {
53656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53657       };
53658     } catch (std::exception& e) {
53659       {
53660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53661       };
53662     } catch (...) {
53663       {
53664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53665       };
53666     }
53667   }
53668 }
53669
53670
53671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
53672   void * jresult ;
53673   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
53674
53675   {
53676     try {
53677       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
53678     } catch (std::out_of_range& e) {
53679       {
53680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53681       };
53682     } catch (std::exception& e) {
53683       {
53684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53685       };
53686     } catch (...) {
53687       {
53688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53689       };
53690     }
53691   }
53692   jresult = (void *)result;
53693   return jresult;
53694 }
53695
53696
53697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
53698   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
53699
53700   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
53701   {
53702     try {
53703       delete arg1;
53704     } catch (std::out_of_range& e) {
53705       {
53706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53707       };
53708     } catch (std::exception& e) {
53709       {
53710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53711       };
53712     } catch (...) {
53713       {
53714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53715       };
53716     }
53717   }
53718 }
53719
53720
53721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
53722   unsigned int jresult ;
53723   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53724   bool result;
53725
53726   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53727   {
53728     try {
53729       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
53730     } catch (std::out_of_range& e) {
53731       {
53732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53733       };
53734     } catch (std::exception& e) {
53735       {
53736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53737       };
53738     } catch (...) {
53739       {
53740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53741       };
53742     }
53743   }
53744   jresult = result;
53745   return jresult;
53746 }
53747
53748
53749 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
53750   unsigned long jresult ;
53751   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53752   std::size_t result;
53753
53754   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53755   {
53756     try {
53757       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
53758     } catch (std::out_of_range& e) {
53759       {
53760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53761       };
53762     } catch (std::exception& e) {
53763       {
53764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53765       };
53766     } catch (...) {
53767       {
53768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53769       };
53770     }
53771   }
53772   jresult = (unsigned long)result;
53773   return jresult;
53774 }
53775
53776
53777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
53778   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53779   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
53780
53781   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53782   arg2 = (void (*)(Dali::ResourceImage))jarg2;
53783   {
53784     try {
53785       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
53786     } catch (std::out_of_range& e) {
53787       {
53788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53789       };
53790     } catch (std::exception& e) {
53791       {
53792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53793       };
53794     } catch (...) {
53795       {
53796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53797       };
53798     }
53799   }
53800 }
53801
53802
53803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
53804   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53805   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
53806
53807   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53808   arg2 = (void (*)(Dali::ResourceImage))jarg2;
53809   {
53810     try {
53811       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
53812     } catch (std::out_of_range& e) {
53813       {
53814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53815       };
53816     } catch (std::exception& e) {
53817       {
53818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53819       };
53820     } catch (...) {
53821       {
53822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53823       };
53824     }
53825   }
53826 }
53827
53828
53829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
53830   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53831   Dali::ResourceImage arg2 ;
53832   Dali::ResourceImage *argp2 ;
53833
53834   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53835   argp2 = (Dali::ResourceImage *)jarg2;
53836   if (!argp2) {
53837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
53838     return ;
53839   }
53840   arg2 = *argp2;
53841   {
53842     try {
53843       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
53844     } catch (std::out_of_range& e) {
53845       {
53846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53847       };
53848     } catch (std::exception& e) {
53849       {
53850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53851       };
53852     } catch (...) {
53853       {
53854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53855       };
53856     }
53857   }
53858 }
53859
53860
53861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
53862   void * jresult ;
53863   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
53864
53865   {
53866     try {
53867       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
53868     } catch (std::out_of_range& e) {
53869       {
53870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53871       };
53872     } catch (std::exception& e) {
53873       {
53874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53875       };
53876     } catch (...) {
53877       {
53878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53879       };
53880     }
53881   }
53882   jresult = (void *)result;
53883   return jresult;
53884 }
53885
53886
53887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
53888   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
53889
53890   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
53891   {
53892     try {
53893       delete arg1;
53894     } catch (std::out_of_range& e) {
53895       {
53896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53897       };
53898     } catch (std::exception& e) {
53899       {
53900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53901       };
53902     } catch (...) {
53903       {
53904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53905       };
53906     }
53907   }
53908 }
53909
53910
53911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
53912   void * jresult ;
53913   Dali::Timer *result = 0 ;
53914
53915   {
53916     try {
53917       result = (Dali::Timer *)new Dali::Timer();
53918     } catch (std::out_of_range& e) {
53919       {
53920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53921       };
53922     } catch (std::exception& e) {
53923       {
53924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53925       };
53926     } catch (...) {
53927       {
53928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53929       };
53930     }
53931   }
53932   jresult = (void *)result;
53933   return jresult;
53934 }
53935
53936
53937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
53938   void * jresult ;
53939   unsigned int arg1 ;
53940   Dali::Timer result;
53941
53942   arg1 = (unsigned int)jarg1;
53943   {
53944     try {
53945       result = Dali::Timer::New(arg1);
53946     } catch (std::out_of_range& e) {
53947       {
53948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53949       };
53950     } catch (std::exception& e) {
53951       {
53952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53953       };
53954     } catch (...) {
53955       {
53956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53957       };
53958     }
53959   }
53960   jresult = new Dali::Timer((const Dali::Timer &)result);
53961   return jresult;
53962 }
53963
53964
53965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
53966   void * jresult ;
53967   Dali::Timer *arg1 = 0 ;
53968   Dali::Timer *result = 0 ;
53969
53970   arg1 = (Dali::Timer *)jarg1;
53971   if (!arg1) {
53972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
53973     return 0;
53974   }
53975   {
53976     try {
53977       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
53978     } catch (std::out_of_range& e) {
53979       {
53980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53981       };
53982     } catch (std::exception& e) {
53983       {
53984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53985       };
53986     } catch (...) {
53987       {
53988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53989       };
53990     }
53991   }
53992   jresult = (void *)result;
53993   return jresult;
53994 }
53995
53996
53997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
53998   void * jresult ;
53999   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54000   Dali::Timer *arg2 = 0 ;
54001   Dali::Timer *result = 0 ;
54002
54003   arg1 = (Dali::Timer *)jarg1;
54004   arg2 = (Dali::Timer *)jarg2;
54005   if (!arg2) {
54006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54007     return 0;
54008   }
54009   {
54010     try {
54011       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
54012     } catch (std::out_of_range& e) {
54013       {
54014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54015       };
54016     } catch (std::exception& e) {
54017       {
54018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54019       };
54020     } catch (...) {
54021       {
54022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54023       };
54024     }
54025   }
54026   jresult = (void *)result;
54027   return jresult;
54028 }
54029
54030
54031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
54032   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54033
54034   arg1 = (Dali::Timer *)jarg1;
54035   {
54036     try {
54037       delete arg1;
54038     } catch (std::out_of_range& e) {
54039       {
54040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54041       };
54042     } catch (std::exception& e) {
54043       {
54044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54045       };
54046     } catch (...) {
54047       {
54048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54049       };
54050     }
54051   }
54052 }
54053
54054
54055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
54056   void * jresult ;
54057   Dali::BaseHandle arg1 ;
54058   Dali::BaseHandle *argp1 ;
54059   Dali::Timer result;
54060
54061   argp1 = (Dali::BaseHandle *)jarg1;
54062   if (!argp1) {
54063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54064     return 0;
54065   }
54066   arg1 = *argp1;
54067   {
54068     try {
54069       result = Dali::Timer::DownCast(arg1);
54070     } catch (std::out_of_range& e) {
54071       {
54072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54073       };
54074     } catch (std::exception& e) {
54075       {
54076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54077       };
54078     } catch (...) {
54079       {
54080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54081       };
54082     }
54083   }
54084   jresult = new Dali::Timer((const Dali::Timer &)result);
54085   return jresult;
54086 }
54087
54088
54089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
54090   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54091
54092   arg1 = (Dali::Timer *)jarg1;
54093   {
54094     try {
54095       (arg1)->Start();
54096     } catch (std::out_of_range& e) {
54097       {
54098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54099       };
54100     } catch (std::exception& e) {
54101       {
54102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54103       };
54104     } catch (...) {
54105       {
54106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54107       };
54108     }
54109   }
54110 }
54111
54112
54113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
54114   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54115
54116   arg1 = (Dali::Timer *)jarg1;
54117   {
54118     try {
54119       (arg1)->Stop();
54120     } catch (std::out_of_range& e) {
54121       {
54122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54123       };
54124     } catch (std::exception& e) {
54125       {
54126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54127       };
54128     } catch (...) {
54129       {
54130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54131       };
54132     }
54133   }
54134 }
54135
54136
54137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
54138   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54139   unsigned int arg2 ;
54140
54141   arg1 = (Dali::Timer *)jarg1;
54142   arg2 = (unsigned int)jarg2;
54143   {
54144     try {
54145       (arg1)->SetInterval(arg2);
54146     } catch (std::out_of_range& e) {
54147       {
54148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54149       };
54150     } catch (std::exception& e) {
54151       {
54152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54153       };
54154     } catch (...) {
54155       {
54156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54157       };
54158     }
54159   }
54160 }
54161
54162
54163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
54164   unsigned int jresult ;
54165   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54166   unsigned int result;
54167
54168   arg1 = (Dali::Timer *)jarg1;
54169   {
54170     try {
54171       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
54172     } catch (std::out_of_range& e) {
54173       {
54174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54175       };
54176     } catch (std::exception& e) {
54177       {
54178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54179       };
54180     } catch (...) {
54181       {
54182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54183       };
54184     }
54185   }
54186   jresult = result;
54187   return jresult;
54188 }
54189
54190
54191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
54192   unsigned int jresult ;
54193   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54194   bool result;
54195
54196   arg1 = (Dali::Timer *)jarg1;
54197   {
54198     try {
54199       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
54200     } catch (std::out_of_range& e) {
54201       {
54202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54203       };
54204     } catch (std::exception& e) {
54205       {
54206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54207       };
54208     } catch (...) {
54209       {
54210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54211       };
54212     }
54213   }
54214   jresult = result;
54215   return jresult;
54216 }
54217
54218
54219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
54220   void * jresult ;
54221   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54222   Dali::Timer::TimerSignalType *result = 0 ;
54223
54224   arg1 = (Dali::Timer *)jarg1;
54225   {
54226     try {
54227       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
54228     } catch (std::out_of_range& e) {
54229       {
54230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54231       };
54232     } catch (std::exception& e) {
54233       {
54234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54235       };
54236     } catch (...) {
54237       {
54238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54239       };
54240     }
54241   }
54242   jresult = (void *)result;
54243   return jresult;
54244 }
54245
54246
54247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
54248   void * jresult ;
54249   Dali::DragAndDropDetector *result = 0 ;
54250
54251   {
54252     try {
54253       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
54254     } catch (std::out_of_range& e) {
54255       {
54256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54257       };
54258     } catch (std::exception& e) {
54259       {
54260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54261       };
54262     } catch (...) {
54263       {
54264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54265       };
54266     }
54267   }
54268   jresult = (void *)result;
54269   return jresult;
54270 }
54271
54272
54273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
54274   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54275
54276   arg1 = (Dali::DragAndDropDetector *)jarg1;
54277   {
54278     try {
54279       delete arg1;
54280     } catch (std::out_of_range& e) {
54281       {
54282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54283       };
54284     } catch (std::exception& e) {
54285       {
54286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54287       };
54288     } catch (...) {
54289       {
54290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54291       };
54292     }
54293   }
54294 }
54295
54296
54297 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
54298   char * jresult ;
54299   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54300   std::string *result = 0 ;
54301
54302   arg1 = (Dali::DragAndDropDetector *)jarg1;
54303   {
54304     try {
54305       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
54306     } catch (std::out_of_range& e) {
54307       {
54308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54309       };
54310     } catch (std::exception& e) {
54311       {
54312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54313       };
54314     } catch (...) {
54315       {
54316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54317       };
54318     }
54319   }
54320   jresult = SWIG_csharp_string_callback(result->c_str());
54321   return jresult;
54322 }
54323
54324
54325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
54326   void * jresult ;
54327   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54328   Dali::Vector2 result;
54329
54330   arg1 = (Dali::DragAndDropDetector *)jarg1;
54331   {
54332     try {
54333       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
54334     } catch (std::out_of_range& e) {
54335       {
54336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54337       };
54338     } catch (std::exception& e) {
54339       {
54340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54341       };
54342     } catch (...) {
54343       {
54344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54345       };
54346     }
54347   }
54348   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
54349   return jresult;
54350 }
54351
54352
54353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
54354   void * jresult ;
54355   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54356   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
54357
54358   arg1 = (Dali::DragAndDropDetector *)jarg1;
54359   {
54360     try {
54361       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
54362     } catch (std::out_of_range& e) {
54363       {
54364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54365       };
54366     } catch (std::exception& e) {
54367       {
54368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54369       };
54370     } catch (...) {
54371       {
54372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54373       };
54374     }
54375   }
54376   jresult = (void *)result;
54377   return jresult;
54378 }
54379
54380
54381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
54382   void * jresult ;
54383   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54384   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
54385
54386   arg1 = (Dali::DragAndDropDetector *)jarg1;
54387   {
54388     try {
54389       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
54390     } catch (std::out_of_range& e) {
54391       {
54392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54393       };
54394     } catch (std::exception& e) {
54395       {
54396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54397       };
54398     } catch (...) {
54399       {
54400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54401       };
54402     }
54403   }
54404   jresult = (void *)result;
54405   return jresult;
54406 }
54407
54408
54409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
54410   void * jresult ;
54411   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54412   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
54413
54414   arg1 = (Dali::DragAndDropDetector *)jarg1;
54415   {
54416     try {
54417       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
54418     } catch (std::out_of_range& e) {
54419       {
54420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54421       };
54422     } catch (std::exception& e) {
54423       {
54424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54425       };
54426     } catch (...) {
54427       {
54428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54429       };
54430     }
54431   }
54432   jresult = (void *)result;
54433   return jresult;
54434 }
54435
54436
54437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
54438   void * jresult ;
54439   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
54440   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
54441
54442   arg1 = (Dali::DragAndDropDetector *)jarg1;
54443   {
54444     try {
54445       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
54446     } catch (std::out_of_range& e) {
54447       {
54448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54449       };
54450     } catch (std::exception& e) {
54451       {
54452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54453       };
54454     } catch (...) {
54455       {
54456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54457       };
54458     }
54459   }
54460   jresult = (void *)result;
54461   return jresult;
54462 }
54463
54464
54465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
54466   void * jresult ;
54467   Dali::ApplicationExtensions *result = 0 ;
54468
54469   {
54470     try {
54471       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
54472     } catch (std::out_of_range& e) {
54473       {
54474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54475       };
54476     } catch (std::exception& e) {
54477       {
54478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54479       };
54480     } catch (...) {
54481       {
54482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54483       };
54484     }
54485   }
54486   jresult = (void *)result;
54487   return jresult;
54488 }
54489
54490
54491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
54492   void * jresult ;
54493   Dali::Application *arg1 = (Dali::Application *) 0 ;
54494   Dali::ApplicationExtensions *result = 0 ;
54495
54496   arg1 = (Dali::Application *)jarg1;
54497   {
54498     try {
54499       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
54500     } catch (std::out_of_range& e) {
54501       {
54502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54503       };
54504     } catch (std::exception& e) {
54505       {
54506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54507       };
54508     } catch (...) {
54509       {
54510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54511       };
54512     }
54513   }
54514   jresult = (void *)result;
54515   return jresult;
54516 }
54517
54518
54519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
54520   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54521
54522   arg1 = (Dali::ApplicationExtensions *)jarg1;
54523   {
54524     try {
54525       delete arg1;
54526     } catch (std::out_of_range& e) {
54527       {
54528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54529       };
54530     } catch (std::exception& e) {
54531       {
54532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54533       };
54534     } catch (...) {
54535       {
54536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54537       };
54538     }
54539   }
54540 }
54541
54542
54543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
54544   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54545
54546   arg1 = (Dali::ApplicationExtensions *)jarg1;
54547   {
54548     try {
54549       (arg1)->Init();
54550     } catch (std::out_of_range& e) {
54551       {
54552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54553       };
54554     } catch (std::exception& e) {
54555       {
54556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54557       };
54558     } catch (...) {
54559       {
54560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54561       };
54562     }
54563   }
54564 }
54565
54566
54567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
54568   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54569
54570   arg1 = (Dali::ApplicationExtensions *)jarg1;
54571   {
54572     try {
54573       (arg1)->Terminate();
54574     } catch (std::out_of_range& e) {
54575       {
54576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54577       };
54578     } catch (std::exception& e) {
54579       {
54580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54581       };
54582     } catch (...) {
54583       {
54584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54585       };
54586     }
54587   }
54588 }
54589
54590
54591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
54592   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54593
54594   arg1 = (Dali::ApplicationExtensions *)jarg1;
54595   {
54596     try {
54597       (arg1)->Pause();
54598     } catch (std::out_of_range& e) {
54599       {
54600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54601       };
54602     } catch (std::exception& e) {
54603       {
54604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54605       };
54606     } catch (...) {
54607       {
54608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54609       };
54610     }
54611   }
54612 }
54613
54614
54615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
54616   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54617
54618   arg1 = (Dali::ApplicationExtensions *)jarg1;
54619   {
54620     try {
54621       (arg1)->Resume();
54622     } catch (std::out_of_range& e) {
54623       {
54624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54625       };
54626     } catch (std::exception& e) {
54627       {
54628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54629       };
54630     } catch (...) {
54631       {
54632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54633       };
54634     }
54635   }
54636 }
54637
54638
54639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
54640   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
54641
54642   arg1 = (Dali::ApplicationExtensions *)jarg1;
54643   {
54644     try {
54645       (arg1)->LanguageChange();
54646     } catch (std::out_of_range& e) {
54647       {
54648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54649       };
54650     } catch (std::exception& e) {
54651       {
54652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54653       };
54654     } catch (...) {
54655       {
54656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54657       };
54658     }
54659   }
54660 }
54661
54662
54663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
54664   void * jresult ;
54665   Dali::PositionSize arg1 ;
54666   std::string *arg2 = 0 ;
54667   bool arg3 ;
54668   Dali::PositionSize *argp1 ;
54669   Dali::Window result;
54670
54671   argp1 = (Dali::PositionSize *)jarg1;
54672   if (!argp1) {
54673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54674     return 0;
54675   }
54676   arg1 = *argp1;
54677   if (!jarg2) {
54678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54679     return 0;
54680   }
54681   std::string arg2_str(jarg2);
54682   arg2 = &arg2_str;
54683   arg3 = jarg3 ? true : false;
54684   {
54685     try {
54686       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
54687     } catch (std::out_of_range& e) {
54688       {
54689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54690       };
54691     } catch (std::exception& e) {
54692       {
54693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54694       };
54695     } catch (...) {
54696       {
54697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54698       };
54699     }
54700   }
54701   jresult = new Dali::Window((const Dali::Window &)result);
54702
54703   //argout typemap for const std::string&
54704
54705   return jresult;
54706 }
54707
54708
54709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
54710   void * jresult ;
54711   Dali::PositionSize arg1 ;
54712   std::string *arg2 = 0 ;
54713   Dali::PositionSize *argp1 ;
54714   Dali::Window result;
54715
54716   argp1 = (Dali::PositionSize *)jarg1;
54717   if (!argp1) {
54718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54719     return 0;
54720   }
54721   arg1 = *argp1;
54722   if (!jarg2) {
54723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54724     return 0;
54725   }
54726   std::string arg2_str(jarg2);
54727   arg2 = &arg2_str;
54728   {
54729     try {
54730       result = Dali::Window::New(arg1,(std::string const &)*arg2);
54731     } catch (std::out_of_range& e) {
54732       {
54733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54734       };
54735     } catch (std::exception& e) {
54736       {
54737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54738       };
54739     } catch (...) {
54740       {
54741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54742       };
54743     }
54744   }
54745   jresult = new Dali::Window((const Dali::Window &)result);
54746
54747   //argout typemap for const std::string&
54748
54749   return jresult;
54750 }
54751
54752
54753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
54754   void * jresult ;
54755   Dali::PositionSize arg1 ;
54756   std::string *arg2 = 0 ;
54757   std::string *arg3 = 0 ;
54758   bool arg4 ;
54759   Dali::PositionSize *argp1 ;
54760   Dali::Window result;
54761
54762   argp1 = (Dali::PositionSize *)jarg1;
54763   if (!argp1) {
54764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54765     return 0;
54766   }
54767   arg1 = *argp1;
54768   if (!jarg2) {
54769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54770     return 0;
54771   }
54772   std::string arg2_str(jarg2);
54773   arg2 = &arg2_str;
54774   if (!jarg3) {
54775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54776     return 0;
54777   }
54778   std::string arg3_str(jarg3);
54779   arg3 = &arg3_str;
54780   arg4 = jarg4 ? true : false;
54781   {
54782     try {
54783       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
54784     } catch (std::out_of_range& e) {
54785       {
54786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54787       };
54788     } catch (std::exception& e) {
54789       {
54790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54791       };
54792     } catch (...) {
54793       {
54794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54795       };
54796     }
54797   }
54798   jresult = new Dali::Window((const Dali::Window &)result);
54799
54800   //argout typemap for const std::string&
54801
54802
54803   //argout typemap for const std::string&
54804
54805   return jresult;
54806 }
54807
54808
54809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
54810   void * jresult ;
54811   Dali::PositionSize arg1 ;
54812   std::string *arg2 = 0 ;
54813   std::string *arg3 = 0 ;
54814   Dali::PositionSize *argp1 ;
54815   Dali::Window result;
54816
54817   argp1 = (Dali::PositionSize *)jarg1;
54818   if (!argp1) {
54819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54820     return 0;
54821   }
54822   arg1 = *argp1;
54823   if (!jarg2) {
54824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54825     return 0;
54826   }
54827   std::string arg2_str(jarg2);
54828   arg2 = &arg2_str;
54829   if (!jarg3) {
54830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54831     return 0;
54832   }
54833   std::string arg3_str(jarg3);
54834   arg3 = &arg3_str;
54835   {
54836     try {
54837       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
54838     } catch (std::out_of_range& e) {
54839       {
54840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54841       };
54842     } catch (std::exception& e) {
54843       {
54844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54845       };
54846     } catch (...) {
54847       {
54848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54849       };
54850     }
54851   }
54852   jresult = new Dali::Window((const Dali::Window &)result);
54853
54854   //argout typemap for const std::string&
54855
54856
54857   //argout typemap for const std::string&
54858
54859   return jresult;
54860 }
54861
54862
54863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
54864   void * jresult ;
54865   Dali::Window *result = 0 ;
54866
54867   {
54868     try {
54869       result = (Dali::Window *)new Dali::Window();
54870     } catch (std::out_of_range& e) {
54871       {
54872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54873       };
54874     } catch (std::exception& e) {
54875       {
54876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54877       };
54878     } catch (...) {
54879       {
54880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54881       };
54882     }
54883   }
54884   jresult = (void *)result;
54885   return jresult;
54886 }
54887
54888
54889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
54890   Dali::Window *arg1 = (Dali::Window *) 0 ;
54891
54892   arg1 = (Dali::Window *)jarg1;
54893   {
54894     try {
54895       delete arg1;
54896     } catch (std::out_of_range& e) {
54897       {
54898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54899       };
54900     } catch (std::exception& e) {
54901       {
54902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54903       };
54904     } catch (...) {
54905       {
54906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54907       };
54908     }
54909   }
54910 }
54911
54912
54913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
54914   void * jresult ;
54915   Dali::Window *arg1 = 0 ;
54916   Dali::Window *result = 0 ;
54917
54918   arg1 = (Dali::Window *)jarg1;
54919   if (!arg1) {
54920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
54921     return 0;
54922   }
54923   {
54924     try {
54925       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
54926     } catch (std::out_of_range& e) {
54927       {
54928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54929       };
54930     } catch (std::exception& e) {
54931       {
54932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54933       };
54934     } catch (...) {
54935       {
54936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54937       };
54938     }
54939   }
54940   jresult = (void *)result;
54941   return jresult;
54942 }
54943
54944
54945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
54946   void * jresult ;
54947   Dali::Window *arg1 = (Dali::Window *) 0 ;
54948   Dali::Window *arg2 = 0 ;
54949   Dali::Window *result = 0 ;
54950
54951   arg1 = (Dali::Window *)jarg1;
54952   arg2 = (Dali::Window *)jarg2;
54953   if (!arg2) {
54954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
54955     return 0;
54956   }
54957   {
54958     try {
54959       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
54960     } catch (std::out_of_range& e) {
54961       {
54962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54963       };
54964     } catch (std::exception& e) {
54965       {
54966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54967       };
54968     } catch (...) {
54969       {
54970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54971       };
54972     }
54973   }
54974   jresult = (void *)result;
54975   return jresult;
54976 }
54977
54978
54979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
54980   Dali::Window *arg1 = (Dali::Window *) 0 ;
54981   Dali::Window::IndicatorVisibleMode arg2 ;
54982
54983   arg1 = (Dali::Window *)jarg1;
54984   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
54985   {
54986     try {
54987       (arg1)->ShowIndicator(arg2);
54988     } catch (std::out_of_range& e) {
54989       {
54990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54991       };
54992     } catch (std::exception& e) {
54993       {
54994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54995       };
54996     } catch (...) {
54997       {
54998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54999       };
55000     }
55001   }
55002 }
55003
55004
55005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
55006   Dali::Window *arg1 = (Dali::Window *) 0 ;
55007   Dali::Window::IndicatorBgOpacity arg2 ;
55008
55009   arg1 = (Dali::Window *)jarg1;
55010   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
55011   {
55012     try {
55013       (arg1)->SetIndicatorBgOpacity(arg2);
55014     } catch (std::out_of_range& e) {
55015       {
55016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55017       };
55018     } catch (std::exception& e) {
55019       {
55020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55021       };
55022     } catch (...) {
55023       {
55024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55025       };
55026     }
55027   }
55028 }
55029
55030
55031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
55032   Dali::Window *arg1 = (Dali::Window *) 0 ;
55033   Dali::Window::WindowOrientation arg2 ;
55034
55035   arg1 = (Dali::Window *)jarg1;
55036   arg2 = (Dali::Window::WindowOrientation)jarg2;
55037   {
55038     try {
55039       (arg1)->RotateIndicator(arg2);
55040     } catch (std::out_of_range& e) {
55041       {
55042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55043       };
55044     } catch (std::exception& e) {
55045       {
55046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55047       };
55048     } catch (...) {
55049       {
55050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55051       };
55052     }
55053   }
55054 }
55055
55056
55057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
55058   Dali::Window *arg1 = (Dali::Window *) 0 ;
55059   std::string arg2 ;
55060   std::string arg3 ;
55061
55062   arg1 = (Dali::Window *)jarg1;
55063   if (!jarg2) {
55064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55065     return ;
55066   }
55067   (&arg2)->assign(jarg2);
55068   if (!jarg3) {
55069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55070     return ;
55071   }
55072   (&arg3)->assign(jarg3);
55073   {
55074     try {
55075       (arg1)->SetClass(arg2,arg3);
55076     } catch (std::out_of_range& e) {
55077       {
55078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55079       };
55080     } catch (std::exception& e) {
55081       {
55082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55083       };
55084     } catch (...) {
55085       {
55086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55087       };
55088     }
55089   }
55090 }
55091
55092
55093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
55094   Dali::Window *arg1 = (Dali::Window *) 0 ;
55095
55096   arg1 = (Dali::Window *)jarg1;
55097   {
55098     try {
55099       (arg1)->Raise();
55100     } catch (std::out_of_range& e) {
55101       {
55102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55103       };
55104     } catch (std::exception& e) {
55105       {
55106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55107       };
55108     } catch (...) {
55109       {
55110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55111       };
55112     }
55113   }
55114 }
55115
55116
55117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
55118   Dali::Window *arg1 = (Dali::Window *) 0 ;
55119
55120   arg1 = (Dali::Window *)jarg1;
55121   {
55122     try {
55123       (arg1)->Lower();
55124     } catch (std::out_of_range& e) {
55125       {
55126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55127       };
55128     } catch (std::exception& e) {
55129       {
55130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55131       };
55132     } catch (...) {
55133       {
55134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55135       };
55136     }
55137   }
55138 }
55139
55140
55141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
55142   Dali::Window *arg1 = (Dali::Window *) 0 ;
55143
55144   arg1 = (Dali::Window *)jarg1;
55145   {
55146     try {
55147       (arg1)->Activate();
55148     } catch (std::out_of_range& e) {
55149       {
55150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55151       };
55152     } catch (std::exception& e) {
55153       {
55154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55155       };
55156     } catch (...) {
55157       {
55158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55159       };
55160     }
55161   }
55162 }
55163
55164
55165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
55166   Dali::Window *arg1 = (Dali::Window *) 0 ;
55167   Dali::Window::WindowOrientation arg2 ;
55168
55169   arg1 = (Dali::Window *)jarg1;
55170   arg2 = (Dali::Window::WindowOrientation)jarg2;
55171   {
55172     try {
55173       (arg1)->AddAvailableOrientation(arg2);
55174     } catch (std::out_of_range& e) {
55175       {
55176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55177       };
55178     } catch (std::exception& e) {
55179       {
55180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55181       };
55182     } catch (...) {
55183       {
55184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55185       };
55186     }
55187   }
55188 }
55189
55190
55191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
55192   Dali::Window *arg1 = (Dali::Window *) 0 ;
55193   Dali::Window::WindowOrientation arg2 ;
55194
55195   arg1 = (Dali::Window *)jarg1;
55196   arg2 = (Dali::Window::WindowOrientation)jarg2;
55197   {
55198     try {
55199       (arg1)->RemoveAvailableOrientation(arg2);
55200     } catch (std::out_of_range& e) {
55201       {
55202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55203       };
55204     } catch (std::exception& e) {
55205       {
55206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55207       };
55208     } catch (...) {
55209       {
55210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55211       };
55212     }
55213   }
55214 }
55215
55216
55217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
55218   Dali::Window *arg1 = (Dali::Window *) 0 ;
55219   Dali::Window::WindowOrientation arg2 ;
55220
55221   arg1 = (Dali::Window *)jarg1;
55222   arg2 = (Dali::Window::WindowOrientation)jarg2;
55223   {
55224     try {
55225       (arg1)->SetPreferredOrientation(arg2);
55226     } catch (std::out_of_range& e) {
55227       {
55228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55229       };
55230     } catch (std::exception& e) {
55231       {
55232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55233       };
55234     } catch (...) {
55235       {
55236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55237       };
55238     }
55239   }
55240 }
55241
55242
55243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
55244   int jresult ;
55245   Dali::Window *arg1 = (Dali::Window *) 0 ;
55246   Dali::Window::WindowOrientation result;
55247
55248   arg1 = (Dali::Window *)jarg1;
55249   {
55250     try {
55251       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
55252     } catch (std::out_of_range& e) {
55253       {
55254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55255       };
55256     } catch (std::exception& e) {
55257       {
55258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55259       };
55260     } catch (...) {
55261       {
55262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55263       };
55264     }
55265   }
55266   jresult = (int)result;
55267   return jresult;
55268 }
55269
55270
55271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
55272   void * jresult ;
55273   Dali::Window *arg1 = (Dali::Window *) 0 ;
55274   Dali::DragAndDropDetector result;
55275
55276   arg1 = (Dali::Window *)jarg1;
55277   {
55278     try {
55279       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
55280     } catch (std::out_of_range& e) {
55281       {
55282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55283       };
55284     } catch (std::exception& e) {
55285       {
55286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55287       };
55288     } catch (...) {
55289       {
55290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55291       };
55292     }
55293   }
55294   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
55295   return jresult;
55296 }
55297
55298
55299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
55300   void * jresult ;
55301   Dali::Window *arg1 = (Dali::Window *) 0 ;
55302   Dali::Any result;
55303
55304   arg1 = (Dali::Window *)jarg1;
55305   {
55306     try {
55307       result = ((Dali::Window const *)arg1)->GetNativeHandle();
55308     } catch (std::out_of_range& e) {
55309       {
55310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55311       };
55312     } catch (std::exception& e) {
55313       {
55314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55315       };
55316     } catch (...) {
55317       {
55318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55319       };
55320     }
55321   }
55322   jresult = new Dali::Any((const Dali::Any &)result);
55323   return jresult;
55324 }
55325
55326
55327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_IndicatorVisibilityChangedSignal(void * jarg1) {
55328   void * jresult ;
55329   Dali::Window *arg1 = (Dali::Window *) 0 ;
55330   Dali::Window::IndicatorSignalType *result = 0 ;
55331
55332   arg1 = (Dali::Window *)jarg1;
55333   {
55334     try {
55335       result = (Dali::Window::IndicatorSignalType *) &(arg1)->IndicatorVisibilityChangedSignal();
55336     } catch (std::out_of_range& e) {
55337       {
55338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55339       };
55340     } catch (std::exception& e) {
55341       {
55342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55343       };
55344     } catch (...) {
55345       {
55346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55347       };
55348     }
55349   }
55350   jresult = (void *)result;
55351   return jresult;
55352 }
55353
55354
55355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
55356   void * jresult ;
55357   Dali::Application result;
55358
55359   {
55360     try {
55361       result = Dali::Application::New();
55362     } catch (std::out_of_range& e) {
55363       {
55364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55365       };
55366     } catch (std::exception& e) {
55367       {
55368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55369       };
55370     } catch (...) {
55371       {
55372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55373       };
55374     }
55375   }
55376   jresult = new Dali::Application((const Dali::Application &)result);
55377   return jresult;
55378 }
55379
55380
55381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
55382   void * jresult ;
55383   int *arg1 = (int *) 0 ;
55384   char ***arg2 ;
55385   Dali::Application result;
55386
55387   {
55388     // Todo generate argv data from the C# args
55389     char **array;         // two dimensional array
55390     int numStrings = 1;     // number of strings
55391     int stringLength = 30;      // max string length.
55392     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55393     argV = array;
55394
55395     // allocate the string data
55396     for( int i=0; i < numStrings; i++)
55397     {
55398       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55399     }
55400     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55401
55402     strcpy( array[0], "dali-csharp-app");
55403
55404     arg1 = &argC;
55405     arg2 = &argV;
55406   }
55407   {
55408     try {
55409       result = Dali::Application::New(arg1,arg2);
55410     } catch (std::out_of_range& e) {
55411       {
55412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55413       };
55414     } catch (std::exception& e) {
55415       {
55416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55417       };
55418     } catch (...) {
55419       {
55420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55421       };
55422     }
55423   }
55424   jresult = new Dali::Application((const Dali::Application &)result);
55425   return jresult;
55426 }
55427
55428
55429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
55430   void * jresult ;
55431   int *arg1 = (int *) 0 ;
55432   char ***arg2 ;
55433   std::string *arg3 = 0 ;
55434   Dali::Application result;
55435
55436   {
55437     // Todo generate argv data from the C# args
55438     char **array;         // two dimensional array
55439     int numStrings = 1;     // number of strings
55440     int stringLength = 30;      // max string length.
55441     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55442     argV = array;
55443
55444     // allocate the string data
55445     for( int i=0; i < numStrings; i++)
55446     {
55447       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55448     }
55449     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55450
55451     strcpy( array[0], "dali-csharp-app");
55452
55453     arg1 = &argC;
55454     arg2 = &argV;
55455   }
55456   if (!jarg3) {
55457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55458     return 0;
55459   }
55460   std::string arg3_str(jarg3);
55461   arg3 = &arg3_str;
55462   {
55463     try {
55464       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
55465     } catch (std::out_of_range& e) {
55466       {
55467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55468       };
55469     } catch (std::exception& e) {
55470       {
55471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55472       };
55473     } catch (...) {
55474       {
55475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55476       };
55477     }
55478   }
55479   jresult = new Dali::Application((const Dali::Application &)result);
55480
55481   //argout typemap for const std::string&
55482
55483   return jresult;
55484 }
55485
55486
55487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
55488   void * jresult ;
55489   int *arg1 = (int *) 0 ;
55490   char ***arg2 ;
55491   std::string *arg3 = 0 ;
55492   Dali::Application::WINDOW_MODE arg4 ;
55493   Dali::Application result;
55494
55495   {
55496     // Todo generate argv data from the C# args
55497     char **array;         // two dimensional array
55498     int numStrings = 1;     // number of strings
55499     int stringLength = 30;      // max string length.
55500     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
55501     argV = array;
55502
55503     // allocate the string data
55504     for( int i=0; i < numStrings; i++)
55505     {
55506       array[i]=(char *)malloc( stringLength * sizeof(char *) );
55507     }
55508     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
55509
55510     strcpy( array[0], "dali-csharp-app");
55511
55512     arg1 = &argC;
55513     arg2 = &argV;
55514   }
55515   if (!jarg3) {
55516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55517     return 0;
55518   }
55519   std::string arg3_str(jarg3);
55520   arg3 = &arg3_str;
55521   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
55522   {
55523     try {
55524       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
55525     } catch (std::out_of_range& e) {
55526       {
55527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55528       };
55529     } catch (std::exception& e) {
55530       {
55531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55532       };
55533     } catch (...) {
55534       {
55535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55536       };
55537     }
55538   }
55539   jresult = new Dali::Application((const Dali::Application &)result);
55540
55541   //argout typemap for const std::string&
55542
55543   return jresult;
55544 }
55545
55546
55547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
55548   void * jresult ;
55549   Dali::Application *result = 0 ;
55550
55551   {
55552     try {
55553       result = (Dali::Application *)new Dali::Application();
55554     } catch (std::out_of_range& e) {
55555       {
55556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55557       };
55558     } catch (std::exception& e) {
55559       {
55560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55561       };
55562     } catch (...) {
55563       {
55564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55565       };
55566     }
55567   }
55568   jresult = (void *)result;
55569   return jresult;
55570 }
55571
55572
55573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
55574   void * jresult ;
55575   Dali::Application *arg1 = 0 ;
55576   Dali::Application *result = 0 ;
55577
55578   arg1 = (Dali::Application *)jarg1;
55579   if (!arg1) {
55580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55581     return 0;
55582   }
55583   {
55584     try {
55585       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
55586     } catch (std::out_of_range& e) {
55587       {
55588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55589       };
55590     } catch (std::exception& e) {
55591       {
55592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55593       };
55594     } catch (...) {
55595       {
55596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55597       };
55598     }
55599   }
55600   jresult = (void *)result;
55601   return jresult;
55602 }
55603
55604
55605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
55606   void * jresult ;
55607   Dali::Application *arg1 = (Dali::Application *) 0 ;
55608   Dali::Application *arg2 = 0 ;
55609   Dali::Application *result = 0 ;
55610
55611   arg1 = (Dali::Application *)jarg1;
55612   arg2 = (Dali::Application *)jarg2;
55613   if (!arg2) {
55614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
55615     return 0;
55616   }
55617   {
55618     try {
55619       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
55620     } catch (std::out_of_range& e) {
55621       {
55622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55623       };
55624     } catch (std::exception& e) {
55625       {
55626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55627       };
55628     } catch (...) {
55629       {
55630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55631       };
55632     }
55633   }
55634   jresult = (void *)result;
55635   return jresult;
55636 }
55637
55638
55639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
55640   Dali::Application *arg1 = (Dali::Application *) 0 ;
55641
55642   arg1 = (Dali::Application *)jarg1;
55643   {
55644     try {
55645       delete arg1;
55646     } catch (std::out_of_range& e) {
55647       {
55648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55649       };
55650     } catch (std::exception& e) {
55651       {
55652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55653       };
55654     } catch (...) {
55655       {
55656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55657       };
55658     }
55659   }
55660 }
55661
55662
55663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
55664   Dali::Application *arg1 = (Dali::Application *) 0 ;
55665
55666   arg1 = (Dali::Application *)jarg1;
55667   {
55668     try {
55669       (arg1)->MainLoop();
55670     } catch (std::out_of_range& e) {
55671       {
55672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55673       };
55674     } catch (std::exception& e) {
55675       {
55676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55677       };
55678     } catch (...) {
55679       {
55680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55681       };
55682     }
55683   }
55684 }
55685
55686
55687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
55688   Dali::Application *arg1 = (Dali::Application *) 0 ;
55689   Configuration::ContextLoss arg2 ;
55690   Configuration::ContextLoss *argp2 ;
55691
55692   arg1 = (Dali::Application *)jarg1;
55693   argp2 = (Configuration::ContextLoss *)jarg2;
55694   if (!argp2) {
55695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
55696     return ;
55697   }
55698   arg2 = *argp2;
55699   {
55700     try {
55701       (arg1)->MainLoop(arg2);
55702     } catch (std::out_of_range& e) {
55703       {
55704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55705       };
55706     } catch (std::exception& e) {
55707       {
55708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55709       };
55710     } catch (...) {
55711       {
55712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55713       };
55714     }
55715   }
55716 }
55717
55718
55719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
55720   Dali::Application *arg1 = (Dali::Application *) 0 ;
55721
55722   arg1 = (Dali::Application *)jarg1;
55723   {
55724     try {
55725       (arg1)->Lower();
55726     } catch (std::out_of_range& e) {
55727       {
55728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55729       };
55730     } catch (std::exception& e) {
55731       {
55732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55733       };
55734     } catch (...) {
55735       {
55736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55737       };
55738     }
55739   }
55740 }
55741
55742
55743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
55744   Dali::Application *arg1 = (Dali::Application *) 0 ;
55745
55746   arg1 = (Dali::Application *)jarg1;
55747   {
55748     try {
55749       (arg1)->Quit();
55750     } catch (std::out_of_range& e) {
55751       {
55752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55753       };
55754     } catch (std::exception& e) {
55755       {
55756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55757       };
55758     } catch (...) {
55759       {
55760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55761       };
55762     }
55763   }
55764 }
55765
55766
55767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
55768   unsigned int jresult ;
55769   Dali::Application *arg1 = (Dali::Application *) 0 ;
55770   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
55771   bool result;
55772
55773   arg1 = (Dali::Application *)jarg1;
55774   arg2 = (Dali::CallbackBase *)jarg2;
55775   {
55776     try {
55777       result = (bool)(arg1)->AddIdle(arg2);
55778     } catch (std::out_of_range& e) {
55779       {
55780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55781       };
55782     } catch (std::exception& e) {
55783       {
55784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55785       };
55786     } catch (...) {
55787       {
55788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55789       };
55790     }
55791   }
55792   jresult = result;
55793   return jresult;
55794 }
55795
55796
55797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
55798   void * jresult ;
55799   Dali::Application *arg1 = (Dali::Application *) 0 ;
55800   Dali::Window result;
55801
55802   arg1 = (Dali::Application *)jarg1;
55803   {
55804     try {
55805       result = (arg1)->GetWindow();
55806     } catch (std::out_of_range& e) {
55807       {
55808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55809       };
55810     } catch (std::exception& e) {
55811       {
55812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55813       };
55814     } catch (...) {
55815       {
55816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55817       };
55818     }
55819   }
55820   jresult = new Dali::Window((const Dali::Window &)result);
55821   return jresult;
55822 }
55823
55824
55825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
55826   Dali::Application *arg1 = (Dali::Application *) 0 ;
55827   Dali::PositionSize arg2 ;
55828   std::string *arg3 = 0 ;
55829   Dali::PositionSize *argp2 ;
55830
55831   arg1 = (Dali::Application *)jarg1;
55832   argp2 = (Dali::PositionSize *)jarg2;
55833   if (!argp2) {
55834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
55835     return ;
55836   }
55837   arg2 = *argp2;
55838   if (!jarg3) {
55839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
55840     return ;
55841   }
55842   std::string arg3_str(jarg3);
55843   arg3 = &arg3_str;
55844   {
55845     try {
55846       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
55847     } catch (std::out_of_range& e) {
55848       {
55849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55850       };
55851     } catch (std::exception& e) {
55852       {
55853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55854       };
55855     } catch (...) {
55856       {
55857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55858       };
55859     }
55860   }
55861
55862   //argout typemap for const std::string&
55863
55864 }
55865
55866
55867 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
55868   char * jresult ;
55869   std::string result;
55870
55871   {
55872     try {
55873       result = Dali::Application::GetResourcePath();
55874     } catch (std::out_of_range& e) {
55875       {
55876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55877       };
55878     } catch (std::exception& e) {
55879       {
55880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55881       };
55882     } catch (...) {
55883       {
55884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55885       };
55886     }
55887   }
55888   jresult = SWIG_csharp_string_callback((&result)->c_str());
55889   return jresult;
55890 }
55891
55892
55893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
55894   Dali::Application *arg1 = (Dali::Application *) 0 ;
55895   Dali::ViewMode arg2 ;
55896
55897   arg1 = (Dali::Application *)jarg1;
55898   arg2 = (Dali::ViewMode)jarg2;
55899   {
55900     try {
55901       (arg1)->SetViewMode(arg2);
55902     } catch (std::out_of_range& e) {
55903       {
55904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55905       };
55906     } catch (std::exception& e) {
55907       {
55908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55909       };
55910     } catch (...) {
55911       {
55912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55913       };
55914     }
55915   }
55916 }
55917
55918
55919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
55920   int jresult ;
55921   Dali::Application *arg1 = (Dali::Application *) 0 ;
55922   Dali::ViewMode result;
55923
55924   arg1 = (Dali::Application *)jarg1;
55925   {
55926     try {
55927       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
55928     } catch (std::out_of_range& e) {
55929       {
55930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55931       };
55932     } catch (std::exception& e) {
55933       {
55934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55935       };
55936     } catch (...) {
55937       {
55938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55939       };
55940     }
55941   }
55942   jresult = (int)result;
55943   return jresult;
55944 }
55945
55946
55947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
55948   Dali::Application *arg1 = (Dali::Application *) 0 ;
55949   float arg2 ;
55950
55951   arg1 = (Dali::Application *)jarg1;
55952   arg2 = (float)jarg2;
55953   {
55954     try {
55955       (arg1)->SetStereoBase(arg2);
55956     } catch (std::out_of_range& e) {
55957       {
55958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55959       };
55960     } catch (std::exception& e) {
55961       {
55962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55963       };
55964     } catch (...) {
55965       {
55966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55967       };
55968     }
55969   }
55970 }
55971
55972
55973 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
55974   float jresult ;
55975   Dali::Application *arg1 = (Dali::Application *) 0 ;
55976   float result;
55977
55978   arg1 = (Dali::Application *)jarg1;
55979   {
55980     try {
55981       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
55982     } catch (std::out_of_range& e) {
55983       {
55984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55985       };
55986     } catch (std::exception& e) {
55987       {
55988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55989       };
55990     } catch (...) {
55991       {
55992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55993       };
55994     }
55995   }
55996   jresult = result;
55997   return jresult;
55998 }
55999
56000
56001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
56002   void * jresult ;
56003   Dali::Application *arg1 = (Dali::Application *) 0 ;
56004   Dali::Application::AppSignalType *result = 0 ;
56005
56006   arg1 = (Dali::Application *)jarg1;
56007   {
56008     try {
56009       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
56010     } catch (std::out_of_range& e) {
56011       {
56012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56013       };
56014     } catch (std::exception& e) {
56015       {
56016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56017       };
56018     } catch (...) {
56019       {
56020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56021       };
56022     }
56023   }
56024   jresult = (void *)result;
56025   return jresult;
56026 }
56027
56028
56029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
56030   void * jresult ;
56031   Dali::Application *arg1 = (Dali::Application *) 0 ;
56032   Dali::Application::AppSignalType *result = 0 ;
56033
56034   arg1 = (Dali::Application *)jarg1;
56035   {
56036     try {
56037       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
56038     } catch (std::out_of_range& e) {
56039       {
56040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56041       };
56042     } catch (std::exception& e) {
56043       {
56044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56045       };
56046     } catch (...) {
56047       {
56048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56049       };
56050     }
56051   }
56052   jresult = (void *)result;
56053   return jresult;
56054 }
56055
56056
56057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
56058   void * jresult ;
56059   Dali::Application *arg1 = (Dali::Application *) 0 ;
56060   Dali::Application::AppSignalType *result = 0 ;
56061
56062   arg1 = (Dali::Application *)jarg1;
56063   {
56064     try {
56065       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
56066     } catch (std::out_of_range& e) {
56067       {
56068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56069       };
56070     } catch (std::exception& e) {
56071       {
56072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56073       };
56074     } catch (...) {
56075       {
56076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56077       };
56078     }
56079   }
56080   jresult = (void *)result;
56081   return jresult;
56082 }
56083
56084
56085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
56086   void * jresult ;
56087   Dali::Application *arg1 = (Dali::Application *) 0 ;
56088   Dali::Application::AppSignalType *result = 0 ;
56089
56090   arg1 = (Dali::Application *)jarg1;
56091   {
56092     try {
56093       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
56094     } catch (std::out_of_range& e) {
56095       {
56096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56097       };
56098     } catch (std::exception& e) {
56099       {
56100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56101       };
56102     } catch (...) {
56103       {
56104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56105       };
56106     }
56107   }
56108   jresult = (void *)result;
56109   return jresult;
56110 }
56111
56112
56113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
56114   void * jresult ;
56115   Dali::Application *arg1 = (Dali::Application *) 0 ;
56116   Dali::Application::AppSignalType *result = 0 ;
56117
56118   arg1 = (Dali::Application *)jarg1;
56119   {
56120     try {
56121       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
56122     } catch (std::out_of_range& e) {
56123       {
56124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56125       };
56126     } catch (std::exception& e) {
56127       {
56128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56129       };
56130     } catch (...) {
56131       {
56132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56133       };
56134     }
56135   }
56136   jresult = (void *)result;
56137   return jresult;
56138 }
56139
56140
56141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
56142   void * jresult ;
56143   Dali::Application *arg1 = (Dali::Application *) 0 ;
56144   Dali::Application::AppSignalType *result = 0 ;
56145
56146   arg1 = (Dali::Application *)jarg1;
56147   {
56148     try {
56149       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
56150     } catch (std::out_of_range& e) {
56151       {
56152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56153       };
56154     } catch (std::exception& e) {
56155       {
56156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56157       };
56158     } catch (...) {
56159       {
56160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56161       };
56162     }
56163   }
56164   jresult = (void *)result;
56165   return jresult;
56166 }
56167
56168
56169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
56170   void * jresult ;
56171   Dali::Application *arg1 = (Dali::Application *) 0 ;
56172   Dali::Application::AppControlSignalType *result = 0 ;
56173
56174   arg1 = (Dali::Application *)jarg1;
56175   {
56176     try {
56177       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
56178     } catch (std::out_of_range& e) {
56179       {
56180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56181       };
56182     } catch (std::exception& e) {
56183       {
56184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56185       };
56186     } catch (...) {
56187       {
56188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56189       };
56190     }
56191   }
56192   jresult = (void *)result;
56193   return jresult;
56194 }
56195
56196
56197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
56198   void * jresult ;
56199   Dali::Application *arg1 = (Dali::Application *) 0 ;
56200   Dali::Application::AppSignalType *result = 0 ;
56201
56202   arg1 = (Dali::Application *)jarg1;
56203   {
56204     try {
56205       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
56206     } catch (std::out_of_range& e) {
56207       {
56208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56209       };
56210     } catch (std::exception& e) {
56211       {
56212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56213       };
56214     } catch (...) {
56215       {
56216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56217       };
56218     }
56219   }
56220   jresult = (void *)result;
56221   return jresult;
56222 }
56223
56224
56225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
56226   void * jresult ;
56227   Dali::Application *arg1 = (Dali::Application *) 0 ;
56228   Dali::Application::AppSignalType *result = 0 ;
56229
56230   arg1 = (Dali::Application *)jarg1;
56231   {
56232     try {
56233       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
56234     } catch (std::out_of_range& e) {
56235       {
56236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56237       };
56238     } catch (std::exception& e) {
56239       {
56240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56241       };
56242     } catch (...) {
56243       {
56244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56245       };
56246     }
56247   }
56248   jresult = (void *)result;
56249   return jresult;
56250 }
56251
56252
56253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
56254   void * jresult ;
56255   Dali::Application *arg1 = (Dali::Application *) 0 ;
56256   Dali::Application::AppSignalType *result = 0 ;
56257
56258   arg1 = (Dali::Application *)jarg1;
56259   {
56260     try {
56261       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
56262     } catch (std::out_of_range& e) {
56263       {
56264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56265       };
56266     } catch (std::exception& e) {
56267       {
56268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56269       };
56270     } catch (...) {
56271       {
56272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56273       };
56274     }
56275   }
56276   jresult = (void *)result;
56277   return jresult;
56278 }
56279
56280
56281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
56282   void * jresult ;
56283   Dali::Application *arg1 = (Dali::Application *) 0 ;
56284   Dali::Application::AppSignalType *result = 0 ;
56285
56286   arg1 = (Dali::Application *)jarg1;
56287   {
56288     try {
56289       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
56290     } catch (std::out_of_range& e) {
56291       {
56292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56293       };
56294     } catch (std::exception& e) {
56295       {
56296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56297       };
56298     } catch (...) {
56299       {
56300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56301       };
56302     }
56303   }
56304   jresult = (void *)result;
56305   return jresult;
56306 }
56307
56308
56309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
56310   unsigned int jresult ;
56311   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56312   bool result;
56313
56314   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56315   {
56316     try {
56317       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
56318     } catch (std::out_of_range& e) {
56319       {
56320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56321       };
56322     } catch (std::exception& e) {
56323       {
56324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56325       };
56326     } catch (...) {
56327       {
56328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56329       };
56330     }
56331   }
56332   jresult = result;
56333   return jresult;
56334 }
56335
56336
56337 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
56338   unsigned long jresult ;
56339   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56340   std::size_t result;
56341
56342   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56343   {
56344     try {
56345       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
56346     } catch (std::out_of_range& e) {
56347       {
56348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56349       };
56350     } catch (std::exception& e) {
56351       {
56352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56353       };
56354     } catch (...) {
56355       {
56356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56357       };
56358     }
56359   }
56360   jresult = (unsigned long)result;
56361   return jresult;
56362 }
56363
56364
56365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
56366   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56367   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56368
56369   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56370   arg2 = (void (*)(Dali::Application &))jarg2;
56371   {
56372     try {
56373       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
56374     } catch (std::out_of_range& e) {
56375       {
56376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56377       };
56378     } catch (std::exception& e) {
56379       {
56380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56381       };
56382     } catch (...) {
56383       {
56384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56385       };
56386     }
56387   }
56388 }
56389
56390
56391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
56392   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56393   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
56394
56395   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56396   arg2 = (void (*)(Dali::Application &))jarg2;
56397   {
56398     try {
56399       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
56400     } catch (std::out_of_range& e) {
56401       {
56402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56403       };
56404     } catch (std::exception& e) {
56405       {
56406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56407       };
56408     } catch (...) {
56409       {
56410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56411       };
56412     }
56413   }
56414 }
56415
56416
56417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
56418   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56419   Dali::Application *arg2 = 0 ;
56420
56421   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56422   arg2 = (Dali::Application *)jarg2;
56423   if (!arg2) {
56424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56425     return ;
56426   }
56427   {
56428     try {
56429       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
56430     } catch (std::out_of_range& e) {
56431       {
56432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56433       };
56434     } catch (std::exception& e) {
56435       {
56436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56437       };
56438     } catch (...) {
56439       {
56440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56441       };
56442     }
56443   }
56444 }
56445
56446
56447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
56448   void * jresult ;
56449   Dali::Signal< void (Dali::Application &) > *result = 0 ;
56450
56451   {
56452     try {
56453       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
56454     } catch (std::out_of_range& e) {
56455       {
56456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56457       };
56458     } catch (std::exception& e) {
56459       {
56460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56461       };
56462     } catch (...) {
56463       {
56464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56465       };
56466     }
56467   }
56468   jresult = (void *)result;
56469   return jresult;
56470 }
56471
56472
56473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
56474   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
56475
56476   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
56477   {
56478     try {
56479       delete arg1;
56480     } catch (std::out_of_range& e) {
56481       {
56482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56483       };
56484     } catch (std::exception& e) {
56485       {
56486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56487       };
56488     } catch (...) {
56489       {
56490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56491       };
56492     }
56493   }
56494 }
56495
56496
56497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
56498   unsigned int jresult ;
56499   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56500   bool result;
56501
56502   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56503   {
56504     try {
56505       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56506     } catch (std::out_of_range& e) {
56507       {
56508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56509       };
56510     } catch (std::exception& e) {
56511       {
56512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56513       };
56514     } catch (...) {
56515       {
56516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56517       };
56518     }
56519   }
56520   jresult = result;
56521   return jresult;
56522 }
56523
56524
56525 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
56526   unsigned long jresult ;
56527   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56528   std::size_t result;
56529
56530   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56531   {
56532     try {
56533       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
56534     } catch (std::out_of_range& e) {
56535       {
56536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56537       };
56538     } catch (std::exception& e) {
56539       {
56540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56541       };
56542     } catch (...) {
56543       {
56544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56545       };
56546     }
56547   }
56548   jresult = (unsigned long)result;
56549   return jresult;
56550 }
56551
56552
56553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
56554   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56555   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56556
56557   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56558   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56559   {
56560     try {
56561       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
56562     } catch (std::out_of_range& e) {
56563       {
56564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56565       };
56566     } catch (std::exception& e) {
56567       {
56568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56569       };
56570     } catch (...) {
56571       {
56572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56573       };
56574     }
56575   }
56576 }
56577
56578
56579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
56580   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56581   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
56582
56583   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56584   arg2 = (void (*)(Dali::Application &,void *))jarg2;
56585   {
56586     try {
56587       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
56588     } catch (std::out_of_range& e) {
56589       {
56590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56591       };
56592     } catch (std::exception& e) {
56593       {
56594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56595       };
56596     } catch (...) {
56597       {
56598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56599       };
56600     }
56601   }
56602 }
56603
56604
56605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56606   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56607   Dali::Application *arg2 = 0 ;
56608   void *arg3 = (void *) 0 ;
56609
56610   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56611   arg2 = (Dali::Application *)jarg2;
56612   if (!arg2) {
56613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
56614     return ;
56615   }
56616   arg3 = jarg3;
56617   {
56618     try {
56619       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
56620     } catch (std::out_of_range& e) {
56621       {
56622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56623       };
56624     } catch (std::exception& e) {
56625       {
56626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56627       };
56628     } catch (...) {
56629       {
56630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56631       };
56632     }
56633   }
56634 }
56635
56636
56637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
56638   void * jresult ;
56639   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
56640
56641   {
56642     try {
56643       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
56644     } catch (std::out_of_range& e) {
56645       {
56646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56647       };
56648     } catch (std::exception& e) {
56649       {
56650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56651       };
56652     } catch (...) {
56653       {
56654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56655       };
56656     }
56657   }
56658   jresult = (void *)result;
56659   return jresult;
56660 }
56661
56662
56663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
56664   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
56665
56666   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
56667   {
56668     try {
56669       delete arg1;
56670     } catch (std::out_of_range& e) {
56671       {
56672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56673       };
56674     } catch (std::exception& e) {
56675       {
56676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56677       };
56678     } catch (...) {
56679       {
56680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56681       };
56682     }
56683   }
56684 }
56685
56686
56687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
56688   void * jresult ;
56689   Dali::Signal< bool () > *result = 0 ;
56690
56691   {
56692     try {
56693       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
56694     } catch (std::out_of_range& e) {
56695       {
56696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56697       };
56698     } catch (std::exception& e) {
56699       {
56700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56701       };
56702     } catch (...) {
56703       {
56704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56705       };
56706     }
56707   }
56708   jresult = (void *)result;
56709   return jresult;
56710 }
56711
56712
56713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
56714   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56715
56716   arg1 = (Dali::Signal< bool () > *)jarg1;
56717   {
56718     try {
56719       delete arg1;
56720     } catch (std::out_of_range& e) {
56721       {
56722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56723       };
56724     } catch (std::exception& e) {
56725       {
56726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56727       };
56728     } catch (...) {
56729       {
56730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56731       };
56732     }
56733   }
56734 }
56735
56736
56737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
56738   unsigned int jresult ;
56739   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56740   bool result;
56741
56742   arg1 = (Dali::Signal< bool () > *)jarg1;
56743   {
56744     try {
56745       result = (bool)((Dali::Signal< bool () > const *)arg1)->Empty();
56746     } catch (std::out_of_range& e) {
56747       {
56748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56749       };
56750     } catch (std::exception& e) {
56751       {
56752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56753       };
56754     } catch (...) {
56755       {
56756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56757       };
56758     }
56759   }
56760   jresult = result;
56761   return jresult;
56762 }
56763
56764
56765 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
56766   unsigned long jresult ;
56767   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56768   std::size_t result;
56769
56770   arg1 = (Dali::Signal< bool () > *)jarg1;
56771   {
56772     try {
56773       result = ((Dali::Signal< bool () > const *)arg1)->GetConnectionCount();
56774     } catch (std::out_of_range& e) {
56775       {
56776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56777       };
56778     } catch (std::exception& e) {
56779       {
56780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56781       };
56782     } catch (...) {
56783       {
56784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56785       };
56786     }
56787   }
56788   jresult = (unsigned long)result;
56789   return jresult;
56790 }
56791
56792
56793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect__SWIG_0(void * jarg1, void * jarg2) {
56794   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56795   bool (*arg2)() = (bool (*)()) 0 ;
56796
56797   arg1 = (Dali::Signal< bool () > *)jarg1;
56798   arg2 = (bool (*)())jarg2;
56799   {
56800     try {
56801       (arg1)->Connect(arg2);
56802     } catch (std::out_of_range& e) {
56803       {
56804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56805       };
56806     } catch (std::exception& e) {
56807       {
56808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56809       };
56810     } catch (...) {
56811       {
56812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56813       };
56814     }
56815   }
56816 }
56817
56818
56819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
56820   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56821   bool (*arg2)() = (bool (*)()) 0 ;
56822
56823   arg1 = (Dali::Signal< bool () > *)jarg1;
56824   arg2 = (bool (*)())jarg2;
56825   {
56826     try {
56827       (arg1)->Disconnect(arg2);
56828     } catch (std::out_of_range& e) {
56829       {
56830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56831       };
56832     } catch (std::exception& e) {
56833       {
56834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56835       };
56836     } catch (...) {
56837       {
56838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56839       };
56840     }
56841   }
56842 }
56843
56844
56845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
56846   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56847   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
56848   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
56849
56850   arg1 = (Dali::Signal< bool () > *)jarg1;
56851   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
56852   arg3 = (Dali::FunctorDelegate *)jarg3;
56853   {
56854     try {
56855       (arg1)->Connect(arg2,arg3);
56856     } catch (std::out_of_range& e) {
56857       {
56858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56859       };
56860     } catch (std::exception& e) {
56861       {
56862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56863       };
56864     } catch (...) {
56865       {
56866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56867       };
56868     }
56869   }
56870 }
56871
56872
56873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
56874   unsigned int jresult ;
56875   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
56876   bool result;
56877
56878   arg1 = (Dali::Signal< bool () > *)jarg1;
56879   {
56880     try {
56881       result = (bool)(arg1)->Emit();
56882     } catch (std::out_of_range& e) {
56883       {
56884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56885       };
56886     } catch (std::exception& e) {
56887       {
56888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56889       };
56890     } catch (...) {
56891       {
56892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56893       };
56894     }
56895   }
56896   jresult = result;
56897   return jresult;
56898 }
56899
56900
56901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
56902   int jresult ;
56903   int result;
56904
56905   {
56906     try {
56907       result = (int)Dali::Toolkit::Visual::Property::TYPE;
56908     } catch (std::out_of_range& e) {
56909       {
56910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56911       };
56912     } catch (std::exception& e) {
56913       {
56914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56915       };
56916     } catch (...) {
56917       {
56918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56919       };
56920     }
56921   }
56922   jresult = (int)result;
56923   return jresult;
56924 }
56925
56926
56927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
56928   int jresult ;
56929   int result;
56930
56931   {
56932     try {
56933       result = (int)Dali::Toolkit::Visual::Property::SHADER;
56934     } catch (std::out_of_range& e) {
56935       {
56936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56937       };
56938     } catch (std::exception& e) {
56939       {
56940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56941       };
56942     } catch (...) {
56943       {
56944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56945       };
56946     }
56947   }
56948   jresult = (int)result;
56949   return jresult;
56950 }
56951
56952
56953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
56954   int jresult ;
56955   int result;
56956
56957   {
56958     try {
56959       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
56960     } catch (std::out_of_range& e) {
56961       {
56962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56963       };
56964     } catch (std::exception& e) {
56965       {
56966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56967       };
56968     } catch (...) {
56969       {
56970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56971       };
56972     }
56973   }
56974   jresult = (int)result;
56975   return jresult;
56976 }
56977
56978
56979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
56980   int jresult ;
56981   int result;
56982
56983   {
56984     try {
56985       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56986     } catch (std::out_of_range& e) {
56987       {
56988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56989       };
56990     } catch (std::exception& e) {
56991       {
56992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56993       };
56994     } catch (...) {
56995       {
56996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56997       };
56998     }
56999   }
57000   jresult = (int)result;
57001   return jresult;
57002 }
57003
57004
57005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
57006   int jresult ;
57007   int result;
57008
57009   {
57010     try {
57011       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
57012     } catch (std::out_of_range& e) {
57013       {
57014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57015       };
57016     } catch (std::exception& e) {
57017       {
57018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57019       };
57020     } catch (...) {
57021       {
57022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57023       };
57024     }
57025   }
57026   jresult = (int)result;
57027   return jresult;
57028 }
57029
57030
57031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
57032   int jresult ;
57033   int result;
57034
57035   {
57036     try {
57037       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
57038     } catch (std::out_of_range& e) {
57039       {
57040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57041       };
57042     } catch (std::exception& e) {
57043       {
57044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57045       };
57046     } catch (...) {
57047       {
57048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57049       };
57050     }
57051   }
57052   jresult = (int)result;
57053   return jresult;
57054 }
57055
57056
57057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
57058   int jresult ;
57059   int result;
57060
57061   {
57062     try {
57063       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
57064     } catch (std::out_of_range& e) {
57065       {
57066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57067       };
57068     } catch (std::exception& e) {
57069       {
57070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57071       };
57072     } catch (...) {
57073       {
57074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57075       };
57076     }
57077   }
57078   jresult = (int)result;
57079   return jresult;
57080 }
57081
57082
57083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
57084   int jresult ;
57085   int result;
57086
57087   {
57088     try {
57089       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
57090     } catch (std::out_of_range& e) {
57091       {
57092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57093       };
57094     } catch (std::exception& e) {
57095       {
57096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57097       };
57098     } catch (...) {
57099       {
57100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57101       };
57102     }
57103   }
57104   jresult = (int)result;
57105   return jresult;
57106 }
57107
57108
57109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
57110   int jresult ;
57111   int result;
57112
57113   {
57114     try {
57115       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
57116     } catch (std::out_of_range& e) {
57117       {
57118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57119       };
57120     } catch (std::exception& e) {
57121       {
57122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57123       };
57124     } catch (...) {
57125       {
57126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57127       };
57128     }
57129   }
57130   jresult = (int)result;
57131   return jresult;
57132 }
57133
57134
57135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
57136   int jresult ;
57137   int result;
57138
57139   {
57140     try {
57141       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
57142     } catch (std::out_of_range& e) {
57143       {
57144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57145       };
57146     } catch (std::exception& e) {
57147       {
57148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57149       };
57150     } catch (...) {
57151       {
57152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57153       };
57154     }
57155   }
57156   jresult = (int)result;
57157   return jresult;
57158 }
57159
57160
57161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
57162   int jresult ;
57163   int result;
57164
57165   {
57166     try {
57167       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
57168     } catch (std::out_of_range& e) {
57169       {
57170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57171       };
57172     } catch (std::exception& e) {
57173       {
57174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57175       };
57176     } catch (...) {
57177       {
57178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57179       };
57180     }
57181   }
57182   jresult = (int)result;
57183   return jresult;
57184 }
57185
57186
57187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
57188   int jresult ;
57189   int result;
57190
57191   {
57192     try {
57193       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
57194     } catch (std::out_of_range& e) {
57195       {
57196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57197       };
57198     } catch (std::exception& e) {
57199       {
57200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57201       };
57202     } catch (...) {
57203       {
57204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57205       };
57206     }
57207   }
57208   jresult = (int)result;
57209   return jresult;
57210 }
57211
57212
57213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
57214   int jresult ;
57215   int result;
57216
57217   {
57218     try {
57219       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
57220     } catch (std::out_of_range& e) {
57221       {
57222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57223       };
57224     } catch (std::exception& e) {
57225       {
57226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57227       };
57228     } catch (...) {
57229       {
57230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57231       };
57232     }
57233   }
57234   jresult = (int)result;
57235   return jresult;
57236 }
57237
57238
57239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
57240   int jresult ;
57241   int result;
57242
57243   {
57244     try {
57245       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
57246     } catch (std::out_of_range& e) {
57247       {
57248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57249       };
57250     } catch (std::exception& e) {
57251       {
57252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57253       };
57254     } catch (...) {
57255       {
57256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57257       };
57258     }
57259   }
57260   jresult = (int)result;
57261   return jresult;
57262 }
57263
57264
57265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
57266   int jresult ;
57267   int result;
57268
57269   {
57270     try {
57271       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
57272     } catch (std::out_of_range& e) {
57273       {
57274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57275       };
57276     } catch (std::exception& e) {
57277       {
57278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57279       };
57280     } catch (...) {
57281       {
57282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57283       };
57284     }
57285   }
57286   jresult = (int)result;
57287   return jresult;
57288 }
57289
57290
57291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
57292   int jresult ;
57293   int result;
57294
57295   {
57296     try {
57297       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
57298     } catch (std::out_of_range& e) {
57299       {
57300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57301       };
57302     } catch (std::exception& e) {
57303       {
57304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57305       };
57306     } catch (...) {
57307       {
57308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57309       };
57310     }
57311   }
57312   jresult = (int)result;
57313   return jresult;
57314 }
57315
57316
57317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
57318   int jresult ;
57319   int result;
57320
57321   {
57322     try {
57323       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
57324     } catch (std::out_of_range& e) {
57325       {
57326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57327       };
57328     } catch (std::exception& e) {
57329       {
57330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57331       };
57332     } catch (...) {
57333       {
57334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57335       };
57336     }
57337   }
57338   jresult = (int)result;
57339   return jresult;
57340 }
57341
57342
57343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
57344   int jresult ;
57345   int result;
57346
57347   {
57348     try {
57349       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
57350     } catch (std::out_of_range& e) {
57351       {
57352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57353       };
57354     } catch (std::exception& e) {
57355       {
57356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57357       };
57358     } catch (...) {
57359       {
57360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57361       };
57362     }
57363   }
57364   jresult = (int)result;
57365   return jresult;
57366 }
57367
57368
57369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
57370   int jresult ;
57371   int result;
57372
57373   {
57374     try {
57375       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
57376     } catch (std::out_of_range& e) {
57377       {
57378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57379       };
57380     } catch (std::exception& e) {
57381       {
57382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57383       };
57384     } catch (...) {
57385       {
57386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57387       };
57388     }
57389   }
57390   jresult = (int)result;
57391   return jresult;
57392 }
57393
57394
57395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
57396   int jresult ;
57397   int result;
57398
57399   {
57400     try {
57401       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
57402     } catch (std::out_of_range& e) {
57403       {
57404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57405       };
57406     } catch (std::exception& e) {
57407       {
57408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57409       };
57410     } catch (...) {
57411       {
57412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57413       };
57414     }
57415   }
57416   jresult = (int)result;
57417   return jresult;
57418 }
57419
57420
57421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
57422   int jresult ;
57423   int result;
57424
57425   {
57426     try {
57427       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
57428     } catch (std::out_of_range& e) {
57429       {
57430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57431       };
57432     } catch (std::exception& e) {
57433       {
57434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57435       };
57436     } catch (...) {
57437       {
57438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57439       };
57440     }
57441   }
57442   jresult = (int)result;
57443   return jresult;
57444 }
57445
57446
57447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
57448   int jresult ;
57449   int result;
57450
57451   {
57452     try {
57453       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
57454     } catch (std::out_of_range& e) {
57455       {
57456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57457       };
57458     } catch (std::exception& e) {
57459       {
57460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57461       };
57462     } catch (...) {
57463       {
57464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57465       };
57466     }
57467   }
57468   jresult = (int)result;
57469   return jresult;
57470 }
57471
57472
57473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
57474   int jresult ;
57475   int result;
57476
57477   {
57478     try {
57479       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
57480     } catch (std::out_of_range& e) {
57481       {
57482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57483       };
57484     } catch (std::exception& e) {
57485       {
57486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57487       };
57488     } catch (...) {
57489       {
57490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57491       };
57492     }
57493   }
57494   jresult = (int)result;
57495   return jresult;
57496 }
57497
57498
57499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
57500   int jresult ;
57501   int result;
57502
57503   {
57504     try {
57505       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
57506     } catch (std::out_of_range& e) {
57507       {
57508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57509       };
57510     } catch (std::exception& e) {
57511       {
57512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57513       };
57514     } catch (...) {
57515       {
57516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57517       };
57518     }
57519   }
57520   jresult = (int)result;
57521   return jresult;
57522 }
57523
57524
57525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
57526   int jresult ;
57527   int result;
57528
57529   {
57530     try {
57531       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
57532     } catch (std::out_of_range& e) {
57533       {
57534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57535       };
57536     } catch (std::exception& e) {
57537       {
57538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57539       };
57540     } catch (...) {
57541       {
57542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57543       };
57544     }
57545   }
57546   jresult = (int)result;
57547   return jresult;
57548 }
57549
57550
57551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
57552   int jresult ;
57553   int result;
57554
57555   {
57556     try {
57557       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
57558     } catch (std::out_of_range& e) {
57559       {
57560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57561       };
57562     } catch (std::exception& e) {
57563       {
57564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57565       };
57566     } catch (...) {
57567       {
57568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57569       };
57570     }
57571   }
57572   jresult = (int)result;
57573   return jresult;
57574 }
57575
57576
57577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCHING_ENABLED_get() {
57578   int jresult ;
57579   int result;
57580
57581   {
57582     try {
57583       result = (int)Dali::Toolkit::ImageVisual::Property::BATCHING_ENABLED;
57584     } catch (std::out_of_range& e) {
57585       {
57586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57587       };
57588     } catch (std::exception& e) {
57589       {
57590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57591       };
57592     } catch (...) {
57593       {
57594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57595       };
57596     }
57597   }
57598   jresult = (int)result;
57599   return jresult;
57600 }
57601
57602
57603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
57604   int jresult ;
57605   int result;
57606
57607   {
57608     try {
57609       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
57610     } catch (std::out_of_range& e) {
57611       {
57612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57613       };
57614     } catch (std::exception& e) {
57615       {
57616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57617       };
57618     } catch (...) {
57619       {
57620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57621       };
57622     }
57623   }
57624   jresult = (int)result;
57625   return jresult;
57626 }
57627
57628
57629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
57630   int jresult ;
57631   int result;
57632
57633   {
57634     try {
57635       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
57636     } catch (std::out_of_range& e) {
57637       {
57638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57639       };
57640     } catch (std::exception& e) {
57641       {
57642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57643       };
57644     } catch (...) {
57645       {
57646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57647       };
57648     }
57649   }
57650   jresult = (int)result;
57651   return jresult;
57652 }
57653
57654
57655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
57656   int jresult ;
57657   int result;
57658
57659   {
57660     try {
57661       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
57662     } catch (std::out_of_range& e) {
57663       {
57664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57665       };
57666     } catch (std::exception& e) {
57667       {
57668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57669       };
57670     } catch (...) {
57671       {
57672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57673       };
57674     }
57675   }
57676   jresult = (int)result;
57677   return jresult;
57678 }
57679
57680
57681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
57682   int jresult ;
57683   int result;
57684
57685   {
57686     try {
57687       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
57688     } catch (std::out_of_range& e) {
57689       {
57690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57691       };
57692     } catch (std::exception& e) {
57693       {
57694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57695       };
57696     } catch (...) {
57697       {
57698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57699       };
57700     }
57701   }
57702   jresult = (int)result;
57703   return jresult;
57704 }
57705
57706
57707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
57708   int jresult ;
57709   int result;
57710
57711   {
57712     try {
57713       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
57714     } catch (std::out_of_range& e) {
57715       {
57716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57717       };
57718     } catch (std::exception& e) {
57719       {
57720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57721       };
57722     } catch (...) {
57723       {
57724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57725       };
57726     }
57727   }
57728   jresult = (int)result;
57729   return jresult;
57730 }
57731
57732
57733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
57734   int jresult ;
57735   int result;
57736
57737   {
57738     try {
57739       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
57740     } catch (std::out_of_range& e) {
57741       {
57742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57743       };
57744     } catch (std::exception& e) {
57745       {
57746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57747       };
57748     } catch (...) {
57749       {
57750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57751       };
57752     }
57753   }
57754   jresult = (int)result;
57755   return jresult;
57756 }
57757
57758
57759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
57760   int jresult ;
57761   int result;
57762
57763   {
57764     try {
57765       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
57766     } catch (std::out_of_range& e) {
57767       {
57768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57769       };
57770     } catch (std::exception& e) {
57771       {
57772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57773       };
57774     } catch (...) {
57775       {
57776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57777       };
57778     }
57779   }
57780   jresult = (int)result;
57781   return jresult;
57782 }
57783
57784
57785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
57786   int jresult ;
57787   int result;
57788
57789   {
57790     try {
57791       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
57792     } catch (std::out_of_range& e) {
57793       {
57794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57795       };
57796     } catch (std::exception& e) {
57797       {
57798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57799       };
57800     } catch (...) {
57801       {
57802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57803       };
57804     }
57805   }
57806   jresult = (int)result;
57807   return jresult;
57808 }
57809
57810
57811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
57812   int jresult ;
57813   int result;
57814
57815   {
57816     try {
57817       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
57818     } catch (std::out_of_range& e) {
57819       {
57820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57821       };
57822     } catch (std::exception& e) {
57823       {
57824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57825       };
57826     } catch (...) {
57827       {
57828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57829       };
57830     }
57831   }
57832   jresult = (int)result;
57833   return jresult;
57834 }
57835
57836
57837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
57838   int jresult ;
57839   int result;
57840
57841   {
57842     try {
57843       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57844     } catch (std::out_of_range& e) {
57845       {
57846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57847       };
57848     } catch (std::exception& e) {
57849       {
57850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57851       };
57852     } catch (...) {
57853       {
57854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57855       };
57856     }
57857   }
57858   jresult = (int)result;
57859   return jresult;
57860 }
57861
57862
57863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
57864   int jresult ;
57865   int result;
57866
57867   {
57868     try {
57869       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57870     } catch (std::out_of_range& e) {
57871       {
57872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57873       };
57874     } catch (std::exception& e) {
57875       {
57876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57877       };
57878     } catch (...) {
57879       {
57880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57881       };
57882     }
57883   }
57884   jresult = (int)result;
57885   return jresult;
57886 }
57887
57888
57889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57890   int jresult ;
57891   int result;
57892
57893   {
57894     try {
57895       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57896     } catch (std::out_of_range& e) {
57897       {
57898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57899       };
57900     } catch (std::exception& e) {
57901       {
57902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57903       };
57904     } catch (...) {
57905       {
57906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57907       };
57908     }
57909   }
57910   jresult = (int)result;
57911   return jresult;
57912 }
57913
57914
57915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
57916   int jresult ;
57917   int result;
57918
57919   {
57920     try {
57921       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57922     } catch (std::out_of_range& e) {
57923       {
57924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57925       };
57926     } catch (std::exception& e) {
57927       {
57928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57929       };
57930     } catch (...) {
57931       {
57932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57933       };
57934     }
57935   }
57936   jresult = (int)result;
57937   return jresult;
57938 }
57939
57940
57941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
57942   int jresult ;
57943   int result;
57944
57945   {
57946     try {
57947       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57948     } catch (std::out_of_range& e) {
57949       {
57950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57951       };
57952     } catch (std::exception& e) {
57953       {
57954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57955       };
57956     } catch (...) {
57957       {
57958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57959       };
57960     }
57961   }
57962   jresult = (int)result;
57963   return jresult;
57964 }
57965
57966
57967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57968   int jresult ;
57969   int result;
57970
57971   {
57972     try {
57973       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57974     } catch (std::out_of_range& e) {
57975       {
57976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57977       };
57978     } catch (std::exception& e) {
57979       {
57980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57981       };
57982     } catch (...) {
57983       {
57984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57985       };
57986     }
57987   }
57988   jresult = (int)result;
57989   return jresult;
57990 }
57991
57992
57993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57994   int jresult ;
57995   int result;
57996
57997   {
57998     try {
57999       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
58000     } catch (std::out_of_range& e) {
58001       {
58002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58003       };
58004     } catch (std::exception& e) {
58005       {
58006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58007       };
58008     } catch (...) {
58009       {
58010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58011       };
58012     }
58013   }
58014   jresult = (int)result;
58015   return jresult;
58016 }
58017
58018
58019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
58020   int jresult ;
58021   int result;
58022
58023   {
58024     try {
58025       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
58026     } catch (std::out_of_range& e) {
58027       {
58028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58029       };
58030     } catch (std::exception& e) {
58031       {
58032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58033       };
58034     } catch (...) {
58035       {
58036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58037       };
58038     }
58039   }
58040   jresult = (int)result;
58041   return jresult;
58042 }
58043
58044
58045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
58046   int jresult ;
58047   int result;
58048
58049   {
58050     try {
58051       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
58052     } catch (std::out_of_range& e) {
58053       {
58054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58055       };
58056     } catch (std::exception& e) {
58057       {
58058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58059       };
58060     } catch (...) {
58061       {
58062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58063       };
58064     }
58065   }
58066   jresult = (int)result;
58067   return jresult;
58068 }
58069
58070
58071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
58072   int jresult ;
58073   int result;
58074
58075   {
58076     try {
58077       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
58078     } catch (std::out_of_range& e) {
58079       {
58080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58081       };
58082     } catch (std::exception& e) {
58083       {
58084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58085       };
58086     } catch (...) {
58087       {
58088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58089       };
58090     }
58091   }
58092   jresult = (int)result;
58093   return jresult;
58094 }
58095
58096
58097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
58098   int jresult ;
58099   int result;
58100
58101   {
58102     try {
58103       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
58104     } catch (std::out_of_range& e) {
58105       {
58106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58107       };
58108     } catch (std::exception& e) {
58109       {
58110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58111       };
58112     } catch (...) {
58113       {
58114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58115       };
58116     }
58117   }
58118   jresult = (int)result;
58119   return jresult;
58120 }
58121
58122
58123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
58124   int jresult ;
58125   int result;
58126
58127   {
58128     try {
58129       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
58130     } catch (std::out_of_range& e) {
58131       {
58132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58133       };
58134     } catch (std::exception& e) {
58135       {
58136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58137       };
58138     } catch (...) {
58139       {
58140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58141       };
58142     }
58143   }
58144   jresult = (int)result;
58145   return jresult;
58146 }
58147
58148
58149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
58150   int jresult ;
58151   int result;
58152
58153   {
58154     try {
58155       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
58156     } catch (std::out_of_range& e) {
58157       {
58158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58159       };
58160     } catch (std::exception& e) {
58161       {
58162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58163       };
58164     } catch (...) {
58165       {
58166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58167       };
58168     }
58169   }
58170   jresult = (int)result;
58171   return jresult;
58172 }
58173
58174
58175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
58176   int jresult ;
58177   int result;
58178
58179   {
58180     try {
58181       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
58182     } catch (std::out_of_range& e) {
58183       {
58184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58185       };
58186     } catch (std::exception& e) {
58187       {
58188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58189       };
58190     } catch (...) {
58191       {
58192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58193       };
58194     }
58195   }
58196   jresult = (int)result;
58197   return jresult;
58198 }
58199
58200
58201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
58202   int jresult ;
58203   int result;
58204
58205   {
58206     try {
58207       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
58208     } catch (std::out_of_range& e) {
58209       {
58210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58211       };
58212     } catch (std::exception& e) {
58213       {
58214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58215       };
58216     } catch (...) {
58217       {
58218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58219       };
58220     }
58221   }
58222   jresult = (int)result;
58223   return jresult;
58224 }
58225
58226
58227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
58228   int jresult ;
58229   int result;
58230
58231   {
58232     try {
58233       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
58234     } catch (std::out_of_range& e) {
58235       {
58236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58237       };
58238     } catch (std::exception& e) {
58239       {
58240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58241       };
58242     } catch (...) {
58243       {
58244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58245       };
58246     }
58247   }
58248   jresult = (int)result;
58249   return jresult;
58250 }
58251
58252
58253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
58254   int jresult ;
58255   int result;
58256
58257   {
58258     try {
58259       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
58260     } catch (std::out_of_range& e) {
58261       {
58262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58263       };
58264     } catch (std::exception& e) {
58265       {
58266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58267       };
58268     } catch (...) {
58269       {
58270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58271       };
58272     }
58273   }
58274   jresult = (int)result;
58275   return jresult;
58276 }
58277
58278
58279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
58280   int jresult ;
58281   int result;
58282
58283   {
58284     try {
58285       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
58286     } catch (std::out_of_range& e) {
58287       {
58288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58289       };
58290     } catch (std::exception& e) {
58291       {
58292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58293       };
58294     } catch (...) {
58295       {
58296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58297       };
58298     }
58299   }
58300   jresult = (int)result;
58301   return jresult;
58302 }
58303
58304
58305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
58306   int jresult ;
58307   int result;
58308
58309   {
58310     try {
58311       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
58312     } catch (std::out_of_range& e) {
58313       {
58314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58315       };
58316     } catch (std::exception& e) {
58317       {
58318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58319       };
58320     } catch (...) {
58321       {
58322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58323       };
58324     }
58325   }
58326   jresult = (int)result;
58327   return jresult;
58328 }
58329
58330
58331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
58332   int jresult ;
58333   int result;
58334
58335   {
58336     try {
58337       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
58338     } catch (std::out_of_range& e) {
58339       {
58340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58341       };
58342     } catch (std::exception& e) {
58343       {
58344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58345       };
58346     } catch (...) {
58347       {
58348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58349       };
58350     }
58351   }
58352   jresult = (int)result;
58353   return jresult;
58354 }
58355
58356
58357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
58358   int jresult ;
58359   int result;
58360
58361   {
58362     try {
58363       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
58364     } catch (std::out_of_range& e) {
58365       {
58366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58367       };
58368     } catch (std::exception& e) {
58369       {
58370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58371       };
58372     } catch (...) {
58373       {
58374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58375       };
58376     }
58377   }
58378   jresult = (int)result;
58379   return jresult;
58380 }
58381
58382
58383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
58384   int jresult ;
58385   int result;
58386
58387   {
58388     try {
58389       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
58390     } catch (std::out_of_range& e) {
58391       {
58392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58393       };
58394     } catch (std::exception& e) {
58395       {
58396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58397       };
58398     } catch (...) {
58399       {
58400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58401       };
58402     }
58403   }
58404   jresult = (int)result;
58405   return jresult;
58406 }
58407
58408
58409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
58410   void * jresult ;
58411   Dali::Toolkit::Builder *result = 0 ;
58412
58413   {
58414     try {
58415       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
58416     } catch (std::out_of_range& e) {
58417       {
58418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58419       };
58420     } catch (std::exception& e) {
58421       {
58422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58423       };
58424     } catch (...) {
58425       {
58426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58427       };
58428     }
58429   }
58430   jresult = (void *)result;
58431   return jresult;
58432 }
58433
58434
58435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
58436   void * jresult ;
58437   Dali::Toolkit::Builder result;
58438
58439   {
58440     try {
58441       result = Dali::Toolkit::Builder::New();
58442     } catch (std::out_of_range& e) {
58443       {
58444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58445       };
58446     } catch (std::exception& e) {
58447       {
58448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58449       };
58450     } catch (...) {
58451       {
58452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58453       };
58454     }
58455   }
58456   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
58457   return jresult;
58458 }
58459
58460
58461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
58462   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58463
58464   arg1 = (Dali::Toolkit::Builder *)jarg1;
58465   {
58466     try {
58467       delete arg1;
58468     } catch (std::out_of_range& e) {
58469       {
58470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58471       };
58472     } catch (std::exception& e) {
58473       {
58474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58475       };
58476     } catch (...) {
58477       {
58478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58479       };
58480     }
58481   }
58482 }
58483
58484
58485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
58486   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58487   std::string *arg2 = 0 ;
58488   Dali::Toolkit::Builder::UIFormat arg3 ;
58489
58490   arg1 = (Dali::Toolkit::Builder *)jarg1;
58491   if (!jarg2) {
58492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58493     return ;
58494   }
58495   std::string arg2_str(jarg2);
58496   arg2 = &arg2_str;
58497   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
58498   {
58499     try {
58500       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
58501     } catch (std::out_of_range& e) {
58502       {
58503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58504       };
58505     } catch (std::exception& e) {
58506       {
58507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58508       };
58509     } catch (...) {
58510       {
58511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58512       };
58513     }
58514   }
58515
58516   //argout typemap for const std::string&
58517
58518 }
58519
58520
58521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
58522   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58523   std::string *arg2 = 0 ;
58524
58525   arg1 = (Dali::Toolkit::Builder *)jarg1;
58526   if (!jarg2) {
58527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58528     return ;
58529   }
58530   std::string arg2_str(jarg2);
58531   arg2 = &arg2_str;
58532   {
58533     try {
58534       (arg1)->LoadFromString((std::string const &)*arg2);
58535     } catch (std::out_of_range& e) {
58536       {
58537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58538       };
58539     } catch (std::exception& e) {
58540       {
58541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58542       };
58543     } catch (...) {
58544       {
58545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58546       };
58547     }
58548   }
58549
58550   //argout typemap for const std::string&
58551
58552 }
58553
58554
58555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
58556   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58557   Dali::Property::Map *arg2 = 0 ;
58558
58559   arg1 = (Dali::Toolkit::Builder *)jarg1;
58560   arg2 = (Dali::Property::Map *)jarg2;
58561   if (!arg2) {
58562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58563     return ;
58564   }
58565   {
58566     try {
58567       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
58568     } catch (std::out_of_range& e) {
58569       {
58570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58571       };
58572     } catch (std::exception& e) {
58573       {
58574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58575       };
58576     } catch (...) {
58577       {
58578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58579       };
58580     }
58581   }
58582 }
58583
58584
58585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
58586   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58587   std::string *arg2 = 0 ;
58588   Dali::Property::Value *arg3 = 0 ;
58589
58590   arg1 = (Dali::Toolkit::Builder *)jarg1;
58591   if (!jarg2) {
58592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58593     return ;
58594   }
58595   std::string arg2_str(jarg2);
58596   arg2 = &arg2_str;
58597   arg3 = (Dali::Property::Value *)jarg3;
58598   if (!arg3) {
58599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
58600     return ;
58601   }
58602   {
58603     try {
58604       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
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   //argout typemap for const std::string&
58621
58622 }
58623
58624
58625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
58626   void * jresult ;
58627   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58628   Dali::Property::Map *result = 0 ;
58629
58630   arg1 = (Dali::Toolkit::Builder *)jarg1;
58631   {
58632     try {
58633       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
58634     } catch (std::out_of_range& e) {
58635       {
58636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58637       };
58638     } catch (std::exception& e) {
58639       {
58640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58641       };
58642     } catch (...) {
58643       {
58644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58645       };
58646     }
58647   }
58648   jresult = (void *)result;
58649   return jresult;
58650 }
58651
58652
58653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
58654   void * jresult ;
58655   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58656   std::string *arg2 = 0 ;
58657   Dali::Property::Value *result = 0 ;
58658
58659   arg1 = (Dali::Toolkit::Builder *)jarg1;
58660   if (!jarg2) {
58661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58662     return 0;
58663   }
58664   std::string arg2_str(jarg2);
58665   arg2 = &arg2_str;
58666   {
58667     try {
58668       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
58669     } catch (std::out_of_range& e) {
58670       {
58671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58672       };
58673     } catch (std::exception& e) {
58674       {
58675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58676       };
58677     } catch (...) {
58678       {
58679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58680       };
58681     }
58682   }
58683   jresult = (void *)result;
58684
58685   //argout typemap for const std::string&
58686
58687   return jresult;
58688 }
58689
58690
58691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58692   void * jresult ;
58693   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58694   std::string *arg2 = 0 ;
58695   Dali::Animation result;
58696
58697   arg1 = (Dali::Toolkit::Builder *)jarg1;
58698   if (!jarg2) {
58699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58700     return 0;
58701   }
58702   std::string arg2_str(jarg2);
58703   arg2 = &arg2_str;
58704   {
58705     try {
58706       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58707     } catch (std::out_of_range& e) {
58708       {
58709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58710       };
58711     } catch (std::exception& e) {
58712       {
58713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58714       };
58715     } catch (...) {
58716       {
58717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58718       };
58719     }
58720   }
58721   jresult = new Dali::Animation((const Dali::Animation &)result);
58722
58723   //argout typemap for const std::string&
58724
58725   return jresult;
58726 }
58727
58728
58729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58730   void * jresult ;
58731   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58732   std::string *arg2 = 0 ;
58733   Dali::Property::Map *arg3 = 0 ;
58734   Dali::Animation result;
58735
58736   arg1 = (Dali::Toolkit::Builder *)jarg1;
58737   if (!jarg2) {
58738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58739     return 0;
58740   }
58741   std::string arg2_str(jarg2);
58742   arg2 = &arg2_str;
58743   arg3 = (Dali::Property::Map *)jarg3;
58744   if (!arg3) {
58745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58746     return 0;
58747   }
58748   {
58749     try {
58750       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58751     } catch (std::out_of_range& e) {
58752       {
58753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58754       };
58755     } catch (std::exception& e) {
58756       {
58757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58758       };
58759     } catch (...) {
58760       {
58761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58762       };
58763     }
58764   }
58765   jresult = new Dali::Animation((const Dali::Animation &)result);
58766
58767   //argout typemap for const std::string&
58768
58769   return jresult;
58770 }
58771
58772
58773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58774   void * jresult ;
58775   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58776   std::string *arg2 = 0 ;
58777   Dali::Actor arg3 ;
58778   Dali::Actor *argp3 ;
58779   Dali::Animation result;
58780
58781   arg1 = (Dali::Toolkit::Builder *)jarg1;
58782   if (!jarg2) {
58783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58784     return 0;
58785   }
58786   std::string arg2_str(jarg2);
58787   arg2 = &arg2_str;
58788   argp3 = (Dali::Actor *)jarg3;
58789   if (!argp3) {
58790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58791     return 0;
58792   }
58793   arg3 = *argp3;
58794   {
58795     try {
58796       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58797     } catch (std::out_of_range& e) {
58798       {
58799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58800       };
58801     } catch (std::exception& e) {
58802       {
58803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58804       };
58805     } catch (...) {
58806       {
58807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58808       };
58809     }
58810   }
58811   jresult = new Dali::Animation((const Dali::Animation &)result);
58812
58813   //argout typemap for const std::string&
58814
58815   return jresult;
58816 }
58817
58818
58819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58820   void * jresult ;
58821   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58822   std::string *arg2 = 0 ;
58823   Dali::Property::Map *arg3 = 0 ;
58824   Dali::Actor arg4 ;
58825   Dali::Actor *argp4 ;
58826   Dali::Animation result;
58827
58828   arg1 = (Dali::Toolkit::Builder *)jarg1;
58829   if (!jarg2) {
58830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58831     return 0;
58832   }
58833   std::string arg2_str(jarg2);
58834   arg2 = &arg2_str;
58835   arg3 = (Dali::Property::Map *)jarg3;
58836   if (!arg3) {
58837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58838     return 0;
58839   }
58840   argp4 = (Dali::Actor *)jarg4;
58841   if (!argp4) {
58842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58843     return 0;
58844   }
58845   arg4 = *argp4;
58846   {
58847     try {
58848       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58849     } catch (std::out_of_range& e) {
58850       {
58851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58852       };
58853     } catch (std::exception& e) {
58854       {
58855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58856       };
58857     } catch (...) {
58858       {
58859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58860       };
58861     }
58862   }
58863   jresult = new Dali::Animation((const Dali::Animation &)result);
58864
58865   //argout typemap for const std::string&
58866
58867   return jresult;
58868 }
58869
58870
58871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58872   void * jresult ;
58873   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58874   std::string *arg2 = 0 ;
58875   Dali::BaseHandle result;
58876
58877   arg1 = (Dali::Toolkit::Builder *)jarg1;
58878   if (!jarg2) {
58879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58880     return 0;
58881   }
58882   std::string arg2_str(jarg2);
58883   arg2 = &arg2_str;
58884   {
58885     try {
58886       result = (arg1)->Create((std::string const &)*arg2);
58887     } catch (std::out_of_range& e) {
58888       {
58889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58890       };
58891     } catch (std::exception& e) {
58892       {
58893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58894       };
58895     } catch (...) {
58896       {
58897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58898       };
58899     }
58900   }
58901   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58902
58903   //argout typemap for const std::string&
58904
58905   return jresult;
58906 }
58907
58908
58909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58910   void * jresult ;
58911   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58912   std::string *arg2 = 0 ;
58913   Dali::Property::Map *arg3 = 0 ;
58914   Dali::BaseHandle result;
58915
58916   arg1 = (Dali::Toolkit::Builder *)jarg1;
58917   if (!jarg2) {
58918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58919     return 0;
58920   }
58921   std::string arg2_str(jarg2);
58922   arg2 = &arg2_str;
58923   arg3 = (Dali::Property::Map *)jarg3;
58924   if (!arg3) {
58925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58926     return 0;
58927   }
58928   {
58929     try {
58930       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58931     } catch (std::out_of_range& e) {
58932       {
58933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58934       };
58935     } catch (std::exception& e) {
58936       {
58937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58938       };
58939     } catch (...) {
58940       {
58941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58942       };
58943     }
58944   }
58945   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58946
58947   //argout typemap for const std::string&
58948
58949   return jresult;
58950 }
58951
58952
58953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58954   void * jresult ;
58955   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58956   std::string *arg2 = 0 ;
58957   Dali::BaseHandle result;
58958
58959   arg1 = (Dali::Toolkit::Builder *)jarg1;
58960   if (!jarg2) {
58961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58962     return 0;
58963   }
58964   std::string arg2_str(jarg2);
58965   arg2 = &arg2_str;
58966   {
58967     try {
58968       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58969     } catch (std::out_of_range& e) {
58970       {
58971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58972       };
58973     } catch (std::exception& e) {
58974       {
58975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58976       };
58977     } catch (...) {
58978       {
58979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58980       };
58981     }
58982   }
58983   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58984
58985   //argout typemap for const std::string&
58986
58987   return jresult;
58988 }
58989
58990
58991 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58992   unsigned int jresult ;
58993   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58994   std::string *arg2 = 0 ;
58995   Dali::Handle *arg3 = 0 ;
58996   bool result;
58997
58998   arg1 = (Dali::Toolkit::Builder *)jarg1;
58999   if (!jarg2) {
59000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59001     return 0;
59002   }
59003   std::string arg2_str(jarg2);
59004   arg2 = &arg2_str;
59005   arg3 = (Dali::Handle *)jarg3;
59006   if (!arg3) {
59007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
59008     return 0;
59009   }
59010   {
59011     try {
59012       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
59013     } catch (std::out_of_range& e) {
59014       {
59015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59016       };
59017     } catch (std::exception& e) {
59018       {
59019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59020       };
59021     } catch (...) {
59022       {
59023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59024       };
59025     }
59026   }
59027   jresult = result;
59028
59029   //argout typemap for const std::string&
59030
59031   return jresult;
59032 }
59033
59034
59035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
59036   unsigned int jresult ;
59037   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59038   Dali::Handle *arg2 = 0 ;
59039   std::string *arg3 = 0 ;
59040   bool result;
59041
59042   arg1 = (Dali::Toolkit::Builder *)jarg1;
59043   arg2 = (Dali::Handle *)jarg2;
59044   if (!arg2) {
59045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
59046     return 0;
59047   }
59048   if (!jarg3) {
59049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59050     return 0;
59051   }
59052   std::string arg3_str(jarg3);
59053   arg3 = &arg3_str;
59054   {
59055     try {
59056       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
59057     } catch (std::out_of_range& e) {
59058       {
59059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59060       };
59061     } catch (std::exception& e) {
59062       {
59063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59064       };
59065     } catch (...) {
59066       {
59067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59068       };
59069     }
59070   }
59071   jresult = result;
59072
59073   //argout typemap for const std::string&
59074
59075   return jresult;
59076 }
59077
59078
59079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
59080   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59081   Dali::Actor arg2 ;
59082   Dali::Actor *argp2 ;
59083
59084   arg1 = (Dali::Toolkit::Builder *)jarg1;
59085   argp2 = (Dali::Actor *)jarg2;
59086   if (!argp2) {
59087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59088     return ;
59089   }
59090   arg2 = *argp2;
59091   {
59092     try {
59093       (arg1)->AddActors(arg2);
59094     } catch (std::out_of_range& e) {
59095       {
59096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59097       };
59098     } catch (std::exception& e) {
59099       {
59100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59101       };
59102     } catch (...) {
59103       {
59104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59105       };
59106     }
59107   }
59108 }
59109
59110
59111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
59112   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59113   std::string *arg2 = 0 ;
59114   Dali::Actor arg3 ;
59115   Dali::Actor *argp3 ;
59116
59117   arg1 = (Dali::Toolkit::Builder *)jarg1;
59118   if (!jarg2) {
59119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59120     return ;
59121   }
59122   std::string arg2_str(jarg2);
59123   arg2 = &arg2_str;
59124   argp3 = (Dali::Actor *)jarg3;
59125   if (!argp3) {
59126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59127     return ;
59128   }
59129   arg3 = *argp3;
59130   {
59131     try {
59132       (arg1)->AddActors((std::string const &)*arg2,arg3);
59133     } catch (std::out_of_range& e) {
59134       {
59135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59136       };
59137     } catch (std::exception& e) {
59138       {
59139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59140       };
59141     } catch (...) {
59142       {
59143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59144       };
59145     }
59146   }
59147
59148   //argout typemap for const std::string&
59149
59150 }
59151
59152
59153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
59154   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59155   std::string *arg2 = 0 ;
59156
59157   arg1 = (Dali::Toolkit::Builder *)jarg1;
59158   if (!jarg2) {
59159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59160     return ;
59161   }
59162   std::string arg2_str(jarg2);
59163   arg2 = &arg2_str;
59164   {
59165     try {
59166       (arg1)->CreateRenderTask((std::string const &)*arg2);
59167     } catch (std::out_of_range& e) {
59168       {
59169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59170       };
59171     } catch (std::exception& e) {
59172       {
59173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59174       };
59175     } catch (...) {
59176       {
59177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59178       };
59179     }
59180   }
59181
59182   //argout typemap for const std::string&
59183
59184 }
59185
59186
59187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
59188   void * jresult ;
59189   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59190   std::string *arg2 = 0 ;
59191   Dali::FrameBufferImage result;
59192
59193   arg1 = (Dali::Toolkit::Builder *)jarg1;
59194   if (!jarg2) {
59195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59196     return 0;
59197   }
59198   std::string arg2_str(jarg2);
59199   arg2 = &arg2_str;
59200   {
59201     try {
59202       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
59203     } catch (std::out_of_range& e) {
59204       {
59205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59206       };
59207     } catch (std::exception& e) {
59208       {
59209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59210       };
59211     } catch (...) {
59212       {
59213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59214       };
59215     }
59216   }
59217   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
59218
59219   //argout typemap for const std::string&
59220
59221   return jresult;
59222 }
59223
59224
59225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
59226   void * jresult ;
59227   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59228   std::string *arg2 = 0 ;
59229   Dali::Path result;
59230
59231   arg1 = (Dali::Toolkit::Builder *)jarg1;
59232   if (!jarg2) {
59233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59234     return 0;
59235   }
59236   std::string arg2_str(jarg2);
59237   arg2 = &arg2_str;
59238   {
59239     try {
59240       result = (arg1)->GetPath((std::string const &)*arg2);
59241     } catch (std::out_of_range& e) {
59242       {
59243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59244       };
59245     } catch (std::exception& e) {
59246       {
59247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59248       };
59249     } catch (...) {
59250       {
59251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59252       };
59253     }
59254   }
59255   jresult = new Dali::Path((const Dali::Path &)result);
59256
59257   //argout typemap for const std::string&
59258
59259   return jresult;
59260 }
59261
59262
59263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
59264   void * jresult ;
59265   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59266   std::string *arg2 = 0 ;
59267   Dali::PathConstrainer result;
59268
59269   arg1 = (Dali::Toolkit::Builder *)jarg1;
59270   if (!jarg2) {
59271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59272     return 0;
59273   }
59274   std::string arg2_str(jarg2);
59275   arg2 = &arg2_str;
59276   {
59277     try {
59278       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
59279     } catch (std::out_of_range& e) {
59280       {
59281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59282       };
59283     } catch (std::exception& e) {
59284       {
59285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59286       };
59287     } catch (...) {
59288       {
59289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59290       };
59291     }
59292   }
59293   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
59294
59295   //argout typemap for const std::string&
59296
59297   return jresult;
59298 }
59299
59300
59301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
59302   void * jresult ;
59303   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59304   std::string *arg2 = 0 ;
59305   Dali::LinearConstrainer result;
59306
59307   arg1 = (Dali::Toolkit::Builder *)jarg1;
59308   if (!jarg2) {
59309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59310     return 0;
59311   }
59312   std::string arg2_str(jarg2);
59313   arg2 = &arg2_str;
59314   {
59315     try {
59316       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
59317     } catch (std::out_of_range& e) {
59318       {
59319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59320       };
59321     } catch (std::exception& e) {
59322       {
59323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59324       };
59325     } catch (...) {
59326       {
59327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59328       };
59329     }
59330   }
59331   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
59332
59333   //argout typemap for const std::string&
59334
59335   return jresult;
59336 }
59337
59338
59339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
59340   void * jresult ;
59341   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59342   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
59343
59344   arg1 = (Dali::Toolkit::Builder *)jarg1;
59345   {
59346     try {
59347       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
59348     } catch (std::out_of_range& e) {
59349       {
59350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59351       };
59352     } catch (std::exception& e) {
59353       {
59354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59355       };
59356     } catch (...) {
59357       {
59358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59359       };
59360     }
59361   }
59362   jresult = (void *)result;
59363   return jresult;
59364 }
59365
59366
59367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
59368   void * jresult ;
59369   Dali::Toolkit::TransitionData *result = 0 ;
59370
59371   {
59372     try {
59373       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
59374     } catch (std::out_of_range& e) {
59375       {
59376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59377       };
59378     } catch (std::exception& e) {
59379       {
59380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59381       };
59382     } catch (...) {
59383       {
59384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59385       };
59386     }
59387   }
59388   jresult = (void *)result;
59389   return jresult;
59390 }
59391
59392
59393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
59394   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59395
59396   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59397   {
59398     try {
59399       delete arg1;
59400     } catch (std::out_of_range& e) {
59401       {
59402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59403       };
59404     } catch (std::exception& e) {
59405       {
59406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59407       };
59408     } catch (...) {
59409       {
59410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59411       };
59412     }
59413   }
59414 }
59415
59416
59417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
59418   void * jresult ;
59419   Dali::Property::Map *arg1 = 0 ;
59420   Dali::Toolkit::TransitionData result;
59421
59422   arg1 = (Dali::Property::Map *)jarg1;
59423   if (!arg1) {
59424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59425     return 0;
59426   }
59427   {
59428     try {
59429       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
59430     } catch (std::out_of_range& e) {
59431       {
59432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59433       };
59434     } catch (std::exception& e) {
59435       {
59436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59437       };
59438     } catch (...) {
59439       {
59440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59441       };
59442     }
59443   }
59444   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59445   return jresult;
59446 }
59447
59448
59449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
59450   void * jresult ;
59451   Dali::Property::Array *arg1 = 0 ;
59452   Dali::Toolkit::TransitionData result;
59453
59454   arg1 = (Dali::Property::Array *)jarg1;
59455   if (!arg1) {
59456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
59457     return 0;
59458   }
59459   {
59460     try {
59461       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
59462     } catch (std::out_of_range& e) {
59463       {
59464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59465       };
59466     } catch (std::exception& e) {
59467       {
59468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59469       };
59470     } catch (...) {
59471       {
59472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59473       };
59474     }
59475   }
59476   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59477   return jresult;
59478 }
59479
59480
59481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
59482   void * jresult ;
59483   Dali::BaseHandle arg1 ;
59484   Dali::BaseHandle *argp1 ;
59485   Dali::Toolkit::TransitionData result;
59486
59487   argp1 = (Dali::BaseHandle *)jarg1;
59488   if (!argp1) {
59489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
59490     return 0;
59491   }
59492   arg1 = *argp1;
59493   {
59494     try {
59495       result = Dali::Toolkit::TransitionData::DownCast(arg1);
59496     } catch (std::out_of_range& e) {
59497       {
59498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59499       };
59500     } catch (std::exception& e) {
59501       {
59502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59503       };
59504     } catch (...) {
59505       {
59506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59507       };
59508     }
59509   }
59510   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
59511   return jresult;
59512 }
59513
59514
59515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
59516   void * jresult ;
59517   Dali::Toolkit::TransitionData *arg1 = 0 ;
59518   Dali::Toolkit::TransitionData *result = 0 ;
59519
59520   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59521   if (!arg1) {
59522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59523     return 0;
59524   }
59525   {
59526     try {
59527       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
59528     } catch (std::out_of_range& e) {
59529       {
59530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59531       };
59532     } catch (std::exception& e) {
59533       {
59534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59535       };
59536     } catch (...) {
59537       {
59538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59539       };
59540     }
59541   }
59542   jresult = (void *)result;
59543   return jresult;
59544 }
59545
59546
59547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
59548   void * jresult ;
59549   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59550   Dali::Toolkit::TransitionData *arg2 = 0 ;
59551   Dali::Toolkit::TransitionData *result = 0 ;
59552
59553   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59554   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
59555   if (!arg2) {
59556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
59557     return 0;
59558   }
59559   {
59560     try {
59561       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
59562     } catch (std::out_of_range& e) {
59563       {
59564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59565       };
59566     } catch (std::exception& e) {
59567       {
59568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59569       };
59570     } catch (...) {
59571       {
59572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59573       };
59574     }
59575   }
59576   jresult = (void *)result;
59577   return jresult;
59578 }
59579
59580
59581 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
59582   unsigned long jresult ;
59583   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59584   size_t result;
59585
59586   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59587   {
59588     try {
59589       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
59590     } catch (std::out_of_range& e) {
59591       {
59592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59593       };
59594     } catch (std::exception& e) {
59595       {
59596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59597       };
59598     } catch (...) {
59599       {
59600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59601       };
59602     }
59603   }
59604   jresult = (unsigned long)result;
59605   return jresult;
59606 }
59607
59608
59609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59610   void * jresult ;
59611   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59612   size_t arg2 ;
59613   Dali::Property::Map result;
59614
59615   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59616   arg2 = (size_t)jarg2;
59617   {
59618     try {
59619       result = (arg1)->GetAnimatorAt(arg2);
59620     } catch (std::out_of_range& e) {
59621       {
59622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59623       };
59624     } catch (std::exception& e) {
59625       {
59626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59627       };
59628     } catch (...) {
59629       {
59630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59631       };
59632     }
59633   }
59634   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59635   return jresult;
59636 }
59637
59638
59639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
59640   void * jresult ;
59641   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
59642   Dali::Toolkit::TransitionData *result = 0 ;
59643
59644   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
59645   {
59646     try {
59647       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
59648     } catch (std::out_of_range& e) {
59649       {
59650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59651       };
59652     } catch (std::exception& e) {
59653       {
59654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59655       };
59656     } catch (...) {
59657       {
59658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59659       };
59660     }
59661   }
59662   jresult = (void *)result;
59663   return jresult;
59664 }
59665
59666
59667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
59668   int jresult ;
59669   int result;
59670
59671   {
59672     try {
59673       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
59674     } catch (std::out_of_range& e) {
59675       {
59676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59677       };
59678     } catch (std::exception& e) {
59679       {
59680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59681       };
59682     } catch (...) {
59683       {
59684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59685       };
59686     }
59687   }
59688   jresult = (int)result;
59689   return jresult;
59690 }
59691
59692
59693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
59694   int jresult ;
59695   int result;
59696
59697   {
59698     try {
59699       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
59700     } catch (std::out_of_range& e) {
59701       {
59702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59703       };
59704     } catch (std::exception& e) {
59705       {
59706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59707       };
59708     } catch (...) {
59709       {
59710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59711       };
59712     }
59713   }
59714   jresult = (int)result;
59715   return jresult;
59716 }
59717
59718
59719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
59720   int jresult ;
59721   int result;
59722
59723   {
59724     try {
59725       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
59726     } catch (std::out_of_range& e) {
59727       {
59728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59729       };
59730     } catch (std::exception& e) {
59731       {
59732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59733       };
59734     } catch (...) {
59735       {
59736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59737       };
59738     }
59739   }
59740   jresult = (int)result;
59741   return jresult;
59742 }
59743
59744
59745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
59746   int jresult ;
59747   int result;
59748
59749   {
59750     try {
59751       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
59752     } catch (std::out_of_range& e) {
59753       {
59754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59755       };
59756     } catch (std::exception& e) {
59757       {
59758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59759       };
59760     } catch (...) {
59761       {
59762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59763       };
59764     }
59765   }
59766   jresult = (int)result;
59767   return jresult;
59768 }
59769
59770
59771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
59772   int jresult ;
59773   int result;
59774
59775   {
59776     try {
59777       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
59778     } catch (std::out_of_range& e) {
59779       {
59780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59781       };
59782     } catch (std::exception& e) {
59783       {
59784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59785       };
59786     } catch (...) {
59787       {
59788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59789       };
59790     }
59791   }
59792   jresult = (int)result;
59793   return jresult;
59794 }
59795
59796
59797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
59798   int jresult ;
59799   int result;
59800
59801   {
59802     try {
59803       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
59804     } catch (std::out_of_range& e) {
59805       {
59806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59807       };
59808     } catch (std::exception& e) {
59809       {
59810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59811       };
59812     } catch (...) {
59813       {
59814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59815       };
59816     }
59817   }
59818   jresult = (int)result;
59819   return jresult;
59820 }
59821
59822
59823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59824   int jresult ;
59825   int result;
59826
59827   {
59828     try {
59829       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59830     } catch (std::out_of_range& e) {
59831       {
59832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59833       };
59834     } catch (std::exception& e) {
59835       {
59836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59837       };
59838     } catch (...) {
59839       {
59840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59841       };
59842     }
59843   }
59844   jresult = (int)result;
59845   return jresult;
59846 }
59847
59848
59849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59850   int jresult ;
59851   int result;
59852
59853   {
59854     try {
59855       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59856     } catch (std::out_of_range& e) {
59857       {
59858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59859       };
59860     } catch (std::exception& e) {
59861       {
59862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59863       };
59864     } catch (...) {
59865       {
59866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59867       };
59868     }
59869   }
59870   jresult = (int)result;
59871   return jresult;
59872 }
59873
59874
59875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59876   int jresult ;
59877   int result;
59878
59879   {
59880     try {
59881       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59882     } catch (std::out_of_range& e) {
59883       {
59884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59885       };
59886     } catch (std::exception& e) {
59887       {
59888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59889       };
59890     } catch (...) {
59891       {
59892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59893       };
59894     }
59895   }
59896   jresult = (int)result;
59897   return jresult;
59898 }
59899
59900
59901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59902   int jresult ;
59903   int result;
59904
59905   {
59906     try {
59907       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59908     } catch (std::out_of_range& e) {
59909       {
59910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59911       };
59912     } catch (std::exception& e) {
59913       {
59914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59915       };
59916     } catch (...) {
59917       {
59918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59919       };
59920     }
59921   }
59922   jresult = (int)result;
59923   return jresult;
59924 }
59925
59926
59927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59928   int jresult ;
59929   int result;
59930
59931   {
59932     try {
59933       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59934     } catch (std::out_of_range& e) {
59935       {
59936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59937       };
59938     } catch (std::exception& e) {
59939       {
59940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59941       };
59942     } catch (...) {
59943       {
59944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59945       };
59946     }
59947   }
59948   jresult = (int)result;
59949   return jresult;
59950 }
59951
59952
59953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59954   int jresult ;
59955   int result;
59956
59957   {
59958     try {
59959       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59960     } catch (std::out_of_range& e) {
59961       {
59962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59963       };
59964     } catch (std::exception& e) {
59965       {
59966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59967       };
59968     } catch (...) {
59969       {
59970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59971       };
59972     }
59973   }
59974   jresult = (int)result;
59975   return jresult;
59976 }
59977
59978
59979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59980   int jresult ;
59981   int result;
59982
59983   {
59984     try {
59985       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59986     } catch (std::out_of_range& e) {
59987       {
59988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59989       };
59990     } catch (std::exception& e) {
59991       {
59992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59993       };
59994     } catch (...) {
59995       {
59996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59997       };
59998     }
59999   }
60000   jresult = (int)result;
60001   return jresult;
60002 }
60003
60004
60005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
60006   int jresult ;
60007   int result;
60008
60009   {
60010     try {
60011       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
60012     } catch (std::out_of_range& e) {
60013       {
60014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60015       };
60016     } catch (std::exception& e) {
60017       {
60018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60019       };
60020     } catch (...) {
60021       {
60022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60023       };
60024     }
60025   }
60026   jresult = (int)result;
60027   return jresult;
60028 }
60029
60030
60031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
60032   void * jresult ;
60033   Dali::Toolkit::Control result;
60034
60035   {
60036     try {
60037       result = Dali::Toolkit::Internal::Control::New();
60038     } catch (std::out_of_range& e) {
60039       {
60040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60041       };
60042     } catch (std::exception& e) {
60043       {
60044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60045       };
60046     } catch (...) {
60047       {
60048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60049       };
60050     }
60051   }
60052   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
60053   return jresult;
60054 }
60055
60056
60057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
60058   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60059   std::string *arg2 = 0 ;
60060
60061   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60062   if (!jarg2) {
60063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60064     return ;
60065   }
60066   std::string arg2_str(jarg2);
60067   arg2 = &arg2_str;
60068   {
60069     try {
60070       (arg1)->SetStyleName((std::string const &)*arg2);
60071     } catch (std::out_of_range& e) {
60072       {
60073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60074       };
60075     } catch (std::exception& e) {
60076       {
60077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60078       };
60079     } catch (...) {
60080       {
60081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60082       };
60083     }
60084   }
60085
60086   //argout typemap for const std::string&
60087
60088 }
60089
60090
60091 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
60092   char * jresult ;
60093   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60094   std::string *result = 0 ;
60095
60096   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60097   {
60098     try {
60099       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
60100     } catch (std::out_of_range& e) {
60101       {
60102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60103       };
60104     } catch (std::exception& e) {
60105       {
60106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60107       };
60108     } catch (...) {
60109       {
60110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60111       };
60112     }
60113   }
60114   jresult = SWIG_csharp_string_callback(result->c_str());
60115   return jresult;
60116 }
60117
60118
60119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
60120   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60121   Dali::Vector4 *arg2 = 0 ;
60122
60123   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60124   arg2 = (Dali::Vector4 *)jarg2;
60125   if (!arg2) {
60126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
60127     return ;
60128   }
60129   {
60130     try {
60131       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
60132     } catch (std::out_of_range& e) {
60133       {
60134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60135       };
60136     } catch (std::exception& e) {
60137       {
60138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60139       };
60140     } catch (...) {
60141       {
60142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60143       };
60144     }
60145   }
60146 }
60147
60148
60149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
60150   void * jresult ;
60151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60152   Dali::Vector4 result;
60153
60154   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60155   {
60156     try {
60157       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
60158     } catch (std::out_of_range& e) {
60159       {
60160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60161       };
60162     } catch (std::exception& e) {
60163       {
60164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60165       };
60166     } catch (...) {
60167       {
60168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60169       };
60170     }
60171   }
60172   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
60173   return jresult;
60174 }
60175
60176
60177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
60178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60179   Dali::Image arg2 ;
60180   Dali::Image *argp2 ;
60181
60182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60183   argp2 = (Dali::Image *)jarg2;
60184   if (!argp2) {
60185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
60186     return ;
60187   }
60188   arg2 = *argp2;
60189   {
60190     try {
60191       (arg1)->SetBackgroundImage(arg2);
60192     } catch (std::out_of_range& e) {
60193       {
60194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60195       };
60196     } catch (std::exception& e) {
60197       {
60198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60199       };
60200     } catch (...) {
60201       {
60202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60203       };
60204     }
60205   }
60206 }
60207
60208
60209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
60210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60211   Dali::Property::Map *arg2 = 0 ;
60212
60213   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60214   arg2 = (Dali::Property::Map *)jarg2;
60215   if (!arg2) {
60216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60217     return ;
60218   }
60219   {
60220     try {
60221       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
60222     } catch (std::out_of_range& e) {
60223       {
60224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60225       };
60226     } catch (std::exception& e) {
60227       {
60228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60229       };
60230     } catch (...) {
60231       {
60232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60233       };
60234     }
60235   }
60236 }
60237
60238
60239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
60240   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60241
60242   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60243   {
60244     try {
60245       (arg1)->ClearBackground();
60246     } catch (std::out_of_range& e) {
60247       {
60248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60249       };
60250     } catch (std::exception& e) {
60251       {
60252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60253       };
60254     } catch (...) {
60255       {
60256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60257       };
60258     }
60259   }
60260 }
60261
60262
60263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
60264   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60265   Dali::Gesture::Type arg2 ;
60266
60267   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60268   arg2 = (Dali::Gesture::Type)jarg2;
60269   {
60270     try {
60271       (arg1)->EnableGestureDetection(arg2);
60272     } catch (std::out_of_range& e) {
60273       {
60274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60275       };
60276     } catch (std::exception& e) {
60277       {
60278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60279       };
60280     } catch (...) {
60281       {
60282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60283       };
60284     }
60285   }
60286 }
60287
60288
60289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
60290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60291   Dali::Gesture::Type arg2 ;
60292
60293   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60294   arg2 = (Dali::Gesture::Type)jarg2;
60295   {
60296     try {
60297       (arg1)->DisableGestureDetection(arg2);
60298     } catch (std::out_of_range& e) {
60299       {
60300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60301       };
60302     } catch (std::exception& e) {
60303       {
60304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60305       };
60306     } catch (...) {
60307       {
60308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60309       };
60310     }
60311   }
60312 }
60313
60314
60315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
60316   void * jresult ;
60317   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60318   Dali::PinchGestureDetector result;
60319
60320   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60321   {
60322     try {
60323       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
60324     } catch (std::out_of_range& e) {
60325       {
60326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60327       };
60328     } catch (std::exception& e) {
60329       {
60330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60331       };
60332     } catch (...) {
60333       {
60334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60335       };
60336     }
60337   }
60338   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
60339   return jresult;
60340 }
60341
60342
60343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
60344   void * jresult ;
60345   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60346   Dali::PanGestureDetector result;
60347
60348   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60349   {
60350     try {
60351       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
60352     } catch (std::out_of_range& e) {
60353       {
60354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60355       };
60356     } catch (std::exception& e) {
60357       {
60358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60359       };
60360     } catch (...) {
60361       {
60362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60363       };
60364     }
60365   }
60366   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
60367   return jresult;
60368 }
60369
60370
60371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
60372   void * jresult ;
60373   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60374   Dali::TapGestureDetector result;
60375
60376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60377   {
60378     try {
60379       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
60380     } catch (std::out_of_range& e) {
60381       {
60382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60383       };
60384     } catch (std::exception& e) {
60385       {
60386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60387       };
60388     } catch (...) {
60389       {
60390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60391       };
60392     }
60393   }
60394   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
60395   return jresult;
60396 }
60397
60398
60399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
60400   void * jresult ;
60401   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60402   Dali::LongPressGestureDetector result;
60403
60404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60405   {
60406     try {
60407       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
60408     } catch (std::out_of_range& e) {
60409       {
60410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60411       };
60412     } catch (std::exception& e) {
60413       {
60414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60415       };
60416     } catch (...) {
60417       {
60418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60419       };
60420     }
60421   }
60422   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
60423   return jresult;
60424 }
60425
60426
60427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
60428   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60429   bool arg2 ;
60430
60431   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60432   arg2 = jarg2 ? true : false;
60433   {
60434     try {
60435       (arg1)->SetKeyboardNavigationSupport(arg2);
60436     } catch (std::out_of_range& e) {
60437       {
60438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60439       };
60440     } catch (std::exception& e) {
60441       {
60442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60443       };
60444     } catch (...) {
60445       {
60446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60447       };
60448     }
60449   }
60450 }
60451
60452
60453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
60454   unsigned int jresult ;
60455   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60456   bool result;
60457
60458   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60459   {
60460     try {
60461       result = (bool)(arg1)->IsKeyboardNavigationSupported();
60462     } catch (std::out_of_range& e) {
60463       {
60464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60465       };
60466     } catch (std::exception& e) {
60467       {
60468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60469       };
60470     } catch (...) {
60471       {
60472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60473       };
60474     }
60475   }
60476   jresult = result;
60477   return jresult;
60478 }
60479
60480
60481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
60482   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60483
60484   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60485   {
60486     try {
60487       (arg1)->SetKeyInputFocus();
60488     } catch (std::out_of_range& e) {
60489       {
60490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60491       };
60492     } catch (std::exception& e) {
60493       {
60494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60495       };
60496     } catch (...) {
60497       {
60498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60499       };
60500     }
60501   }
60502 }
60503
60504
60505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
60506   unsigned int jresult ;
60507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60508   bool result;
60509
60510   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60511   {
60512     try {
60513       result = (bool)(arg1)->HasKeyInputFocus();
60514     } catch (std::out_of_range& e) {
60515       {
60516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60517       };
60518     } catch (std::exception& e) {
60519       {
60520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60521       };
60522     } catch (...) {
60523       {
60524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60525       };
60526     }
60527   }
60528   jresult = result;
60529   return jresult;
60530 }
60531
60532
60533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60535
60536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60537   {
60538     try {
60539       (arg1)->ClearKeyInputFocus();
60540     } catch (std::out_of_range& e) {
60541       {
60542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60543       };
60544     } catch (std::exception& e) {
60545       {
60546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60547       };
60548     } catch (...) {
60549       {
60550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60551       };
60552     }
60553   }
60554 }
60555
60556
60557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60558   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60559   bool arg2 ;
60560
60561   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60562   arg2 = jarg2 ? true : false;
60563   {
60564     try {
60565       (arg1)->SetAsKeyboardFocusGroup(arg2);
60566     } catch (std::out_of_range& e) {
60567       {
60568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60569       };
60570     } catch (std::exception& e) {
60571       {
60572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60573       };
60574     } catch (...) {
60575       {
60576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60577       };
60578     }
60579   }
60580 }
60581
60582
60583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60584   unsigned int jresult ;
60585   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60586   bool result;
60587
60588   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60589   {
60590     try {
60591       result = (bool)(arg1)->IsKeyboardFocusGroup();
60592     } catch (std::out_of_range& e) {
60593       {
60594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60595       };
60596     } catch (std::exception& e) {
60597       {
60598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60599       };
60600     } catch (...) {
60601       {
60602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60603       };
60604     }
60605   }
60606   jresult = result;
60607   return jresult;
60608 }
60609
60610
60611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
60612   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60613
60614   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60615   {
60616     try {
60617       (arg1)->AccessibilityActivate();
60618     } catch (std::out_of_range& e) {
60619       {
60620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60621       };
60622     } catch (std::exception& e) {
60623       {
60624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60625       };
60626     } catch (...) {
60627       {
60628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60629       };
60630     }
60631   }
60632 }
60633
60634
60635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
60636   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60637
60638   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60639   {
60640     try {
60641       (arg1)->KeyboardEnter();
60642     } catch (std::out_of_range& e) {
60643       {
60644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60645       };
60646     } catch (std::exception& e) {
60647       {
60648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60649       };
60650     } catch (...) {
60651       {
60652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60653       };
60654     }
60655   }
60656 }
60657
60658
60659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
60660   void * jresult ;
60661   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60662   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60663
60664   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60665   {
60666     try {
60667       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60668     } catch (std::out_of_range& e) {
60669       {
60670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60671       };
60672     } catch (std::exception& e) {
60673       {
60674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60675       };
60676     } catch (...) {
60677       {
60678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60679       };
60680     }
60681   }
60682   jresult = (void *)result;
60683   return jresult;
60684 }
60685
60686
60687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60688   void * jresult ;
60689   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60690   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60691
60692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60693   {
60694     try {
60695       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60696     } catch (std::out_of_range& e) {
60697       {
60698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60699       };
60700     } catch (std::exception& e) {
60701       {
60702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60703       };
60704     } catch (...) {
60705       {
60706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60707       };
60708     }
60709   }
60710   jresult = (void *)result;
60711   return jresult;
60712 }
60713
60714
60715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60716   void * jresult ;
60717   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60718   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60719
60720   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60721   {
60722     try {
60723       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60724     } catch (std::out_of_range& e) {
60725       {
60726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60727       };
60728     } catch (std::exception& e) {
60729       {
60730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60731       };
60732     } catch (...) {
60733       {
60734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60735       };
60736     }
60737   }
60738   jresult = (void *)result;
60739   return jresult;
60740 }
60741
60742
60743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
60744   unsigned int jresult ;
60745   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60746   Dali::KeyEvent *arg2 = 0 ;
60747   bool result;
60748
60749   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60750   arg2 = (Dali::KeyEvent *)jarg2;
60751   if (!arg2) {
60752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60753     return 0;
60754   }
60755   {
60756     try {
60757       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
60758     } catch (std::out_of_range& e) {
60759       {
60760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60761       };
60762     } catch (std::exception& e) {
60763       {
60764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60765       };
60766     } catch (...) {
60767       {
60768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60769       };
60770     }
60771   }
60772   jresult = result;
60773   return jresult;
60774 }
60775
60776
60777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
60778   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60779   int arg2 ;
60780   SwigDirector_ViewImpl *darg = 0;
60781
60782   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60783   arg2 = (int)jarg2;
60784   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60785   {
60786     try {
60787       (darg)->OnStageConnection(arg2);
60788     } catch (std::out_of_range& e) {
60789       {
60790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60791       };
60792     } catch (std::exception& e) {
60793       {
60794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60795       };
60796     } catch (...) {
60797       {
60798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60799       };
60800     }
60801   }
60802 }
60803
60804
60805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60806   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60807   int arg2 ;
60808   SwigDirector_ViewImpl *darg = 0;
60809
60810   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60811   arg2 = (int)jarg2;
60812   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60813   {
60814     try {
60815       (darg)->OnStageConnectionSwigPublic(arg2);
60816     } catch (std::out_of_range& e) {
60817       {
60818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60819       };
60820     } catch (std::exception& e) {
60821       {
60822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60823       };
60824     } catch (...) {
60825       {
60826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60827       };
60828     }
60829   }
60830 }
60831
60832
60833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
60834   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60835   SwigDirector_ViewImpl *darg = 0;
60836
60837   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60838   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60839   {
60840     try {
60841       (darg)->OnStageDisconnection();
60842     } catch (std::out_of_range& e) {
60843       {
60844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60845       };
60846     } catch (std::exception& e) {
60847       {
60848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60849       };
60850     } catch (...) {
60851       {
60852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60853       };
60854     }
60855   }
60856 }
60857
60858
60859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
60860   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60861   SwigDirector_ViewImpl *darg = 0;
60862
60863   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60864   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60865   {
60866     try {
60867       (darg)->OnStageDisconnectionSwigPublic();
60868     } catch (std::out_of_range& e) {
60869       {
60870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60871       };
60872     } catch (std::exception& e) {
60873       {
60874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60875       };
60876     } catch (...) {
60877       {
60878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60879       };
60880     }
60881   }
60882 }
60883
60884
60885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60886   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60887   Dali::Actor *arg2 = 0 ;
60888   SwigDirector_ViewImpl *darg = 0;
60889
60890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60891   arg2 = (Dali::Actor *)jarg2;
60892   if (!arg2) {
60893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60894     return ;
60895   }
60896   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60897   {
60898     try {
60899       (darg)->OnChildAdd(*arg2);
60900     } catch (std::out_of_range& e) {
60901       {
60902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60903       };
60904     } catch (std::exception& e) {
60905       {
60906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60907       };
60908     } catch (...) {
60909       {
60910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60911       };
60912     }
60913   }
60914 }
60915
60916
60917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60918   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60919   Dali::Actor *arg2 = 0 ;
60920   SwigDirector_ViewImpl *darg = 0;
60921
60922   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60923   arg2 = (Dali::Actor *)jarg2;
60924   if (!arg2) {
60925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60926     return ;
60927   }
60928   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60929   {
60930     try {
60931       (darg)->OnChildAddSwigPublic(*arg2);
60932     } catch (std::out_of_range& e) {
60933       {
60934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60935       };
60936     } catch (std::exception& e) {
60937       {
60938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60939       };
60940     } catch (...) {
60941       {
60942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60943       };
60944     }
60945   }
60946 }
60947
60948
60949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60950   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60951   Dali::Actor *arg2 = 0 ;
60952   SwigDirector_ViewImpl *darg = 0;
60953
60954   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60955   arg2 = (Dali::Actor *)jarg2;
60956   if (!arg2) {
60957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60958     return ;
60959   }
60960   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60961   {
60962     try {
60963       (darg)->OnChildRemove(*arg2);
60964     } catch (std::out_of_range& e) {
60965       {
60966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60967       };
60968     } catch (std::exception& e) {
60969       {
60970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60971       };
60972     } catch (...) {
60973       {
60974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60975       };
60976     }
60977   }
60978 }
60979
60980
60981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60982   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60983   Dali::Actor *arg2 = 0 ;
60984   SwigDirector_ViewImpl *darg = 0;
60985
60986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60987   arg2 = (Dali::Actor *)jarg2;
60988   if (!arg2) {
60989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60990     return ;
60991   }
60992   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60993   {
60994     try {
60995       (darg)->OnChildRemoveSwigPublic(*arg2);
60996     } catch (std::out_of_range& e) {
60997       {
60998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60999       };
61000     } catch (std::exception& e) {
61001       {
61002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61003       };
61004     } catch (...) {
61005       {
61006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61007       };
61008     }
61009   }
61010 }
61011
61012
61013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
61014   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61015   Dali::Property::Index arg2 ;
61016   Dali::Property::Value arg3 ;
61017   Dali::Property::Value *argp3 ;
61018   SwigDirector_ViewImpl *darg = 0;
61019
61020   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61021   arg2 = (Dali::Property::Index)jarg2;
61022   argp3 = (Dali::Property::Value *)jarg3;
61023   if (!argp3) {
61024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
61025     return ;
61026   }
61027   arg3 = *argp3;
61028   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61029   {
61030     try {
61031       (darg)->OnPropertySet(arg2,arg3);
61032     } catch (std::out_of_range& e) {
61033       {
61034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61035       };
61036     } catch (std::exception& e) {
61037       {
61038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61039       };
61040     } catch (...) {
61041       {
61042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61043       };
61044     }
61045   }
61046 }
61047
61048
61049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
61050   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61051   Dali::Property::Index arg2 ;
61052   Dali::Property::Value arg3 ;
61053   Dali::Property::Value *argp3 ;
61054   SwigDirector_ViewImpl *darg = 0;
61055
61056   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61057   arg2 = (Dali::Property::Index)jarg2;
61058   argp3 = (Dali::Property::Value *)jarg3;
61059   if (!argp3) {
61060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
61061     return ;
61062   }
61063   arg3 = *argp3;
61064   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61065   {
61066     try {
61067       (darg)->OnPropertySetSwigPublic(arg2,arg3);
61068     } catch (std::out_of_range& e) {
61069       {
61070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61071       };
61072     } catch (std::exception& e) {
61073       {
61074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61075       };
61076     } catch (...) {
61077       {
61078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61079       };
61080     }
61081   }
61082 }
61083
61084
61085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
61086   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61087   Dali::Vector3 *arg2 = 0 ;
61088   SwigDirector_ViewImpl *darg = 0;
61089
61090   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61091   arg2 = (Dali::Vector3 *)jarg2;
61092   if (!arg2) {
61093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61094     return ;
61095   }
61096   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61097   {
61098     try {
61099       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
61100     } catch (std::out_of_range& e) {
61101       {
61102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61103       };
61104     } catch (std::exception& e) {
61105       {
61106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61107       };
61108     } catch (...) {
61109       {
61110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61111       };
61112     }
61113   }
61114 }
61115
61116
61117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61118   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61119   Dali::Vector3 *arg2 = 0 ;
61120   SwigDirector_ViewImpl *darg = 0;
61121
61122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61123   arg2 = (Dali::Vector3 *)jarg2;
61124   if (!arg2) {
61125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61126     return ;
61127   }
61128   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61129   {
61130     try {
61131       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
61132     } catch (std::out_of_range& e) {
61133       {
61134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61135       };
61136     } catch (std::exception& e) {
61137       {
61138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61139       };
61140     } catch (...) {
61141       {
61142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61143       };
61144     }
61145   }
61146 }
61147
61148
61149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
61150   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61151   Dali::Animation *arg2 = 0 ;
61152   Dali::Vector3 *arg3 = 0 ;
61153   SwigDirector_ViewImpl *darg = 0;
61154
61155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61156   arg2 = (Dali::Animation *)jarg2;
61157   if (!arg2) {
61158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61159     return ;
61160   }
61161   arg3 = (Dali::Vector3 *)jarg3;
61162   if (!arg3) {
61163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61164     return ;
61165   }
61166   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61167   {
61168     try {
61169       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
61170     } catch (std::out_of_range& e) {
61171       {
61172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61173       };
61174     } catch (std::exception& e) {
61175       {
61176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61177       };
61178     } catch (...) {
61179       {
61180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61181       };
61182     }
61183   }
61184 }
61185
61186
61187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61189   Dali::Animation *arg2 = 0 ;
61190   Dali::Vector3 *arg3 = 0 ;
61191   SwigDirector_ViewImpl *darg = 0;
61192
61193   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61194   arg2 = (Dali::Animation *)jarg2;
61195   if (!arg2) {
61196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
61197     return ;
61198   }
61199   arg3 = (Dali::Vector3 *)jarg3;
61200   if (!arg3) {
61201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
61202     return ;
61203   }
61204   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61205   {
61206     try {
61207       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
61208     } catch (std::out_of_range& e) {
61209       {
61210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61211       };
61212     } catch (std::exception& e) {
61213       {
61214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61215       };
61216     } catch (...) {
61217       {
61218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61219       };
61220     }
61221   }
61222 }
61223
61224
61225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
61226   unsigned int jresult ;
61227   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61228   Dali::TouchEvent *arg2 = 0 ;
61229   SwigDirector_ViewImpl *darg = 0;
61230   bool result;
61231
61232   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61233   arg2 = (Dali::TouchEvent *)jarg2;
61234   if (!arg2) {
61235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61236     return 0;
61237   }
61238   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61239   {
61240     try {
61241       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
61242     } catch (std::out_of_range& e) {
61243       {
61244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61245       };
61246     } catch (std::exception& e) {
61247       {
61248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61249       };
61250     } catch (...) {
61251       {
61252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61253       };
61254     }
61255   }
61256   jresult = result;
61257   return jresult;
61258 }
61259
61260
61261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61262   unsigned int jresult ;
61263   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61264   Dali::TouchEvent *arg2 = 0 ;
61265   SwigDirector_ViewImpl *darg = 0;
61266   bool result;
61267
61268   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61269   arg2 = (Dali::TouchEvent *)jarg2;
61270   if (!arg2) {
61271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61272     return 0;
61273   }
61274   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61275   {
61276     try {
61277       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
61278     } catch (std::out_of_range& e) {
61279       {
61280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61281       };
61282     } catch (std::exception& e) {
61283       {
61284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61285       };
61286     } catch (...) {
61287       {
61288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61289       };
61290     }
61291   }
61292   jresult = result;
61293   return jresult;
61294 }
61295
61296
61297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
61298   unsigned int jresult ;
61299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61300   Dali::HoverEvent *arg2 = 0 ;
61301   SwigDirector_ViewImpl *darg = 0;
61302   bool result;
61303
61304   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61305   arg2 = (Dali::HoverEvent *)jarg2;
61306   if (!arg2) {
61307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61308     return 0;
61309   }
61310   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61311   {
61312     try {
61313       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
61314     } catch (std::out_of_range& e) {
61315       {
61316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61317       };
61318     } catch (std::exception& e) {
61319       {
61320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61321       };
61322     } catch (...) {
61323       {
61324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61325       };
61326     }
61327   }
61328   jresult = result;
61329   return jresult;
61330 }
61331
61332
61333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61334   unsigned int jresult ;
61335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61336   Dali::HoverEvent *arg2 = 0 ;
61337   SwigDirector_ViewImpl *darg = 0;
61338   bool result;
61339
61340   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61341   arg2 = (Dali::HoverEvent *)jarg2;
61342   if (!arg2) {
61343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
61344     return 0;
61345   }
61346   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61347   {
61348     try {
61349       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
61350     } catch (std::out_of_range& e) {
61351       {
61352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61353       };
61354     } catch (std::exception& e) {
61355       {
61356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61357       };
61358     } catch (...) {
61359       {
61360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61361       };
61362     }
61363   }
61364   jresult = result;
61365   return jresult;
61366 }
61367
61368
61369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
61370   unsigned int jresult ;
61371   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61372   Dali::KeyEvent *arg2 = 0 ;
61373   SwigDirector_ViewImpl *darg = 0;
61374   bool result;
61375
61376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61377   arg2 = (Dali::KeyEvent *)jarg2;
61378   if (!arg2) {
61379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61380     return 0;
61381   }
61382   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61383   {
61384     try {
61385       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
61386     } catch (std::out_of_range& e) {
61387       {
61388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61389       };
61390     } catch (std::exception& e) {
61391       {
61392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61393       };
61394     } catch (...) {
61395       {
61396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61397       };
61398     }
61399   }
61400   jresult = result;
61401   return jresult;
61402 }
61403
61404
61405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61406   unsigned int jresult ;
61407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61408   Dali::KeyEvent *arg2 = 0 ;
61409   SwigDirector_ViewImpl *darg = 0;
61410   bool result;
61411
61412   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61413   arg2 = (Dali::KeyEvent *)jarg2;
61414   if (!arg2) {
61415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61416     return 0;
61417   }
61418   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61419   {
61420     try {
61421       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
61422     } catch (std::out_of_range& e) {
61423       {
61424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61425       };
61426     } catch (std::exception& e) {
61427       {
61428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61429       };
61430     } catch (...) {
61431       {
61432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61433       };
61434     }
61435   }
61436   jresult = result;
61437   return jresult;
61438 }
61439
61440
61441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
61442   unsigned int jresult ;
61443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61444   Dali::WheelEvent *arg2 = 0 ;
61445   SwigDirector_ViewImpl *darg = 0;
61446   bool result;
61447
61448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61449   arg2 = (Dali::WheelEvent *)jarg2;
61450   if (!arg2) {
61451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61452     return 0;
61453   }
61454   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61455   {
61456     try {
61457       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61458     } catch (std::out_of_range& e) {
61459       {
61460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61461       };
61462     } catch (std::exception& e) {
61463       {
61464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61465       };
61466     } catch (...) {
61467       {
61468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61469       };
61470     }
61471   }
61472   jresult = result;
61473   return jresult;
61474 }
61475
61476
61477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61478   unsigned int jresult ;
61479   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61480   Dali::WheelEvent *arg2 = 0 ;
61481   SwigDirector_ViewImpl *darg = 0;
61482   bool result;
61483
61484   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61485   arg2 = (Dali::WheelEvent *)jarg2;
61486   if (!arg2) {
61487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61488     return 0;
61489   }
61490   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61491   {
61492     try {
61493       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61494     } catch (std::out_of_range& e) {
61495       {
61496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61497       };
61498     } catch (std::exception& e) {
61499       {
61500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61501       };
61502     } catch (...) {
61503       {
61504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61505       };
61506     }
61507   }
61508   jresult = result;
61509   return jresult;
61510 }
61511
61512
61513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61514   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61515   Dali::Vector2 *arg2 = 0 ;
61516   Dali::RelayoutContainer *arg3 = 0 ;
61517   SwigDirector_ViewImpl *darg = 0;
61518
61519   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61520   arg2 = (Dali::Vector2 *)jarg2;
61521   if (!arg2) {
61522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61523     return ;
61524   }
61525   arg3 = (Dali::RelayoutContainer *)jarg3;
61526   if (!arg3) {
61527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61528     return ;
61529   }
61530   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61531   {
61532     try {
61533       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61534     } catch (std::out_of_range& e) {
61535       {
61536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61537       };
61538     } catch (std::exception& e) {
61539       {
61540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61541       };
61542     } catch (...) {
61543       {
61544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61545       };
61546     }
61547   }
61548 }
61549
61550
61551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61552   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61553   Dali::Vector2 *arg2 = 0 ;
61554   Dali::RelayoutContainer *arg3 = 0 ;
61555   SwigDirector_ViewImpl *darg = 0;
61556
61557   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61558   arg2 = (Dali::Vector2 *)jarg2;
61559   if (!arg2) {
61560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61561     return ;
61562   }
61563   arg3 = (Dali::RelayoutContainer *)jarg3;
61564   if (!arg3) {
61565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61566     return ;
61567   }
61568   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61569   {
61570     try {
61571       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61572     } catch (std::out_of_range& e) {
61573       {
61574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61575       };
61576     } catch (std::exception& e) {
61577       {
61578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61579       };
61580     } catch (...) {
61581       {
61582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61583       };
61584     }
61585   }
61586 }
61587
61588
61589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61590   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61591   Dali::ResizePolicy::Type arg2 ;
61592   Dali::Dimension::Type arg3 ;
61593   SwigDirector_ViewImpl *darg = 0;
61594
61595   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61596   arg2 = (Dali::ResizePolicy::Type)jarg2;
61597   arg3 = (Dali::Dimension::Type)jarg3;
61598   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61599   {
61600     try {
61601       (darg)->OnSetResizePolicy(arg2,arg3);
61602     } catch (std::out_of_range& e) {
61603       {
61604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61605       };
61606     } catch (std::exception& e) {
61607       {
61608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61609       };
61610     } catch (...) {
61611       {
61612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61613       };
61614     }
61615   }
61616 }
61617
61618
61619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61620   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61621   Dali::ResizePolicy::Type arg2 ;
61622   Dali::Dimension::Type arg3 ;
61623   SwigDirector_ViewImpl *darg = 0;
61624
61625   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61626   arg2 = (Dali::ResizePolicy::Type)jarg2;
61627   arg3 = (Dali::Dimension::Type)jarg3;
61628   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61629   {
61630     try {
61631       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61632     } catch (std::out_of_range& e) {
61633       {
61634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61635       };
61636     } catch (std::exception& e) {
61637       {
61638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61639       };
61640     } catch (...) {
61641       {
61642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61643       };
61644     }
61645   }
61646 }
61647
61648
61649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61650   void * jresult ;
61651   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61652   SwigDirector_ViewImpl *darg = 0;
61653   Dali::Vector3 result;
61654
61655   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61656   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61657   {
61658     try {
61659       result = (darg)->GetNaturalSize();
61660     } catch (std::out_of_range& e) {
61661       {
61662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61663       };
61664     } catch (std::exception& e) {
61665       {
61666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61667       };
61668     } catch (...) {
61669       {
61670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61671       };
61672     }
61673   }
61674   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61675   return jresult;
61676 }
61677
61678
61679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61680   void * jresult ;
61681   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61682   SwigDirector_ViewImpl *darg = 0;
61683   Dali::Vector3 result;
61684
61685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61686   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61687   {
61688     try {
61689       result = (darg)->GetNaturalSizeSwigPublic();
61690     } catch (std::out_of_range& e) {
61691       {
61692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61693       };
61694     } catch (std::exception& e) {
61695       {
61696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61697       };
61698     } catch (...) {
61699       {
61700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61701       };
61702     }
61703   }
61704   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61705   return jresult;
61706 }
61707
61708
61709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61710   float jresult ;
61711   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61712   Dali::Actor *arg2 = 0 ;
61713   Dali::Dimension::Type arg3 ;
61714   SwigDirector_ViewImpl *darg = 0;
61715   float result;
61716
61717   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61718   arg2 = (Dali::Actor *)jarg2;
61719   if (!arg2) {
61720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61721     return 0;
61722   }
61723   arg3 = (Dali::Dimension::Type)jarg3;
61724   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61725   {
61726     try {
61727       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61728     } catch (std::out_of_range& e) {
61729       {
61730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61731       };
61732     } catch (std::exception& e) {
61733       {
61734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61735       };
61736     } catch (...) {
61737       {
61738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61739       };
61740     }
61741   }
61742   jresult = result;
61743   return jresult;
61744 }
61745
61746
61747 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61748   float jresult ;
61749   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61750   Dali::Actor *arg2 = 0 ;
61751   Dali::Dimension::Type arg3 ;
61752   SwigDirector_ViewImpl *darg = 0;
61753   float result;
61754
61755   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61756   arg2 = (Dali::Actor *)jarg2;
61757   if (!arg2) {
61758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61759     return 0;
61760   }
61761   arg3 = (Dali::Dimension::Type)jarg3;
61762   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61763   {
61764     try {
61765       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61766     } catch (std::out_of_range& e) {
61767       {
61768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61769       };
61770     } catch (std::exception& e) {
61771       {
61772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61773       };
61774     } catch (...) {
61775       {
61776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61777       };
61778     }
61779   }
61780   jresult = result;
61781   return jresult;
61782 }
61783
61784
61785 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61786   float jresult ;
61787   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61788   float arg2 ;
61789   SwigDirector_ViewImpl *darg = 0;
61790   float result;
61791
61792   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61793   arg2 = (float)jarg2;
61794   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61795   {
61796     try {
61797       result = (float)(darg)->GetHeightForWidth(arg2);
61798     } catch (std::out_of_range& e) {
61799       {
61800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61801       };
61802     } catch (std::exception& e) {
61803       {
61804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61805       };
61806     } catch (...) {
61807       {
61808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61809       };
61810     }
61811   }
61812   jresult = result;
61813   return jresult;
61814 }
61815
61816
61817 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61818   float jresult ;
61819   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61820   float arg2 ;
61821   SwigDirector_ViewImpl *darg = 0;
61822   float result;
61823
61824   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61825   arg2 = (float)jarg2;
61826   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61827   {
61828     try {
61829       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61830     } catch (std::out_of_range& e) {
61831       {
61832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61833       };
61834     } catch (std::exception& e) {
61835       {
61836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61837       };
61838     } catch (...) {
61839       {
61840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61841       };
61842     }
61843   }
61844   jresult = result;
61845   return jresult;
61846 }
61847
61848
61849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61850   float jresult ;
61851   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61852   float arg2 ;
61853   SwigDirector_ViewImpl *darg = 0;
61854   float result;
61855
61856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61857   arg2 = (float)jarg2;
61858   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61859   {
61860     try {
61861       result = (float)(darg)->GetWidthForHeight(arg2);
61862     } catch (std::out_of_range& e) {
61863       {
61864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61865       };
61866     } catch (std::exception& e) {
61867       {
61868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61869       };
61870     } catch (...) {
61871       {
61872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61873       };
61874     }
61875   }
61876   jresult = result;
61877   return jresult;
61878 }
61879
61880
61881 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61882   float jresult ;
61883   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61884   float arg2 ;
61885   SwigDirector_ViewImpl *darg = 0;
61886   float result;
61887
61888   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61889   arg2 = (float)jarg2;
61890   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61891   {
61892     try {
61893       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61894     } catch (std::out_of_range& e) {
61895       {
61896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61897       };
61898     } catch (std::exception& e) {
61899       {
61900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61901       };
61902     } catch (...) {
61903       {
61904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61905       };
61906     }
61907   }
61908   jresult = result;
61909   return jresult;
61910 }
61911
61912
61913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61914   unsigned int jresult ;
61915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61916   Dali::Dimension::Type arg2 ;
61917   SwigDirector_ViewImpl *darg = 0;
61918   bool result;
61919
61920   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61921   arg2 = (Dali::Dimension::Type)jarg2;
61922   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61923   {
61924     try {
61925       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61926     } catch (std::out_of_range& e) {
61927       {
61928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61929       };
61930     } catch (std::exception& e) {
61931       {
61932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61933       };
61934     } catch (...) {
61935       {
61936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61937       };
61938     }
61939   }
61940   jresult = result;
61941   return jresult;
61942 }
61943
61944
61945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61946   unsigned int jresult ;
61947   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61948   Dali::Dimension::Type arg2 ;
61949   SwigDirector_ViewImpl *darg = 0;
61950   bool result;
61951
61952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61953   arg2 = (Dali::Dimension::Type)jarg2;
61954   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61955   {
61956     try {
61957       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61958     } catch (std::out_of_range& e) {
61959       {
61960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61961       };
61962     } catch (std::exception& e) {
61963       {
61964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61965       };
61966     } catch (...) {
61967       {
61968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61969       };
61970     }
61971   }
61972   jresult = result;
61973   return jresult;
61974 }
61975
61976
61977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61978   unsigned int jresult ;
61979   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61980   SwigDirector_ViewImpl *darg = 0;
61981   bool result;
61982
61983   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61984   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61985   {
61986     try {
61987       result = (bool)(darg)->RelayoutDependentOnChildren();
61988     } catch (std::out_of_range& e) {
61989       {
61990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61991       };
61992     } catch (std::exception& e) {
61993       {
61994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61995       };
61996     } catch (...) {
61997       {
61998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61999       };
62000     }
62001   }
62002   jresult = result;
62003   return jresult;
62004 }
62005
62006
62007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
62008   unsigned int jresult ;
62009   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62010   SwigDirector_ViewImpl *darg = 0;
62011   bool result;
62012
62013   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62014   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62015   {
62016     try {
62017       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
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 = result;
62033   return jresult;
62034 }
62035
62036
62037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
62038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62039   Dali::Dimension::Type arg2 ;
62040   SwigDirector_ViewImpl *darg = 0;
62041
62042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62043   arg2 = (Dali::Dimension::Type)jarg2;
62044   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62045   {
62046     try {
62047       (darg)->OnCalculateRelayoutSize(arg2);
62048     } catch (std::out_of_range& e) {
62049       {
62050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62051       };
62052     } catch (std::exception& e) {
62053       {
62054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62055       };
62056     } catch (...) {
62057       {
62058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62059       };
62060     }
62061   }
62062 }
62063
62064
62065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
62066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62067   Dali::Dimension::Type arg2 ;
62068   SwigDirector_ViewImpl *darg = 0;
62069
62070   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62071   arg2 = (Dali::Dimension::Type)jarg2;
62072   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62073   {
62074     try {
62075       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
62076     } catch (std::out_of_range& e) {
62077       {
62078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62079       };
62080     } catch (std::exception& e) {
62081       {
62082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62083       };
62084     } catch (...) {
62085       {
62086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62087       };
62088     }
62089   }
62090 }
62091
62092
62093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
62094   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62095   float arg2 ;
62096   Dali::Dimension::Type arg3 ;
62097   SwigDirector_ViewImpl *darg = 0;
62098
62099   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62100   arg2 = (float)jarg2;
62101   arg3 = (Dali::Dimension::Type)jarg3;
62102   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62103   {
62104     try {
62105       (darg)->OnLayoutNegotiated(arg2,arg3);
62106     } catch (std::out_of_range& e) {
62107       {
62108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62109       };
62110     } catch (std::exception& e) {
62111       {
62112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62113       };
62114     } catch (...) {
62115       {
62116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62117       };
62118     }
62119   }
62120 }
62121
62122
62123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
62124   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62125   float arg2 ;
62126   Dali::Dimension::Type arg3 ;
62127   SwigDirector_ViewImpl *darg = 0;
62128
62129   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62130   arg2 = (float)jarg2;
62131   arg3 = (Dali::Dimension::Type)jarg3;
62132   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62133   {
62134     try {
62135       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
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 void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
62154   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62155
62156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62157   {
62158     try {
62159       (arg1)->OnInitialize();
62160     } catch (std::out_of_range& e) {
62161       {
62162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62163       };
62164     } catch (std::exception& e) {
62165       {
62166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62167       };
62168     } catch (...) {
62169       {
62170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62171       };
62172     }
62173   }
62174 }
62175
62176
62177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
62178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62179
62180   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62181   {
62182     try {
62183       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
62184     } catch (std::out_of_range& e) {
62185       {
62186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62187       };
62188     } catch (std::exception& e) {
62189       {
62190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62191       };
62192     } catch (...) {
62193       {
62194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62195       };
62196     }
62197   }
62198 }
62199
62200
62201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
62202   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62203   Dali::Actor *arg2 = 0 ;
62204
62205   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62206   arg2 = (Dali::Actor *)jarg2;
62207   if (!arg2) {
62208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62209     return ;
62210   }
62211   {
62212     try {
62213       (arg1)->OnControlChildAdd(*arg2);
62214     } catch (std::out_of_range& e) {
62215       {
62216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62217       };
62218     } catch (std::exception& e) {
62219       {
62220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62221       };
62222     } catch (...) {
62223       {
62224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62225       };
62226     }
62227   }
62228 }
62229
62230
62231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62233   Dali::Actor *arg2 = 0 ;
62234
62235   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62236   arg2 = (Dali::Actor *)jarg2;
62237   if (!arg2) {
62238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62239     return ;
62240   }
62241   {
62242     try {
62243       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
62244     } catch (std::out_of_range& e) {
62245       {
62246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62247       };
62248     } catch (std::exception& e) {
62249       {
62250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62251       };
62252     } catch (...) {
62253       {
62254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62255       };
62256     }
62257   }
62258 }
62259
62260
62261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
62262   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62263   Dali::Actor *arg2 = 0 ;
62264
62265   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62266   arg2 = (Dali::Actor *)jarg2;
62267   if (!arg2) {
62268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62269     return ;
62270   }
62271   {
62272     try {
62273       (arg1)->OnControlChildRemove(*arg2);
62274     } catch (std::out_of_range& e) {
62275       {
62276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62277       };
62278     } catch (std::exception& e) {
62279       {
62280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62281       };
62282     } catch (...) {
62283       {
62284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62285       };
62286     }
62287   }
62288 }
62289
62290
62291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62292   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62293   Dali::Actor *arg2 = 0 ;
62294
62295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62296   arg2 = (Dali::Actor *)jarg2;
62297   if (!arg2) {
62298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62299     return ;
62300   }
62301   {
62302     try {
62303       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
62304     } catch (std::out_of_range& e) {
62305       {
62306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62307       };
62308     } catch (std::exception& e) {
62309       {
62310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62311       };
62312     } catch (...) {
62313       {
62314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62315       };
62316     }
62317   }
62318 }
62319
62320
62321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
62322   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62323   Dali::Toolkit::StyleManager arg2 ;
62324   Dali::StyleChange::Type arg3 ;
62325   Dali::Toolkit::StyleManager *argp2 ;
62326
62327   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62328   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62329   if (!argp2) {
62330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62331     return ;
62332   }
62333   arg2 = *argp2;
62334   arg3 = (Dali::StyleChange::Type)jarg3;
62335   {
62336     try {
62337       (arg1)->OnStyleChange(arg2,arg3);
62338     } catch (std::out_of_range& e) {
62339       {
62340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62341       };
62342     } catch (std::exception& e) {
62343       {
62344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62345       };
62346     } catch (...) {
62347       {
62348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62349       };
62350     }
62351   }
62352 }
62353
62354
62355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
62356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62357   Dali::Toolkit::StyleManager arg2 ;
62358   Dali::StyleChange::Type arg3 ;
62359   Dali::Toolkit::StyleManager *argp2 ;
62360
62361   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62362   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62363   if (!argp2) {
62364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62365     return ;
62366   }
62367   arg2 = *argp2;
62368   arg3 = (Dali::StyleChange::Type)jarg3;
62369   {
62370     try {
62371       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
62372     } catch (std::out_of_range& e) {
62373       {
62374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62375       };
62376     } catch (std::exception& e) {
62377       {
62378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62379       };
62380     } catch (...) {
62381       {
62382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62383       };
62384     }
62385   }
62386 }
62387
62388
62389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62390   unsigned int jresult ;
62391   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62392   bool result;
62393
62394   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62395   {
62396     try {
62397       result = (bool)(arg1)->OnAccessibilityActivated();
62398     } catch (std::out_of_range& e) {
62399       {
62400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62401       };
62402     } catch (std::exception& e) {
62403       {
62404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62405       };
62406     } catch (...) {
62407       {
62408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62409       };
62410     }
62411   }
62412   jresult = result;
62413   return jresult;
62414 }
62415
62416
62417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62418   unsigned int jresult ;
62419   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62420   bool result;
62421
62422   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62423   {
62424     try {
62425       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62426     } catch (std::out_of_range& e) {
62427       {
62428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62429       };
62430     } catch (std::exception& e) {
62431       {
62432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62433       };
62434     } catch (...) {
62435       {
62436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62437       };
62438     }
62439   }
62440   jresult = result;
62441   return jresult;
62442 }
62443
62444
62445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62446   unsigned int jresult ;
62447   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62448   Dali::PanGesture arg2 ;
62449   Dali::PanGesture *argp2 ;
62450   bool result;
62451
62452   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62453   argp2 = (Dali::PanGesture *)jarg2;
62454   if (!argp2) {
62455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62456     return 0;
62457   }
62458   arg2 = *argp2;
62459   {
62460     try {
62461       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62462     } catch (std::out_of_range& e) {
62463       {
62464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62465       };
62466     } catch (std::exception& e) {
62467       {
62468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62469       };
62470     } catch (...) {
62471       {
62472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62473       };
62474     }
62475   }
62476   jresult = result;
62477   return jresult;
62478 }
62479
62480
62481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62482   unsigned int jresult ;
62483   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62484   Dali::PanGesture arg2 ;
62485   Dali::PanGesture *argp2 ;
62486   bool result;
62487
62488   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62489   argp2 = (Dali::PanGesture *)jarg2;
62490   if (!argp2) {
62491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62492     return 0;
62493   }
62494   arg2 = *argp2;
62495   {
62496     try {
62497       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62498     } catch (std::out_of_range& e) {
62499       {
62500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62501       };
62502     } catch (std::exception& e) {
62503       {
62504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62505       };
62506     } catch (...) {
62507       {
62508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62509       };
62510     }
62511   }
62512   jresult = result;
62513   return jresult;
62514 }
62515
62516
62517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
62518   unsigned int jresult ;
62519   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62520   Dali::TouchEvent *arg2 = 0 ;
62521   bool result;
62522
62523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62524   arg2 = (Dali::TouchEvent *)jarg2;
62525   if (!arg2) {
62526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62527     return 0;
62528   }
62529   {
62530     try {
62531       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62532     } catch (std::out_of_range& e) {
62533       {
62534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62535       };
62536     } catch (std::exception& e) {
62537       {
62538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62539       };
62540     } catch (...) {
62541       {
62542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62543       };
62544     }
62545   }
62546   jresult = result;
62547   return jresult;
62548 }
62549
62550
62551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62552   unsigned int jresult ;
62553   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62554   Dali::TouchEvent *arg2 = 0 ;
62555   bool result;
62556
62557   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62558   arg2 = (Dali::TouchEvent *)jarg2;
62559   if (!arg2) {
62560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62561     return 0;
62562   }
62563   {
62564     try {
62565       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62566     } catch (std::out_of_range& e) {
62567       {
62568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62569       };
62570     } catch (std::exception& e) {
62571       {
62572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62573       };
62574     } catch (...) {
62575       {
62576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62577       };
62578     }
62579   }
62580   jresult = result;
62581   return jresult;
62582 }
62583
62584
62585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62586   unsigned int jresult ;
62587   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62588   bool arg2 ;
62589   bool result;
62590
62591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62592   arg2 = jarg2 ? true : false;
62593   {
62594     try {
62595       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62596     } catch (std::out_of_range& e) {
62597       {
62598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62599       };
62600     } catch (std::exception& e) {
62601       {
62602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62603       };
62604     } catch (...) {
62605       {
62606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62607       };
62608     }
62609   }
62610   jresult = result;
62611   return jresult;
62612 }
62613
62614
62615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62616   unsigned int jresult ;
62617   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62618   bool arg2 ;
62619   bool result;
62620
62621   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62622   arg2 = jarg2 ? true : false;
62623   {
62624     try {
62625       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62626     } catch (std::out_of_range& e) {
62627       {
62628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62629       };
62630     } catch (std::exception& e) {
62631       {
62632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62633       };
62634     } catch (...) {
62635       {
62636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62637       };
62638     }
62639   }
62640   jresult = result;
62641   return jresult;
62642 }
62643
62644
62645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62646   unsigned int jresult ;
62647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62648   bool result;
62649
62650   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62651   {
62652     try {
62653       result = (bool)(arg1)->OnAccessibilityZoom();
62654     } catch (std::out_of_range& e) {
62655       {
62656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62657       };
62658     } catch (std::exception& e) {
62659       {
62660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62661       };
62662     } catch (...) {
62663       {
62664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62665       };
62666     }
62667   }
62668   jresult = result;
62669   return jresult;
62670 }
62671
62672
62673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62674   unsigned int jresult ;
62675   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62676   bool result;
62677
62678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62679   {
62680     try {
62681       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62682     } catch (std::out_of_range& e) {
62683       {
62684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62685       };
62686     } catch (std::exception& e) {
62687       {
62688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62689       };
62690     } catch (...) {
62691       {
62692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62693       };
62694     }
62695   }
62696   jresult = result;
62697   return jresult;
62698 }
62699
62700
62701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62702   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62703
62704   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62705   {
62706     try {
62707       (arg1)->OnKeyInputFocusGained();
62708     } catch (std::out_of_range& e) {
62709       {
62710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62711       };
62712     } catch (std::exception& e) {
62713       {
62714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62715       };
62716     } catch (...) {
62717       {
62718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62719       };
62720     }
62721   }
62722 }
62723
62724
62725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62726   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62727
62728   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62729   {
62730     try {
62731       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62732     } catch (std::out_of_range& e) {
62733       {
62734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62735       };
62736     } catch (std::exception& e) {
62737       {
62738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62739       };
62740     } catch (...) {
62741       {
62742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62743       };
62744     }
62745   }
62746 }
62747
62748
62749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62750   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62751
62752   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62753   {
62754     try {
62755       (arg1)->OnKeyInputFocusLost();
62756     } catch (std::out_of_range& e) {
62757       {
62758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62759       };
62760     } catch (std::exception& e) {
62761       {
62762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62763       };
62764     } catch (...) {
62765       {
62766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62767       };
62768     }
62769   }
62770 }
62771
62772
62773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62775
62776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62777   {
62778     try {
62779       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62780     } catch (std::out_of_range& e) {
62781       {
62782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62783       };
62784     } catch (std::exception& e) {
62785       {
62786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62787       };
62788     } catch (...) {
62789       {
62790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62791       };
62792     }
62793   }
62794 }
62795
62796
62797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62798   void * jresult ;
62799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62800   Dali::Actor arg2 ;
62801   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62802   bool arg4 ;
62803   Dali::Actor *argp2 ;
62804   Dali::Actor result;
62805
62806   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62807   argp2 = (Dali::Actor *)jarg2;
62808   if (!argp2) {
62809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62810     return 0;
62811   }
62812   arg2 = *argp2;
62813   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62814   arg4 = jarg4 ? true : false;
62815   {
62816     try {
62817       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62818     } catch (std::out_of_range& e) {
62819       {
62820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62821       };
62822     } catch (std::exception& e) {
62823       {
62824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62825       };
62826     } catch (...) {
62827       {
62828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62829       };
62830     }
62831   }
62832   jresult = new Dali::Actor((const Dali::Actor &)result);
62833   return jresult;
62834 }
62835
62836
62837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62838   void * jresult ;
62839   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62840   Dali::Actor arg2 ;
62841   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62842   bool arg4 ;
62843   Dali::Actor *argp2 ;
62844   Dali::Actor result;
62845
62846   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62847   argp2 = (Dali::Actor *)jarg2;
62848   if (!argp2) {
62849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62850     return 0;
62851   }
62852   arg2 = *argp2;
62853   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62854   arg4 = jarg4 ? true : false;
62855   {
62856     try {
62857       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62858     } catch (std::out_of_range& e) {
62859       {
62860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62861       };
62862     } catch (std::exception& e) {
62863       {
62864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62865       };
62866     } catch (...) {
62867       {
62868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62869       };
62870     }
62871   }
62872   jresult = new Dali::Actor((const Dali::Actor &)result);
62873   return jresult;
62874 }
62875
62876
62877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62878   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62879   Dali::Actor arg2 ;
62880   Dali::Actor *argp2 ;
62881
62882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62883   argp2 = (Dali::Actor *)jarg2;
62884   if (!argp2) {
62885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62886     return ;
62887   }
62888   arg2 = *argp2;
62889   {
62890     try {
62891       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62892     } catch (std::out_of_range& e) {
62893       {
62894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62895       };
62896     } catch (std::exception& e) {
62897       {
62898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62899       };
62900     } catch (...) {
62901       {
62902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62903       };
62904     }
62905   }
62906 }
62907
62908
62909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62911   Dali::Actor arg2 ;
62912   Dali::Actor *argp2 ;
62913
62914   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62915   argp2 = (Dali::Actor *)jarg2;
62916   if (!argp2) {
62917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62918     return ;
62919   }
62920   arg2 = *argp2;
62921   {
62922     try {
62923       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62924     } catch (std::out_of_range& e) {
62925       {
62926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62927       };
62928     } catch (std::exception& e) {
62929       {
62930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62931       };
62932     } catch (...) {
62933       {
62934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62935       };
62936     }
62937   }
62938 }
62939
62940
62941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62942   unsigned int jresult ;
62943   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62944   bool result;
62945
62946   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62947   {
62948     try {
62949       result = (bool)(arg1)->OnKeyboardEnter();
62950     } catch (std::out_of_range& e) {
62951       {
62952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62953       };
62954     } catch (std::exception& e) {
62955       {
62956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62957       };
62958     } catch (...) {
62959       {
62960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62961       };
62962     }
62963   }
62964   jresult = result;
62965   return jresult;
62966 }
62967
62968
62969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62970   unsigned int jresult ;
62971   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62972   bool result;
62973
62974   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62975   {
62976     try {
62977       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62978     } catch (std::out_of_range& e) {
62979       {
62980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62981       };
62982     } catch (std::exception& e) {
62983       {
62984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62985       };
62986     } catch (...) {
62987       {
62988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62989       };
62990     }
62991   }
62992   jresult = result;
62993   return jresult;
62994 }
62995
62996
62997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62998   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62999   Dali::PinchGesture *arg2 = 0 ;
63000
63001   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63002   arg2 = (Dali::PinchGesture *)jarg2;
63003   if (!arg2) {
63004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
63005     return ;
63006   }
63007   {
63008     try {
63009       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
63010     } catch (std::out_of_range& e) {
63011       {
63012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63013       };
63014     } catch (std::exception& e) {
63015       {
63016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63017       };
63018     } catch (...) {
63019       {
63020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63021       };
63022     }
63023   }
63024 }
63025
63026
63027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63028   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63029   Dali::PinchGesture *arg2 = 0 ;
63030
63031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63032   arg2 = (Dali::PinchGesture *)jarg2;
63033   if (!arg2) {
63034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
63035     return ;
63036   }
63037   {
63038     try {
63039       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
63040     } catch (std::out_of_range& e) {
63041       {
63042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63043       };
63044     } catch (std::exception& e) {
63045       {
63046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63047       };
63048     } catch (...) {
63049       {
63050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63051       };
63052     }
63053   }
63054 }
63055
63056
63057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
63058   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63059   Dali::PanGesture *arg2 = 0 ;
63060
63061   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63062   arg2 = (Dali::PanGesture *)jarg2;
63063   if (!arg2) {
63064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
63065     return ;
63066   }
63067   {
63068     try {
63069       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
63070     } catch (std::out_of_range& e) {
63071       {
63072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63073       };
63074     } catch (std::exception& e) {
63075       {
63076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63077       };
63078     } catch (...) {
63079       {
63080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63081       };
63082     }
63083   }
63084 }
63085
63086
63087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63088   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63089   Dali::PanGesture *arg2 = 0 ;
63090
63091   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63092   arg2 = (Dali::PanGesture *)jarg2;
63093   if (!arg2) {
63094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
63095     return ;
63096   }
63097   {
63098     try {
63099       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
63100     } catch (std::out_of_range& e) {
63101       {
63102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63103       };
63104     } catch (std::exception& e) {
63105       {
63106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63107       };
63108     } catch (...) {
63109       {
63110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63111       };
63112     }
63113   }
63114 }
63115
63116
63117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
63118   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63119   Dali::TapGesture *arg2 = 0 ;
63120
63121   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63122   arg2 = (Dali::TapGesture *)jarg2;
63123   if (!arg2) {
63124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63125     return ;
63126   }
63127   {
63128     try {
63129       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
63130     } catch (std::out_of_range& e) {
63131       {
63132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63133       };
63134     } catch (std::exception& e) {
63135       {
63136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63137       };
63138     } catch (...) {
63139       {
63140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63141       };
63142     }
63143   }
63144 }
63145
63146
63147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63148   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63149   Dali::TapGesture *arg2 = 0 ;
63150
63151   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63152   arg2 = (Dali::TapGesture *)jarg2;
63153   if (!arg2) {
63154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63155     return ;
63156   }
63157   {
63158     try {
63159       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
63160     } catch (std::out_of_range& e) {
63161       {
63162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63163       };
63164     } catch (std::exception& e) {
63165       {
63166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63167       };
63168     } catch (...) {
63169       {
63170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63171       };
63172     }
63173   }
63174 }
63175
63176
63177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
63178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63179   Dali::LongPressGesture *arg2 = 0 ;
63180
63181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63182   arg2 = (Dali::LongPressGesture *)jarg2;
63183   if (!arg2) {
63184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63185     return ;
63186   }
63187   {
63188     try {
63189       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
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_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63208   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63209   Dali::LongPressGesture *arg2 = 0 ;
63210
63211   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63212   arg2 = (Dali::LongPressGesture *)jarg2;
63213   if (!arg2) {
63214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63215     return ;
63216   }
63217   {
63218     try {
63219       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
63220     } catch (std::out_of_range& e) {
63221       {
63222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63223       };
63224     } catch (std::exception& e) {
63225       {
63226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63227       };
63228     } catch (...) {
63229       {
63230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63231       };
63232     }
63233   }
63234 }
63235
63236
63237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
63238   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63239   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63240   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63241
63242   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63243   arg2 = (Dali::SlotObserver *)jarg2;
63244   arg3 = (Dali::CallbackBase *)jarg3;
63245   {
63246     try {
63247       (arg1)->SignalConnected(arg2,arg3);
63248     } catch (std::out_of_range& e) {
63249       {
63250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63251       };
63252     } catch (std::exception& e) {
63253       {
63254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63255       };
63256     } catch (...) {
63257       {
63258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63259       };
63260     }
63261   }
63262 }
63263
63264
63265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63266   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63267   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63268   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63269
63270   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63271   arg2 = (Dali::SlotObserver *)jarg2;
63272   arg3 = (Dali::CallbackBase *)jarg3;
63273   {
63274     try {
63275       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
63276     } catch (std::out_of_range& e) {
63277       {
63278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63279       };
63280     } catch (std::exception& e) {
63281       {
63282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63283       };
63284     } catch (...) {
63285       {
63286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63287       };
63288     }
63289   }
63290 }
63291
63292
63293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
63294   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63295   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63296   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63297
63298   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63299   arg2 = (Dali::SlotObserver *)jarg2;
63300   arg3 = (Dali::CallbackBase *)jarg3;
63301   {
63302     try {
63303       (arg1)->SignalDisconnected(arg2,arg3);
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 void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63322   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63323   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63324   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63325
63326   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63327   arg2 = (Dali::SlotObserver *)jarg2;
63328   arg3 = (Dali::CallbackBase *)jarg3;
63329   {
63330     try {
63331       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
63332     } catch (std::out_of_range& e) {
63333       {
63334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63335       };
63336     } catch (std::exception& e) {
63337       {
63338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63339       };
63340     } catch (...) {
63341       {
63342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63343       };
63344     }
63345   }
63346 }
63347
63348
63349 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) {
63350   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
63351   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
63352   if (director) {
63353     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);
63354   }
63355 }
63356
63357
63358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
63359   void * jresult ;
63360   Dali::Toolkit::Control *arg1 = 0 ;
63361   Dali::Toolkit::Internal::Control *result = 0 ;
63362
63363   arg1 = (Dali::Toolkit::Control *)jarg1;
63364   if (!arg1) {
63365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63366     return 0;
63367   }
63368   {
63369     try {
63370       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
63371     } catch (std::out_of_range& e) {
63372       {
63373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63374       };
63375     } catch (std::exception& e) {
63376       {
63377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63378       };
63379     } catch (...) {
63380       {
63381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63382       };
63383     }
63384   }
63385   jresult = (void *)result;
63386   return jresult;
63387 }
63388
63389
63390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
63391   int jresult ;
63392   int result;
63393
63394   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63395   jresult = (int)result;
63396   return jresult;
63397 }
63398
63399
63400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
63401   int jresult ;
63402   int result;
63403
63404   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
63405   jresult = (int)result;
63406   return jresult;
63407 }
63408
63409
63410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
63411   int jresult ;
63412   int result;
63413
63414   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
63415   jresult = (int)result;
63416   return jresult;
63417 }
63418
63419
63420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
63421   int jresult ;
63422   int result;
63423
63424   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63425   jresult = (int)result;
63426   return jresult;
63427 }
63428
63429
63430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
63431   int jresult ;
63432   int result;
63433
63434   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63435   jresult = (int)result;
63436   return jresult;
63437 }
63438
63439
63440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63441   void * jresult ;
63442   Dali::Toolkit::Control::Property *result = 0 ;
63443
63444   {
63445     try {
63446       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63447     } catch (std::out_of_range& e) {
63448       {
63449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63450       };
63451     } catch (std::exception& e) {
63452       {
63453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63454       };
63455     } catch (...) {
63456       {
63457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63458       };
63459     }
63460   }
63461   jresult = (void *)result;
63462   return jresult;
63463 }
63464
63465
63466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63467   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63468
63469   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63470   {
63471     try {
63472       delete arg1;
63473     } catch (std::out_of_range& e) {
63474       {
63475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63476       };
63477     } catch (std::exception& e) {
63478       {
63479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63480       };
63481     } catch (...) {
63482       {
63483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63484       };
63485     }
63486   }
63487 }
63488
63489
63490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63491   void * jresult ;
63492   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63493
63494   {
63495     try {
63496       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63497     } catch (std::out_of_range& e) {
63498       {
63499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63500       };
63501     } catch (std::exception& e) {
63502       {
63503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63504       };
63505     } catch (...) {
63506       {
63507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63508       };
63509     }
63510   }
63511   jresult = (void *)result;
63512   return jresult;
63513 }
63514
63515
63516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63517   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63518
63519   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63520   {
63521     try {
63522       delete arg1;
63523     } catch (std::out_of_range& e) {
63524       {
63525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63526       };
63527     } catch (std::exception& e) {
63528       {
63529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63530       };
63531     } catch (...) {
63532       {
63533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63534       };
63535     }
63536   }
63537 }
63538
63539
63540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63541   void * jresult ;
63542   Dali::Toolkit::Control result;
63543
63544   {
63545     try {
63546       result = Dali::Toolkit::Control::New();
63547     } catch (std::out_of_range& e) {
63548       {
63549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63550       };
63551     } catch (std::exception& e) {
63552       {
63553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63554       };
63555     } catch (...) {
63556       {
63557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63558       };
63559     }
63560   }
63561   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63562   return jresult;
63563 }
63564
63565
63566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63567   void * jresult ;
63568   Dali::Toolkit::Control *result = 0 ;
63569
63570   {
63571     try {
63572       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63573     } catch (std::out_of_range& e) {
63574       {
63575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63576       };
63577     } catch (std::exception& e) {
63578       {
63579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63580       };
63581     } catch (...) {
63582       {
63583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63584       };
63585     }
63586   }
63587   jresult = (void *)result;
63588   return jresult;
63589 }
63590
63591
63592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63593   void * jresult ;
63594   Dali::Toolkit::Control *arg1 = 0 ;
63595   Dali::Toolkit::Control *result = 0 ;
63596
63597   arg1 = (Dali::Toolkit::Control *)jarg1;
63598   if (!arg1) {
63599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63600     return 0;
63601   }
63602   {
63603     try {
63604       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63605     } catch (std::out_of_range& e) {
63606       {
63607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63608       };
63609     } catch (std::exception& e) {
63610       {
63611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63612       };
63613     } catch (...) {
63614       {
63615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63616       };
63617     }
63618   }
63619   jresult = (void *)result;
63620   return jresult;
63621 }
63622
63623
63624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63625   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63626
63627   arg1 = (Dali::Toolkit::Control *)jarg1;
63628   {
63629     try {
63630       delete arg1;
63631     } catch (std::out_of_range& e) {
63632       {
63633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63634       };
63635     } catch (std::exception& e) {
63636       {
63637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63638       };
63639     } catch (...) {
63640       {
63641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63642       };
63643     }
63644   }
63645 }
63646
63647
63648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63649   void * jresult ;
63650   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63651   Dali::Toolkit::Control *arg2 = 0 ;
63652   Dali::Toolkit::Control *result = 0 ;
63653
63654   arg1 = (Dali::Toolkit::Control *)jarg1;
63655   arg2 = (Dali::Toolkit::Control *)jarg2;
63656   if (!arg2) {
63657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63658     return 0;
63659   }
63660   {
63661     try {
63662       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63663     } catch (std::out_of_range& e) {
63664       {
63665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63666       };
63667     } catch (std::exception& e) {
63668       {
63669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63670       };
63671     } catch (...) {
63672       {
63673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63674       };
63675     }
63676   }
63677   jresult = (void *)result;
63678   return jresult;
63679 }
63680
63681
63682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63683   void * jresult ;
63684   Dali::BaseHandle arg1 ;
63685   Dali::BaseHandle *argp1 ;
63686   Dali::Toolkit::Control result;
63687
63688   argp1 = (Dali::BaseHandle *)jarg1;
63689   if (!argp1) {
63690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63691     return 0;
63692   }
63693   arg1 = *argp1;
63694   {
63695     try {
63696       result = Dali::Toolkit::Control::DownCast(arg1);
63697     } catch (std::out_of_range& e) {
63698       {
63699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63700       };
63701     } catch (std::exception& e) {
63702       {
63703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63704       };
63705     } catch (...) {
63706       {
63707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63708       };
63709     }
63710   }
63711   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63712   return jresult;
63713 }
63714
63715
63716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63717   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63718
63719   arg1 = (Dali::Toolkit::Control *)jarg1;
63720   {
63721     try {
63722       (arg1)->SetKeyInputFocus();
63723     } catch (std::out_of_range& e) {
63724       {
63725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63726       };
63727     } catch (std::exception& e) {
63728       {
63729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63730       };
63731     } catch (...) {
63732       {
63733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63734       };
63735     }
63736   }
63737 }
63738
63739
63740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63741   unsigned int jresult ;
63742   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63743   bool result;
63744
63745   arg1 = (Dali::Toolkit::Control *)jarg1;
63746   {
63747     try {
63748       result = (bool)(arg1)->HasKeyInputFocus();
63749     } catch (std::out_of_range& e) {
63750       {
63751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63752       };
63753     } catch (std::exception& e) {
63754       {
63755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63756       };
63757     } catch (...) {
63758       {
63759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63760       };
63761     }
63762   }
63763   jresult = result;
63764   return jresult;
63765 }
63766
63767
63768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63769   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63770
63771   arg1 = (Dali::Toolkit::Control *)jarg1;
63772   {
63773     try {
63774       (arg1)->ClearKeyInputFocus();
63775     } catch (std::out_of_range& e) {
63776       {
63777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63778       };
63779     } catch (std::exception& e) {
63780       {
63781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63782       };
63783     } catch (...) {
63784       {
63785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63786       };
63787     }
63788   }
63789 }
63790
63791
63792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63793   void * jresult ;
63794   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63795   Dali::PinchGestureDetector result;
63796
63797   arg1 = (Dali::Toolkit::Control *)jarg1;
63798   {
63799     try {
63800       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63801     } catch (std::out_of_range& e) {
63802       {
63803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63804       };
63805     } catch (std::exception& e) {
63806       {
63807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63808       };
63809     } catch (...) {
63810       {
63811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63812       };
63813     }
63814   }
63815   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63816   return jresult;
63817 }
63818
63819
63820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63821   void * jresult ;
63822   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63823   Dali::PanGestureDetector result;
63824
63825   arg1 = (Dali::Toolkit::Control *)jarg1;
63826   {
63827     try {
63828       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63829     } catch (std::out_of_range& e) {
63830       {
63831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63832       };
63833     } catch (std::exception& e) {
63834       {
63835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63836       };
63837     } catch (...) {
63838       {
63839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63840       };
63841     }
63842   }
63843   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63844   return jresult;
63845 }
63846
63847
63848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63849   void * jresult ;
63850   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63851   Dali::TapGestureDetector result;
63852
63853   arg1 = (Dali::Toolkit::Control *)jarg1;
63854   {
63855     try {
63856       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63857     } catch (std::out_of_range& e) {
63858       {
63859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63860       };
63861     } catch (std::exception& e) {
63862       {
63863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63864       };
63865     } catch (...) {
63866       {
63867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63868       };
63869     }
63870   }
63871   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63872   return jresult;
63873 }
63874
63875
63876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63877   void * jresult ;
63878   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63879   Dali::LongPressGestureDetector result;
63880
63881   arg1 = (Dali::Toolkit::Control *)jarg1;
63882   {
63883     try {
63884       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63885     } catch (std::out_of_range& e) {
63886       {
63887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63888       };
63889     } catch (std::exception& e) {
63890       {
63891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63892       };
63893     } catch (...) {
63894       {
63895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63896       };
63897     }
63898   }
63899   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63900   return jresult;
63901 }
63902
63903
63904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63905   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63906   std::string *arg2 = 0 ;
63907
63908   arg1 = (Dali::Toolkit::Control *)jarg1;
63909   if (!jarg2) {
63910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63911     return ;
63912   }
63913   std::string arg2_str(jarg2);
63914   arg2 = &arg2_str;
63915   {
63916     try {
63917       (arg1)->SetStyleName((std::string const &)*arg2);
63918     } catch (std::out_of_range& e) {
63919       {
63920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63921       };
63922     } catch (std::exception& e) {
63923       {
63924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63925       };
63926     } catch (...) {
63927       {
63928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63929       };
63930     }
63931   }
63932
63933   //argout typemap for const std::string&
63934
63935 }
63936
63937
63938 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63939   char * jresult ;
63940   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63941   std::string *result = 0 ;
63942
63943   arg1 = (Dali::Toolkit::Control *)jarg1;
63944   {
63945     try {
63946       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63947     } catch (std::out_of_range& e) {
63948       {
63949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63950       };
63951     } catch (std::exception& e) {
63952       {
63953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63954       };
63955     } catch (...) {
63956       {
63957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63958       };
63959     }
63960   }
63961   jresult = SWIG_csharp_string_callback(result->c_str());
63962   return jresult;
63963 }
63964
63965
63966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63967   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63968   Dali::Vector4 *arg2 = 0 ;
63969
63970   arg1 = (Dali::Toolkit::Control *)jarg1;
63971   arg2 = (Dali::Vector4 *)jarg2;
63972   if (!arg2) {
63973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63974     return ;
63975   }
63976   {
63977     try {
63978       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63979     } catch (std::out_of_range& e) {
63980       {
63981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63982       };
63983     } catch (std::exception& e) {
63984       {
63985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63986       };
63987     } catch (...) {
63988       {
63989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63990       };
63991     }
63992   }
63993 }
63994
63995
63996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
63997   void * jresult ;
63998   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63999   Dali::Vector4 result;
64000
64001   arg1 = (Dali::Toolkit::Control *)jarg1;
64002   {
64003     try {
64004       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
64005     } catch (std::out_of_range& e) {
64006       {
64007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64008       };
64009     } catch (std::exception& e) {
64010       {
64011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64012       };
64013     } catch (...) {
64014       {
64015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64016       };
64017     }
64018   }
64019   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
64020   return jresult;
64021 }
64022
64023
64024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
64025   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64026   Dali::Image arg2 ;
64027   Dali::Image *argp2 ;
64028
64029   arg1 = (Dali::Toolkit::Control *)jarg1;
64030   argp2 = (Dali::Image *)jarg2;
64031   if (!argp2) {
64032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64033     return ;
64034   }
64035   arg2 = *argp2;
64036   {
64037     try {
64038       (arg1)->SetBackgroundImage(arg2);
64039     } catch (std::out_of_range& e) {
64040       {
64041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64042       };
64043     } catch (std::exception& e) {
64044       {
64045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64046       };
64047     } catch (...) {
64048       {
64049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64050       };
64051     }
64052   }
64053 }
64054
64055
64056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
64057   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64058
64059   arg1 = (Dali::Toolkit::Control *)jarg1;
64060   {
64061     try {
64062       (arg1)->ClearBackground();
64063     } catch (std::out_of_range& e) {
64064       {
64065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64066       };
64067     } catch (std::exception& e) {
64068       {
64069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64070       };
64071     } catch (...) {
64072       {
64073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64074       };
64075     }
64076   }
64077 }
64078
64079
64080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
64081   void * jresult ;
64082   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64083   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64084
64085   arg1 = (Dali::Toolkit::Control *)jarg1;
64086   {
64087     try {
64088       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64089     } catch (std::out_of_range& e) {
64090       {
64091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64092       };
64093     } catch (std::exception& e) {
64094       {
64095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64096       };
64097     } catch (...) {
64098       {
64099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64100       };
64101     }
64102   }
64103   jresult = (void *)result;
64104   return jresult;
64105 }
64106
64107
64108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
64109   void * jresult ;
64110   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64111   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64112
64113   arg1 = (Dali::Toolkit::Control *)jarg1;
64114   {
64115     try {
64116       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64117     } catch (std::out_of_range& e) {
64118       {
64119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64120       };
64121     } catch (std::exception& e) {
64122       {
64123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64124       };
64125     } catch (...) {
64126       {
64127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64128       };
64129     }
64130   }
64131   jresult = (void *)result;
64132   return jresult;
64133 }
64134
64135
64136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
64137   void * jresult ;
64138   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64139   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64140
64141   arg1 = (Dali::Toolkit::Control *)jarg1;
64142   {
64143     try {
64144       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64145     } catch (std::out_of_range& e) {
64146       {
64147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64148       };
64149     } catch (std::exception& e) {
64150       {
64151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64152       };
64153     } catch (...) {
64154       {
64155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64156       };
64157     }
64158   }
64159   jresult = (void *)result;
64160   return jresult;
64161 }
64162
64163
64164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
64165   void * jresult ;
64166   Dali::Toolkit::Internal::Control *arg1 = 0 ;
64167   Dali::Toolkit::Control *result = 0 ;
64168
64169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64170   if (!arg1) {
64171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
64172     return 0;
64173   }
64174   {
64175     try {
64176       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
64177     } catch (std::out_of_range& e) {
64178       {
64179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64180       };
64181     } catch (std::exception& e) {
64182       {
64183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64184       };
64185     } catch (...) {
64186       {
64187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64188       };
64189     }
64190   }
64191   jresult = (void *)result;
64192   return jresult;
64193 }
64194
64195
64196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64197   void * jresult ;
64198   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64199
64200   {
64201     try {
64202       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
64203     } catch (std::out_of_range& e) {
64204       {
64205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64206       };
64207     } catch (std::exception& e) {
64208       {
64209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64210       };
64211     } catch (...) {
64212       {
64213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64214       };
64215     }
64216   }
64217   jresult = (void *)result;
64218   return jresult;
64219 }
64220
64221
64222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64223   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64224
64225   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64226   {
64227     try {
64228       delete arg1;
64229     } catch (std::out_of_range& e) {
64230       {
64231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64232       };
64233     } catch (std::exception& e) {
64234       {
64235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64236       };
64237     } catch (...) {
64238       {
64239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64240       };
64241     }
64242   }
64243 }
64244
64245
64246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64247   void * jresult ;
64248   Dali::Toolkit::KeyInputFocusManager result;
64249
64250   {
64251     try {
64252       result = Dali::Toolkit::KeyInputFocusManager::Get();
64253     } catch (std::out_of_range& e) {
64254       {
64255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64256       };
64257     } catch (std::exception& e) {
64258       {
64259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64260       };
64261     } catch (...) {
64262       {
64263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64264       };
64265     }
64266   }
64267   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64268   return jresult;
64269 }
64270
64271
64272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64273   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64274   Dali::Toolkit::Control arg2 ;
64275   Dali::Toolkit::Control *argp2 ;
64276
64277   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64278   argp2 = (Dali::Toolkit::Control *)jarg2;
64279   if (!argp2) {
64280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64281     return ;
64282   }
64283   arg2 = *argp2;
64284   {
64285     try {
64286       (arg1)->SetFocus(arg2);
64287     } catch (std::out_of_range& e) {
64288       {
64289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64290       };
64291     } catch (std::exception& e) {
64292       {
64293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64294       };
64295     } catch (...) {
64296       {
64297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64298       };
64299     }
64300   }
64301 }
64302
64303
64304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64305   void * jresult ;
64306   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64307   Dali::Toolkit::Control result;
64308
64309   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64310   {
64311     try {
64312       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64313     } catch (std::out_of_range& e) {
64314       {
64315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64316       };
64317     } catch (std::exception& e) {
64318       {
64319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64320       };
64321     } catch (...) {
64322       {
64323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64324       };
64325     }
64326   }
64327   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64328   return jresult;
64329 }
64330
64331
64332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64333   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64334   Dali::Toolkit::Control arg2 ;
64335   Dali::Toolkit::Control *argp2 ;
64336
64337   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64338   argp2 = (Dali::Toolkit::Control *)jarg2;
64339   if (!argp2) {
64340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64341     return ;
64342   }
64343   arg2 = *argp2;
64344   {
64345     try {
64346       (arg1)->RemoveFocus(arg2);
64347     } catch (std::out_of_range& e) {
64348       {
64349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64350       };
64351     } catch (std::exception& e) {
64352       {
64353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64354       };
64355     } catch (...) {
64356       {
64357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64358       };
64359     }
64360   }
64361 }
64362
64363
64364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_IsKeyboardListener(void * jarg1, void * jarg2) {
64365   unsigned int jresult ;
64366   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64367   Dali::Toolkit::Control arg2 ;
64368   Dali::Toolkit::Control *argp2 ;
64369   bool result;
64370
64371   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64372   argp2 = (Dali::Toolkit::Control *)jarg2;
64373   if (!argp2) {
64374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64375     return 0;
64376   }
64377   arg2 = *argp2;
64378   {
64379     try {
64380       result = (bool)(arg1)->IsKeyboardListener(arg2);
64381     } catch (std::out_of_range& e) {
64382       {
64383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64384       };
64385     } catch (std::exception& e) {
64386       {
64387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64388       };
64389     } catch (...) {
64390       {
64391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64392       };
64393     }
64394   }
64395   jresult = result;
64396   return jresult;
64397 }
64398
64399
64400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64401   void * jresult ;
64402   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64403   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64404
64405   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64406   {
64407     try {
64408       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64409     } catch (std::out_of_range& e) {
64410       {
64411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64412       };
64413     } catch (std::exception& e) {
64414       {
64415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64416       };
64417     } catch (...) {
64418       {
64419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64420       };
64421     }
64422   }
64423   jresult = (void *)result;
64424   return jresult;
64425 }
64426
64427
64428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_UnhandledKeyEventSignal(void * jarg1) {
64429   void * jresult ;
64430   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64431   Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *result = 0 ;
64432
64433   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64434   {
64435     try {
64436       result = (Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *) &(arg1)->UnhandledKeyEventSignal();
64437     } catch (std::out_of_range& e) {
64438       {
64439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64440       };
64441     } catch (std::exception& e) {
64442       {
64443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64444       };
64445     } catch (...) {
64446       {
64447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64448       };
64449     }
64450   }
64451   jresult = (void *)result;
64452   return jresult;
64453 }
64454
64455
64456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64457   void * jresult ;
64458   Dali::Toolkit::Alignment::Padding *result = 0 ;
64459
64460   {
64461     try {
64462       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64463     } catch (std::out_of_range& e) {
64464       {
64465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64466       };
64467     } catch (std::exception& e) {
64468       {
64469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64470       };
64471     } catch (...) {
64472       {
64473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64474       };
64475     }
64476   }
64477   jresult = (void *)result;
64478   return jresult;
64479 }
64480
64481
64482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64483   void * jresult ;
64484   float arg1 ;
64485   float arg2 ;
64486   float arg3 ;
64487   float arg4 ;
64488   Dali::Toolkit::Alignment::Padding *result = 0 ;
64489
64490   arg1 = (float)jarg1;
64491   arg2 = (float)jarg2;
64492   arg3 = (float)jarg3;
64493   arg4 = (float)jarg4;
64494   {
64495     try {
64496       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64497     } catch (std::out_of_range& e) {
64498       {
64499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64500       };
64501     } catch (std::exception& e) {
64502       {
64503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64504       };
64505     } catch (...) {
64506       {
64507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64508       };
64509     }
64510   }
64511   jresult = (void *)result;
64512   return jresult;
64513 }
64514
64515
64516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64517   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64518   float arg2 ;
64519
64520   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64521   arg2 = (float)jarg2;
64522   if (arg1) (arg1)->left = arg2;
64523 }
64524
64525
64526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64527   float jresult ;
64528   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64529   float result;
64530
64531   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64532   result = (float) ((arg1)->left);
64533   jresult = result;
64534   return jresult;
64535 }
64536
64537
64538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64539   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64540   float arg2 ;
64541
64542   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64543   arg2 = (float)jarg2;
64544   if (arg1) (arg1)->right = arg2;
64545 }
64546
64547
64548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64549   float jresult ;
64550   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64551   float result;
64552
64553   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64554   result = (float) ((arg1)->right);
64555   jresult = result;
64556   return jresult;
64557 }
64558
64559
64560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64561   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64562   float arg2 ;
64563
64564   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64565   arg2 = (float)jarg2;
64566   if (arg1) (arg1)->top = arg2;
64567 }
64568
64569
64570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64571   float jresult ;
64572   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64573   float result;
64574
64575   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64576   result = (float) ((arg1)->top);
64577   jresult = result;
64578   return jresult;
64579 }
64580
64581
64582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64583   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64584   float arg2 ;
64585
64586   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64587   arg2 = (float)jarg2;
64588   if (arg1) (arg1)->bottom = arg2;
64589 }
64590
64591
64592 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64593   float jresult ;
64594   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64595   float result;
64596
64597   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64598   result = (float) ((arg1)->bottom);
64599   jresult = result;
64600   return jresult;
64601 }
64602
64603
64604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64605   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64606
64607   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64608   {
64609     try {
64610       delete arg1;
64611     } catch (std::out_of_range& e) {
64612       {
64613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64614       };
64615     } catch (std::exception& e) {
64616       {
64617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64618       };
64619     } catch (...) {
64620       {
64621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64622       };
64623     }
64624   }
64625 }
64626
64627
64628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64629   void * jresult ;
64630   Dali::Toolkit::Alignment *result = 0 ;
64631
64632   {
64633     try {
64634       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64635     } catch (std::out_of_range& e) {
64636       {
64637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64638       };
64639     } catch (std::exception& e) {
64640       {
64641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64642       };
64643     } catch (...) {
64644       {
64645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64646       };
64647     }
64648   }
64649   jresult = (void *)result;
64650   return jresult;
64651 }
64652
64653
64654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64655   void * jresult ;
64656   Dali::Toolkit::Alignment::Type arg1 ;
64657   Dali::Toolkit::Alignment::Type arg2 ;
64658   Dali::Toolkit::Alignment result;
64659
64660   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64661   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64662   {
64663     try {
64664       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64665     } catch (std::out_of_range& e) {
64666       {
64667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64668       };
64669     } catch (std::exception& e) {
64670       {
64671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64672       };
64673     } catch (...) {
64674       {
64675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64676       };
64677     }
64678   }
64679   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64680   return jresult;
64681 }
64682
64683
64684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64685   void * jresult ;
64686   Dali::Toolkit::Alignment::Type arg1 ;
64687   Dali::Toolkit::Alignment result;
64688
64689   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64690   {
64691     try {
64692       result = Dali::Toolkit::Alignment::New(arg1);
64693     } catch (std::out_of_range& e) {
64694       {
64695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64696       };
64697     } catch (std::exception& e) {
64698       {
64699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64700       };
64701     } catch (...) {
64702       {
64703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64704       };
64705     }
64706   }
64707   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64708   return jresult;
64709 }
64710
64711
64712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64713   void * jresult ;
64714   Dali::Toolkit::Alignment result;
64715
64716   {
64717     try {
64718       result = Dali::Toolkit::Alignment::New();
64719     } catch (std::out_of_range& e) {
64720       {
64721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64722       };
64723     } catch (std::exception& e) {
64724       {
64725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64726       };
64727     } catch (...) {
64728       {
64729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64730       };
64731     }
64732   }
64733   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64734   return jresult;
64735 }
64736
64737
64738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64739   void * jresult ;
64740   Dali::Toolkit::Alignment *arg1 = 0 ;
64741   Dali::Toolkit::Alignment *result = 0 ;
64742
64743   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64744   if (!arg1) {
64745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64746     return 0;
64747   }
64748   {
64749     try {
64750       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64751     } catch (std::out_of_range& e) {
64752       {
64753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64754       };
64755     } catch (std::exception& e) {
64756       {
64757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64758       };
64759     } catch (...) {
64760       {
64761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64762       };
64763     }
64764   }
64765   jresult = (void *)result;
64766   return jresult;
64767 }
64768
64769
64770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64771   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64772
64773   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64774   {
64775     try {
64776       delete arg1;
64777     } catch (std::out_of_range& e) {
64778       {
64779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64780       };
64781     } catch (std::exception& e) {
64782       {
64783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64784       };
64785     } catch (...) {
64786       {
64787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64788       };
64789     }
64790   }
64791 }
64792
64793
64794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64795   void * jresult ;
64796   Dali::BaseHandle arg1 ;
64797   Dali::BaseHandle *argp1 ;
64798   Dali::Toolkit::Alignment result;
64799
64800   argp1 = (Dali::BaseHandle *)jarg1;
64801   if (!argp1) {
64802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64803     return 0;
64804   }
64805   arg1 = *argp1;
64806   {
64807     try {
64808       result = Dali::Toolkit::Alignment::DownCast(arg1);
64809     } catch (std::out_of_range& e) {
64810       {
64811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64812       };
64813     } catch (std::exception& e) {
64814       {
64815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64816       };
64817     } catch (...) {
64818       {
64819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64820       };
64821     }
64822   }
64823   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64824   return jresult;
64825 }
64826
64827
64828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64829   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64830   Dali::Toolkit::Alignment::Type arg2 ;
64831
64832   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64833   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64834   {
64835     try {
64836       (arg1)->SetAlignmentType(arg2);
64837     } catch (std::out_of_range& e) {
64838       {
64839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64840       };
64841     } catch (std::exception& e) {
64842       {
64843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64844       };
64845     } catch (...) {
64846       {
64847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64848       };
64849     }
64850   }
64851 }
64852
64853
64854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64855   int jresult ;
64856   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64857   Dali::Toolkit::Alignment::Type result;
64858
64859   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64860   {
64861     try {
64862       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64863     } catch (std::out_of_range& e) {
64864       {
64865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64866       };
64867     } catch (std::exception& e) {
64868       {
64869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64870       };
64871     } catch (...) {
64872       {
64873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64874       };
64875     }
64876   }
64877   jresult = (int)result;
64878   return jresult;
64879 }
64880
64881
64882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64883   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64884   Dali::Toolkit::Alignment::Scaling arg2 ;
64885
64886   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64887   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64888   {
64889     try {
64890       (arg1)->SetScaling(arg2);
64891     } catch (std::out_of_range& e) {
64892       {
64893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64894       };
64895     } catch (std::exception& e) {
64896       {
64897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64898       };
64899     } catch (...) {
64900       {
64901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64902       };
64903     }
64904   }
64905 }
64906
64907
64908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64909   int jresult ;
64910   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64911   Dali::Toolkit::Alignment::Scaling result;
64912
64913   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64914   {
64915     try {
64916       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64917     } catch (std::out_of_range& e) {
64918       {
64919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64920       };
64921     } catch (std::exception& e) {
64922       {
64923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64924       };
64925     } catch (...) {
64926       {
64927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64928       };
64929     }
64930   }
64931   jresult = (int)result;
64932   return jresult;
64933 }
64934
64935
64936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64937   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64938   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64939
64940   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64941   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64942   if (!arg2) {
64943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64944     return ;
64945   }
64946   {
64947     try {
64948       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64949     } catch (std::out_of_range& e) {
64950       {
64951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64952       };
64953     } catch (std::exception& e) {
64954       {
64955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64956       };
64957     } catch (...) {
64958       {
64959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64960       };
64961     }
64962   }
64963 }
64964
64965
64966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64967   void * jresult ;
64968   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64969   Dali::Toolkit::Alignment::Padding *result = 0 ;
64970
64971   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64972   {
64973     try {
64974       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64975     } catch (std::out_of_range& e) {
64976       {
64977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64978       };
64979     } catch (std::exception& e) {
64980       {
64981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64982       };
64983     } catch (...) {
64984       {
64985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64986       };
64987     }
64988   }
64989   jresult = (void *)result;
64990   return jresult;
64991 }
64992
64993
64994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64995   void * jresult ;
64996   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64997   Dali::Toolkit::Alignment *arg2 = 0 ;
64998   Dali::Toolkit::Alignment *result = 0 ;
64999
65000   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65001   arg2 = (Dali::Toolkit::Alignment *)jarg2;
65002   if (!arg2) {
65003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
65004     return 0;
65005   }
65006   {
65007     try {
65008       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
65009     } catch (std::out_of_range& e) {
65010       {
65011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65012       };
65013     } catch (std::exception& e) {
65014       {
65015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65016       };
65017     } catch (...) {
65018       {
65019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65020       };
65021     }
65022   }
65023   jresult = (void *)result;
65024   return jresult;
65025 }
65026
65027
65028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
65029   int jresult ;
65030   int result;
65031
65032   result = (int)Dali::Toolkit::Button::Property::DISABLED;
65033   jresult = (int)result;
65034   return jresult;
65035 }
65036
65037
65038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
65039   int jresult ;
65040   int result;
65041
65042   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
65043   jresult = (int)result;
65044   return jresult;
65045 }
65046
65047
65048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
65049   int jresult ;
65050   int result;
65051
65052   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
65053   jresult = (int)result;
65054   return jresult;
65055 }
65056
65057
65058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
65059   int jresult ;
65060   int result;
65061
65062   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
65063   jresult = (int)result;
65064   return jresult;
65065 }
65066
65067
65068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
65069   int jresult ;
65070   int result;
65071
65072   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
65073   jresult = (int)result;
65074   return jresult;
65075 }
65076
65077
65078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
65079   int jresult ;
65080   int result;
65081
65082   result = (int)Dali::Toolkit::Button::Property::SELECTED;
65083   jresult = (int)result;
65084   return jresult;
65085 }
65086
65087
65088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_STATE_IMAGE_get() {
65089   int jresult ;
65090   int result;
65091
65092   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_STATE_IMAGE;
65093   jresult = (int)result;
65094   return jresult;
65095 }
65096
65097
65098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_STATE_IMAGE_get() {
65099   int jresult ;
65100   int result;
65101
65102   result = (int)Dali::Toolkit::Button::Property::SELECTED_STATE_IMAGE;
65103   jresult = (int)result;
65104   return jresult;
65105 }
65106
65107
65108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_STATE_IMAGE_get() {
65109   int jresult ;
65110   int result;
65111
65112   result = (int)Dali::Toolkit::Button::Property::DISABLED_STATE_IMAGE;
65113   jresult = (int)result;
65114   return jresult;
65115 }
65116
65117
65118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
65119   int jresult ;
65120   int result;
65121
65122   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
65123   jresult = (int)result;
65124   return jresult;
65125 }
65126
65127
65128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
65129   int jresult ;
65130   int result;
65131
65132   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
65133   jresult = (int)result;
65134   return jresult;
65135 }
65136
65137
65138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
65139   int jresult ;
65140   int result;
65141
65142   result = (int)Dali::Toolkit::Button::Property::LABEL;
65143   jresult = (int)result;
65144   return jresult;
65145 }
65146
65147
65148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
65149   int jresult ;
65150   int result;
65151
65152   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
65153   jresult = (int)result;
65154   return jresult;
65155 }
65156
65157
65158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
65159   void * jresult ;
65160   Dali::Toolkit::Button::Property *result = 0 ;
65161
65162   {
65163     try {
65164       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
65165     } catch (std::out_of_range& e) {
65166       {
65167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65168       };
65169     } catch (std::exception& e) {
65170       {
65171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65172       };
65173     } catch (...) {
65174       {
65175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65176       };
65177     }
65178   }
65179   jresult = (void *)result;
65180   return jresult;
65181 }
65182
65183
65184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
65185   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65186
65187   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65188   {
65189     try {
65190       delete arg1;
65191     } catch (std::out_of_range& e) {
65192       {
65193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65194       };
65195     } catch (std::exception& e) {
65196       {
65197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65198       };
65199     } catch (...) {
65200       {
65201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65202       };
65203     }
65204   }
65205 }
65206
65207
65208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65209   void * jresult ;
65210   Dali::Toolkit::Button *result = 0 ;
65211
65212   {
65213     try {
65214       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65215     } catch (std::out_of_range& e) {
65216       {
65217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65218       };
65219     } catch (std::exception& e) {
65220       {
65221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65222       };
65223     } catch (...) {
65224       {
65225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65226       };
65227     }
65228   }
65229   jresult = (void *)result;
65230   return jresult;
65231 }
65232
65233
65234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65235   void * jresult ;
65236   Dali::Toolkit::Button *arg1 = 0 ;
65237   Dali::Toolkit::Button *result = 0 ;
65238
65239   arg1 = (Dali::Toolkit::Button *)jarg1;
65240   if (!arg1) {
65241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65242     return 0;
65243   }
65244   {
65245     try {
65246       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65247     } catch (std::out_of_range& e) {
65248       {
65249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65250       };
65251     } catch (std::exception& e) {
65252       {
65253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65254       };
65255     } catch (...) {
65256       {
65257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65258       };
65259     }
65260   }
65261   jresult = (void *)result;
65262   return jresult;
65263 }
65264
65265
65266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65267   void * jresult ;
65268   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65269   Dali::Toolkit::Button *arg2 = 0 ;
65270   Dali::Toolkit::Button *result = 0 ;
65271
65272   arg1 = (Dali::Toolkit::Button *)jarg1;
65273   arg2 = (Dali::Toolkit::Button *)jarg2;
65274   if (!arg2) {
65275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65276     return 0;
65277   }
65278   {
65279     try {
65280       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65281     } catch (std::out_of_range& e) {
65282       {
65283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65284       };
65285     } catch (std::exception& e) {
65286       {
65287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65288       };
65289     } catch (...) {
65290       {
65291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65292       };
65293     }
65294   }
65295   jresult = (void *)result;
65296   return jresult;
65297 }
65298
65299
65300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65301   void * jresult ;
65302   Dali::BaseHandle arg1 ;
65303   Dali::BaseHandle *argp1 ;
65304   Dali::Toolkit::Button result;
65305
65306   argp1 = (Dali::BaseHandle *)jarg1;
65307   if (!argp1) {
65308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65309     return 0;
65310   }
65311   arg1 = *argp1;
65312   {
65313     try {
65314       result = Dali::Toolkit::Button::DownCast(arg1);
65315     } catch (std::out_of_range& e) {
65316       {
65317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65318       };
65319     } catch (std::exception& e) {
65320       {
65321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65322       };
65323     } catch (...) {
65324       {
65325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65326       };
65327     }
65328   }
65329   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65330   return jresult;
65331 }
65332
65333
65334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65335   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65336
65337   arg1 = (Dali::Toolkit::Button *)jarg1;
65338   {
65339     try {
65340       delete arg1;
65341     } catch (std::out_of_range& e) {
65342       {
65343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65344       };
65345     } catch (std::exception& e) {
65346       {
65347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65348       };
65349     } catch (...) {
65350       {
65351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65352       };
65353     }
65354   }
65355 }
65356
65357
65358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
65359   unsigned int jresult ;
65360   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65361   bool result;
65362
65363   arg1 = (Dali::Toolkit::Button *)jarg1;
65364   {
65365     try {
65366       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
65367     } catch (std::out_of_range& e) {
65368       {
65369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65370       };
65371     } catch (std::exception& e) {
65372       {
65373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65374       };
65375     } catch (...) {
65376       {
65377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65378       };
65379     }
65380   }
65381   jresult = result;
65382   return jresult;
65383 }
65384
65385
65386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
65387   unsigned int jresult ;
65388   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65389   bool result;
65390
65391   arg1 = (Dali::Toolkit::Button *)jarg1;
65392   {
65393     try {
65394       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
65395     } catch (std::out_of_range& e) {
65396       {
65397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65398       };
65399     } catch (std::exception& e) {
65400       {
65401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65402       };
65403     } catch (...) {
65404       {
65405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65406       };
65407     }
65408   }
65409   jresult = result;
65410   return jresult;
65411 }
65412
65413
65414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
65415   float jresult ;
65416   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65417   float result;
65418
65419   arg1 = (Dali::Toolkit::Button *)jarg1;
65420   {
65421     try {
65422       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
65423     } catch (std::out_of_range& e) {
65424       {
65425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65426       };
65427     } catch (std::exception& e) {
65428       {
65429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65430       };
65431     } catch (...) {
65432       {
65433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65434       };
65435     }
65436   }
65437   jresult = result;
65438   return jresult;
65439 }
65440
65441
65442 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
65443   float jresult ;
65444   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65445   float result;
65446
65447   arg1 = (Dali::Toolkit::Button *)jarg1;
65448   {
65449     try {
65450       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
65451     } catch (std::out_of_range& e) {
65452       {
65453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65454       };
65455     } catch (std::exception& e) {
65456       {
65457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65458       };
65459     } catch (...) {
65460       {
65461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65462       };
65463     }
65464   }
65465   jresult = result;
65466   return jresult;
65467 }
65468
65469
65470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
65471   unsigned int jresult ;
65472   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65473   bool result;
65474
65475   arg1 = (Dali::Toolkit::Button *)jarg1;
65476   {
65477     try {
65478       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
65479     } catch (std::out_of_range& e) {
65480       {
65481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65482       };
65483     } catch (std::exception& e) {
65484       {
65485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65486       };
65487     } catch (...) {
65488       {
65489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65490       };
65491     }
65492   }
65493   jresult = result;
65494   return jresult;
65495 }
65496
65497
65498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
65499   unsigned int jresult ;
65500   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65501   bool result;
65502
65503   arg1 = (Dali::Toolkit::Button *)jarg1;
65504   {
65505     try {
65506       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
65507     } catch (std::out_of_range& e) {
65508       {
65509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65510       };
65511     } catch (std::exception& e) {
65512       {
65513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65514       };
65515     } catch (...) {
65516       {
65517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65518       };
65519     }
65520   }
65521   jresult = result;
65522   return jresult;
65523 }
65524
65525
65526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
65527   float jresult ;
65528   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65529   float result;
65530
65531   arg1 = (Dali::Toolkit::Button *)jarg1;
65532   {
65533     try {
65534       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
65535     } catch (std::out_of_range& e) {
65536       {
65537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65538       };
65539     } catch (std::exception& e) {
65540       {
65541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65542       };
65543     } catch (...) {
65544       {
65545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65546       };
65547     }
65548   }
65549   jresult = result;
65550   return jresult;
65551 }
65552
65553
65554 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
65555   char * jresult ;
65556   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65557   std::string result;
65558
65559   arg1 = (Dali::Toolkit::Button *)jarg1;
65560   {
65561     try {
65562       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
65563     } catch (std::out_of_range& e) {
65564       {
65565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65566       };
65567     } catch (std::exception& e) {
65568       {
65569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65570       };
65571     } catch (...) {
65572       {
65573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65574       };
65575     }
65576   }
65577   jresult = SWIG_csharp_string_callback((&result)->c_str());
65578   return jresult;
65579 }
65580
65581
65582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
65583   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65584   Dali::Actor arg2 ;
65585   Dali::Actor *argp2 ;
65586
65587   arg1 = (Dali::Toolkit::Button *)jarg1;
65588   argp2 = (Dali::Actor *)jarg2;
65589   if (!argp2) {
65590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65591     return ;
65592   }
65593   arg2 = *argp2;
65594   {
65595     try {
65596       (arg1)->SetLabel(arg2);
65597     } catch (std::out_of_range& e) {
65598       {
65599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65600       };
65601     } catch (std::exception& e) {
65602       {
65603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65604       };
65605     } catch (...) {
65606       {
65607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65608       };
65609     }
65610   }
65611 }
65612
65613
65614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
65615   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65616   Dali::Image arg2 ;
65617   Dali::Image *argp2 ;
65618
65619   arg1 = (Dali::Toolkit::Button *)jarg1;
65620   argp2 = (Dali::Image *)jarg2;
65621   if (!argp2) {
65622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65623     return ;
65624   }
65625   arg2 = *argp2;
65626   {
65627     try {
65628       (arg1)->SetButtonImage(arg2);
65629     } catch (std::out_of_range& e) {
65630       {
65631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65632       };
65633     } catch (std::exception& e) {
65634       {
65635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65636       };
65637     } catch (...) {
65638       {
65639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65640       };
65641     }
65642   }
65643 }
65644
65645
65646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
65647   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65648   Dali::Image arg2 ;
65649   Dali::Image *argp2 ;
65650
65651   arg1 = (Dali::Toolkit::Button *)jarg1;
65652   argp2 = (Dali::Image *)jarg2;
65653   if (!argp2) {
65654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65655     return ;
65656   }
65657   arg2 = *argp2;
65658   {
65659     try {
65660       (arg1)->SetSelectedImage(arg2);
65661     } catch (std::out_of_range& e) {
65662       {
65663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65664       };
65665     } catch (std::exception& e) {
65666       {
65667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65668       };
65669     } catch (...) {
65670       {
65671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65672       };
65673     }
65674   }
65675 }
65676
65677
65678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
65679   void * jresult ;
65680   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65681   Dali::Actor result;
65682
65683   arg1 = (Dali::Toolkit::Button *)jarg1;
65684   {
65685     try {
65686       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
65687     } catch (std::out_of_range& e) {
65688       {
65689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65690       };
65691     } catch (std::exception& e) {
65692       {
65693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65694       };
65695     } catch (...) {
65696       {
65697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65698       };
65699     }
65700   }
65701   jresult = new Dali::Actor((const Dali::Actor &)result);
65702   return jresult;
65703 }
65704
65705
65706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
65707   void * jresult ;
65708   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65709   Dali::Actor result;
65710
65711   arg1 = (Dali::Toolkit::Button *)jarg1;
65712   {
65713     try {
65714       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
65715     } catch (std::out_of_range& e) {
65716       {
65717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65718       };
65719     } catch (std::exception& e) {
65720       {
65721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65722       };
65723     } catch (...) {
65724       {
65725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65726       };
65727     }
65728   }
65729   jresult = new Dali::Actor((const Dali::Actor &)result);
65730   return jresult;
65731 }
65732
65733
65734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65735   void * jresult ;
65736   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65737   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65738
65739   arg1 = (Dali::Toolkit::Button *)jarg1;
65740   {
65741     try {
65742       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65743     } catch (std::out_of_range& e) {
65744       {
65745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65746       };
65747     } catch (std::exception& e) {
65748       {
65749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65750       };
65751     } catch (...) {
65752       {
65753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65754       };
65755     }
65756   }
65757   jresult = (void *)result;
65758   return jresult;
65759 }
65760
65761
65762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65763   void * jresult ;
65764   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65765   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65766
65767   arg1 = (Dali::Toolkit::Button *)jarg1;
65768   {
65769     try {
65770       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65771     } catch (std::out_of_range& e) {
65772       {
65773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65774       };
65775     } catch (std::exception& e) {
65776       {
65777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65778       };
65779     } catch (...) {
65780       {
65781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65782       };
65783     }
65784   }
65785   jresult = (void *)result;
65786   return jresult;
65787 }
65788
65789
65790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65791   void * jresult ;
65792   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65793   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65794
65795   arg1 = (Dali::Toolkit::Button *)jarg1;
65796   {
65797     try {
65798       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65799     } catch (std::out_of_range& e) {
65800       {
65801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65802       };
65803     } catch (std::exception& e) {
65804       {
65805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65806       };
65807     } catch (...) {
65808       {
65809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65810       };
65811     }
65812   }
65813   jresult = (void *)result;
65814   return jresult;
65815 }
65816
65817
65818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65819   void * jresult ;
65820   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65821   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65822
65823   arg1 = (Dali::Toolkit::Button *)jarg1;
65824   {
65825     try {
65826       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65827     } catch (std::out_of_range& e) {
65828       {
65829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65830       };
65831     } catch (std::exception& e) {
65832       {
65833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65834       };
65835     } catch (...) {
65836       {
65837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65838       };
65839     }
65840   }
65841   jresult = (void *)result;
65842   return jresult;
65843 }
65844
65845
65846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65847   void * jresult ;
65848   Dali::Toolkit::CheckBoxButton *result = 0 ;
65849
65850   {
65851     try {
65852       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65853     } catch (std::out_of_range& e) {
65854       {
65855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65856       };
65857     } catch (std::exception& e) {
65858       {
65859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65860       };
65861     } catch (...) {
65862       {
65863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65864       };
65865     }
65866   }
65867   jresult = (void *)result;
65868   return jresult;
65869 }
65870
65871
65872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65873   void * jresult ;
65874   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65875   Dali::Toolkit::CheckBoxButton *result = 0 ;
65876
65877   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65878   if (!arg1) {
65879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65880     return 0;
65881   }
65882   {
65883     try {
65884       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65885     } catch (std::out_of_range& e) {
65886       {
65887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65888       };
65889     } catch (std::exception& e) {
65890       {
65891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65892       };
65893     } catch (...) {
65894       {
65895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65896       };
65897     }
65898   }
65899   jresult = (void *)result;
65900   return jresult;
65901 }
65902
65903
65904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65905   void * jresult ;
65906   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65907   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65908   Dali::Toolkit::CheckBoxButton *result = 0 ;
65909
65910   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65911   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65912   if (!arg2) {
65913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65914     return 0;
65915   }
65916   {
65917     try {
65918       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65919     } catch (std::out_of_range& e) {
65920       {
65921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65922       };
65923     } catch (std::exception& e) {
65924       {
65925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65926       };
65927     } catch (...) {
65928       {
65929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65930       };
65931     }
65932   }
65933   jresult = (void *)result;
65934   return jresult;
65935 }
65936
65937
65938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65939   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65940
65941   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65942   {
65943     try {
65944       delete arg1;
65945     } catch (std::out_of_range& e) {
65946       {
65947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65948       };
65949     } catch (std::exception& e) {
65950       {
65951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65952       };
65953     } catch (...) {
65954       {
65955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65956       };
65957     }
65958   }
65959 }
65960
65961
65962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65963   void * jresult ;
65964   Dali::Toolkit::CheckBoxButton result;
65965
65966   {
65967     try {
65968       result = Dali::Toolkit::CheckBoxButton::New();
65969     } catch (std::out_of_range& e) {
65970       {
65971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65972       };
65973     } catch (std::exception& e) {
65974       {
65975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65976       };
65977     } catch (...) {
65978       {
65979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65980       };
65981     }
65982   }
65983   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65984   return jresult;
65985 }
65986
65987
65988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65989   void * jresult ;
65990   Dali::BaseHandle arg1 ;
65991   Dali::BaseHandle *argp1 ;
65992   Dali::Toolkit::CheckBoxButton result;
65993
65994   argp1 = (Dali::BaseHandle *)jarg1;
65995   if (!argp1) {
65996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65997     return 0;
65998   }
65999   arg1 = *argp1;
66000   {
66001     try {
66002       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
66003     } catch (std::out_of_range& e) {
66004       {
66005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66006       };
66007     } catch (std::exception& e) {
66008       {
66009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66010       };
66011     } catch (...) {
66012       {
66013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66014       };
66015     }
66016   }
66017   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
66018   return jresult;
66019 }
66020
66021
66022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
66023   int jresult ;
66024   int result;
66025
66026   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
66027   jresult = (int)result;
66028   return jresult;
66029 }
66030
66031
66032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
66033   int jresult ;
66034   int result;
66035
66036   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
66037   jresult = (int)result;
66038   return jresult;
66039 }
66040
66041
66042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
66043   int jresult ;
66044   int result;
66045
66046   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
66047   jresult = (int)result;
66048   return jresult;
66049 }
66050
66051
66052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
66053   int jresult ;
66054   int result;
66055
66056   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
66057   jresult = (int)result;
66058   return jresult;
66059 }
66060
66061
66062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
66063   int jresult ;
66064   int result;
66065
66066   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
66067   jresult = (int)result;
66068   return jresult;
66069 }
66070
66071
66072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
66073   void * jresult ;
66074   Dali::Toolkit::PushButton::Property *result = 0 ;
66075
66076   {
66077     try {
66078       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
66079     } catch (std::out_of_range& e) {
66080       {
66081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66082       };
66083     } catch (std::exception& e) {
66084       {
66085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66086       };
66087     } catch (...) {
66088       {
66089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66090       };
66091     }
66092   }
66093   jresult = (void *)result;
66094   return jresult;
66095 }
66096
66097
66098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
66099   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
66100
66101   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
66102   {
66103     try {
66104       delete arg1;
66105     } catch (std::out_of_range& e) {
66106       {
66107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66108       };
66109     } catch (std::exception& e) {
66110       {
66111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66112       };
66113     } catch (...) {
66114       {
66115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66116       };
66117     }
66118   }
66119 }
66120
66121
66122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
66123   void * jresult ;
66124   Dali::Toolkit::PushButton *result = 0 ;
66125
66126   {
66127     try {
66128       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
66129     } catch (std::out_of_range& e) {
66130       {
66131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66132       };
66133     } catch (std::exception& e) {
66134       {
66135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66136       };
66137     } catch (...) {
66138       {
66139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66140       };
66141     }
66142   }
66143   jresult = (void *)result;
66144   return jresult;
66145 }
66146
66147
66148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
66149   void * jresult ;
66150   Dali::Toolkit::PushButton *arg1 = 0 ;
66151   Dali::Toolkit::PushButton *result = 0 ;
66152
66153   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66154   if (!arg1) {
66155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66156     return 0;
66157   }
66158   {
66159     try {
66160       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
66161     } catch (std::out_of_range& e) {
66162       {
66163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66164       };
66165     } catch (std::exception& e) {
66166       {
66167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66168       };
66169     } catch (...) {
66170       {
66171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66172       };
66173     }
66174   }
66175   jresult = (void *)result;
66176   return jresult;
66177 }
66178
66179
66180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
66181   void * jresult ;
66182   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66183   Dali::Toolkit::PushButton *arg2 = 0 ;
66184   Dali::Toolkit::PushButton *result = 0 ;
66185
66186   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66187   arg2 = (Dali::Toolkit::PushButton *)jarg2;
66188   if (!arg2) {
66189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66190     return 0;
66191   }
66192   {
66193     try {
66194       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
66195     } catch (std::out_of_range& e) {
66196       {
66197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66198       };
66199     } catch (std::exception& e) {
66200       {
66201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66202       };
66203     } catch (...) {
66204       {
66205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66206       };
66207     }
66208   }
66209   jresult = (void *)result;
66210   return jresult;
66211 }
66212
66213
66214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
66215   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66216
66217   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66218   {
66219     try {
66220       delete arg1;
66221     } catch (std::out_of_range& e) {
66222       {
66223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66224       };
66225     } catch (std::exception& e) {
66226       {
66227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66228       };
66229     } catch (...) {
66230       {
66231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66232       };
66233     }
66234   }
66235 }
66236
66237
66238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
66239   void * jresult ;
66240   Dali::Toolkit::PushButton result;
66241
66242   {
66243     try {
66244       result = Dali::Toolkit::PushButton::New();
66245     } catch (std::out_of_range& e) {
66246       {
66247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66248       };
66249     } catch (std::exception& e) {
66250       {
66251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66252       };
66253     } catch (...) {
66254       {
66255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66256       };
66257     }
66258   }
66259   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66260   return jresult;
66261 }
66262
66263
66264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
66265   void * jresult ;
66266   Dali::BaseHandle arg1 ;
66267   Dali::BaseHandle *argp1 ;
66268   Dali::Toolkit::PushButton result;
66269
66270   argp1 = (Dali::BaseHandle *)jarg1;
66271   if (!argp1) {
66272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66273     return 0;
66274   }
66275   arg1 = *argp1;
66276   {
66277     try {
66278       result = Dali::Toolkit::PushButton::DownCast(arg1);
66279     } catch (std::out_of_range& e) {
66280       {
66281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66282       };
66283     } catch (std::exception& e) {
66284       {
66285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66286       };
66287     } catch (...) {
66288       {
66289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66290       };
66291     }
66292   }
66293   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66294   return jresult;
66295 }
66296
66297
66298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
66299   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66300   Dali::Image arg2 ;
66301   Dali::Image *argp2 ;
66302
66303   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66304   argp2 = (Dali::Image *)jarg2;
66305   if (!argp2) {
66306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66307     return ;
66308   }
66309   arg2 = *argp2;
66310   {
66311     try {
66312       (arg1)->SetButtonImage(arg2);
66313     } catch (std::out_of_range& e) {
66314       {
66315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66316       };
66317     } catch (std::exception& e) {
66318       {
66319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66320       };
66321     } catch (...) {
66322       {
66323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66324       };
66325     }
66326   }
66327 }
66328
66329
66330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
66331   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66332   Dali::Actor arg2 ;
66333   Dali::Actor *argp2 ;
66334
66335   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66336   argp2 = (Dali::Actor *)jarg2;
66337   if (!argp2) {
66338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66339     return ;
66340   }
66341   arg2 = *argp2;
66342   {
66343     try {
66344       (arg1)->SetButtonImage(arg2);
66345     } catch (std::out_of_range& e) {
66346       {
66347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66348       };
66349     } catch (std::exception& e) {
66350       {
66351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66352       };
66353     } catch (...) {
66354       {
66355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66356       };
66357     }
66358   }
66359 }
66360
66361
66362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
66363   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66364   Dali::Actor arg2 ;
66365   Dali::Actor *argp2 ;
66366
66367   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66368   argp2 = (Dali::Actor *)jarg2;
66369   if (!argp2) {
66370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66371     return ;
66372   }
66373   arg2 = *argp2;
66374   {
66375     try {
66376       (arg1)->SetBackgroundImage(arg2);
66377     } catch (std::out_of_range& e) {
66378       {
66379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66380       };
66381     } catch (std::exception& e) {
66382       {
66383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66384       };
66385     } catch (...) {
66386       {
66387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66388       };
66389     }
66390   }
66391 }
66392
66393
66394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
66395   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66396   Dali::Image arg2 ;
66397   Dali::Image *argp2 ;
66398
66399   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66400   argp2 = (Dali::Image *)jarg2;
66401   if (!argp2) {
66402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66403     return ;
66404   }
66405   arg2 = *argp2;
66406   {
66407     try {
66408       (arg1)->SetSelectedImage(arg2);
66409     } catch (std::out_of_range& e) {
66410       {
66411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66412       };
66413     } catch (std::exception& e) {
66414       {
66415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66416       };
66417     } catch (...) {
66418       {
66419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66420       };
66421     }
66422   }
66423 }
66424
66425
66426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
66427   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66428   Dali::Actor arg2 ;
66429   Dali::Actor *argp2 ;
66430
66431   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66432   argp2 = (Dali::Actor *)jarg2;
66433   if (!argp2) {
66434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66435     return ;
66436   }
66437   arg2 = *argp2;
66438   {
66439     try {
66440       (arg1)->SetSelectedImage(arg2);
66441     } catch (std::out_of_range& e) {
66442       {
66443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66444       };
66445     } catch (std::exception& e) {
66446       {
66447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66448       };
66449     } catch (...) {
66450       {
66451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66452       };
66453     }
66454   }
66455 }
66456
66457
66458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
66459   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66460   Dali::Actor arg2 ;
66461   Dali::Actor *argp2 ;
66462
66463   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66464   argp2 = (Dali::Actor *)jarg2;
66465   if (!argp2) {
66466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66467     return ;
66468   }
66469   arg2 = *argp2;
66470   {
66471     try {
66472       (arg1)->SetSelectedBackgroundImage(arg2);
66473     } catch (std::out_of_range& e) {
66474       {
66475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66476       };
66477     } catch (std::exception& e) {
66478       {
66479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66480       };
66481     } catch (...) {
66482       {
66483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66484       };
66485     }
66486   }
66487 }
66488
66489
66490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
66491   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66492   Dali::Actor arg2 ;
66493   Dali::Actor *argp2 ;
66494
66495   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66496   argp2 = (Dali::Actor *)jarg2;
66497   if (!argp2) {
66498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66499     return ;
66500   }
66501   arg2 = *argp2;
66502   {
66503     try {
66504       (arg1)->SetDisabledBackgroundImage(arg2);
66505     } catch (std::out_of_range& e) {
66506       {
66507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66508       };
66509     } catch (std::exception& e) {
66510       {
66511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66512       };
66513     } catch (...) {
66514       {
66515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66516       };
66517     }
66518   }
66519 }
66520
66521
66522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
66523   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66524   Dali::Actor arg2 ;
66525   Dali::Actor *argp2 ;
66526
66527   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66528   argp2 = (Dali::Actor *)jarg2;
66529   if (!argp2) {
66530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66531     return ;
66532   }
66533   arg2 = *argp2;
66534   {
66535     try {
66536       (arg1)->SetDisabledImage(arg2);
66537     } catch (std::out_of_range& e) {
66538       {
66539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66540       };
66541     } catch (std::exception& e) {
66542       {
66543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66544       };
66545     } catch (...) {
66546       {
66547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66548       };
66549     }
66550   }
66551 }
66552
66553
66554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
66555   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66556   Dali::Actor arg2 ;
66557   Dali::Actor *argp2 ;
66558
66559   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66560   argp2 = (Dali::Actor *)jarg2;
66561   if (!argp2) {
66562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66563     return ;
66564   }
66565   arg2 = *argp2;
66566   {
66567     try {
66568       (arg1)->SetDisabledSelectedImage(arg2);
66569     } catch (std::out_of_range& e) {
66570       {
66571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66572       };
66573     } catch (std::exception& e) {
66574       {
66575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66576       };
66577     } catch (...) {
66578       {
66579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66580       };
66581     }
66582   }
66583 }
66584
66585
66586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
66587   void * jresult ;
66588   Dali::Toolkit::RadioButton *result = 0 ;
66589
66590   {
66591     try {
66592       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
66593     } catch (std::out_of_range& e) {
66594       {
66595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66596       };
66597     } catch (std::exception& e) {
66598       {
66599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66600       };
66601     } catch (...) {
66602       {
66603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66604       };
66605     }
66606   }
66607   jresult = (void *)result;
66608   return jresult;
66609 }
66610
66611
66612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
66613   void * jresult ;
66614   Dali::Toolkit::RadioButton *arg1 = 0 ;
66615   Dali::Toolkit::RadioButton *result = 0 ;
66616
66617   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66618   if (!arg1) {
66619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66620     return 0;
66621   }
66622   {
66623     try {
66624       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66625     } catch (std::out_of_range& e) {
66626       {
66627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66628       };
66629     } catch (std::exception& e) {
66630       {
66631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66632       };
66633     } catch (...) {
66634       {
66635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66636       };
66637     }
66638   }
66639   jresult = (void *)result;
66640   return jresult;
66641 }
66642
66643
66644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
66645   void * jresult ;
66646   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66647   Dali::Toolkit::RadioButton *arg2 = 0 ;
66648   Dali::Toolkit::RadioButton *result = 0 ;
66649
66650   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66651   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66652   if (!arg2) {
66653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66654     return 0;
66655   }
66656   {
66657     try {
66658       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66659     } catch (std::out_of_range& e) {
66660       {
66661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66662       };
66663     } catch (std::exception& e) {
66664       {
66665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66666       };
66667     } catch (...) {
66668       {
66669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66670       };
66671     }
66672   }
66673   jresult = (void *)result;
66674   return jresult;
66675 }
66676
66677
66678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
66679   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66680
66681   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66682   {
66683     try {
66684       delete arg1;
66685     } catch (std::out_of_range& e) {
66686       {
66687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66688       };
66689     } catch (std::exception& e) {
66690       {
66691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66692       };
66693     } catch (...) {
66694       {
66695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66696       };
66697     }
66698   }
66699 }
66700
66701
66702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
66703   void * jresult ;
66704   Dali::Toolkit::RadioButton result;
66705
66706   {
66707     try {
66708       result = Dali::Toolkit::RadioButton::New();
66709     } catch (std::out_of_range& e) {
66710       {
66711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66712       };
66713     } catch (std::exception& e) {
66714       {
66715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66716       };
66717     } catch (...) {
66718       {
66719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66720       };
66721     }
66722   }
66723   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66724   return jresult;
66725 }
66726
66727
66728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66729   void * jresult ;
66730   std::string *arg1 = 0 ;
66731   Dali::Toolkit::RadioButton result;
66732
66733   if (!jarg1) {
66734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66735     return 0;
66736   }
66737   std::string arg1_str(jarg1);
66738   arg1 = &arg1_str;
66739   {
66740     try {
66741       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66742     } catch (std::out_of_range& e) {
66743       {
66744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66745       };
66746     } catch (std::exception& e) {
66747       {
66748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66749       };
66750     } catch (...) {
66751       {
66752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66753       };
66754     }
66755   }
66756   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66757
66758   //argout typemap for const std::string&
66759
66760   return jresult;
66761 }
66762
66763
66764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66765   void * jresult ;
66766   Dali::BaseHandle arg1 ;
66767   Dali::BaseHandle *argp1 ;
66768   Dali::Toolkit::RadioButton result;
66769
66770   argp1 = (Dali::BaseHandle *)jarg1;
66771   if (!argp1) {
66772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66773     return 0;
66774   }
66775   arg1 = *argp1;
66776   {
66777     try {
66778       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66779     } catch (std::out_of_range& e) {
66780       {
66781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66782       };
66783     } catch (std::exception& e) {
66784       {
66785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66786       };
66787     } catch (...) {
66788       {
66789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66790       };
66791     }
66792   }
66793   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66794   return jresult;
66795 }
66796
66797
66798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66799   int jresult ;
66800   int result;
66801
66802   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66803   jresult = (int)result;
66804   return jresult;
66805 }
66806
66807
66808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66809   int jresult ;
66810   int result;
66811
66812   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66813   jresult = (int)result;
66814   return jresult;
66815 }
66816
66817
66818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66819   int jresult ;
66820   int result;
66821
66822   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66823   jresult = (int)result;
66824   return jresult;
66825 }
66826
66827
66828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66829   int jresult ;
66830   int result;
66831
66832   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66833   jresult = (int)result;
66834   return jresult;
66835 }
66836
66837
66838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66839   int jresult ;
66840   int result;
66841
66842   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66843   jresult = (int)result;
66844   return jresult;
66845 }
66846
66847
66848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66849   int jresult ;
66850   int result;
66851
66852   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66853   jresult = (int)result;
66854   return jresult;
66855 }
66856
66857
66858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66859   void * jresult ;
66860   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66861
66862   {
66863     try {
66864       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66865     } catch (std::out_of_range& e) {
66866       {
66867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66868       };
66869     } catch (std::exception& e) {
66870       {
66871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66872       };
66873     } catch (...) {
66874       {
66875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66876       };
66877     }
66878   }
66879   jresult = (void *)result;
66880   return jresult;
66881 }
66882
66883
66884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66885   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66886
66887   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66888   {
66889     try {
66890       delete arg1;
66891     } catch (std::out_of_range& e) {
66892       {
66893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66894       };
66895     } catch (std::exception& e) {
66896       {
66897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66898       };
66899     } catch (...) {
66900       {
66901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66902       };
66903     }
66904   }
66905 }
66906
66907
66908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66909   int jresult ;
66910   int result;
66911
66912   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66913   jresult = (int)result;
66914   return jresult;
66915 }
66916
66917
66918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66919   int jresult ;
66920   int result;
66921
66922   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66923   jresult = (int)result;
66924   return jresult;
66925 }
66926
66927
66928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66929   int jresult ;
66930   int result;
66931
66932   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66933   jresult = (int)result;
66934   return jresult;
66935 }
66936
66937
66938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66939   void * jresult ;
66940   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66941
66942   {
66943     try {
66944       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66945     } catch (std::out_of_range& e) {
66946       {
66947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66948       };
66949     } catch (std::exception& e) {
66950       {
66951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66952       };
66953     } catch (...) {
66954       {
66955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66956       };
66957     }
66958   }
66959   jresult = (void *)result;
66960   return jresult;
66961 }
66962
66963
66964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66965   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66966
66967   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66968   {
66969     try {
66970       delete arg1;
66971     } catch (std::out_of_range& e) {
66972       {
66973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66974       };
66975     } catch (std::exception& e) {
66976       {
66977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66978       };
66979     } catch (...) {
66980       {
66981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66982       };
66983     }
66984   }
66985 }
66986
66987
66988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66989   void * jresult ;
66990   Dali::Toolkit::FlexContainer *result = 0 ;
66991
66992   {
66993     try {
66994       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66995     } catch (std::out_of_range& e) {
66996       {
66997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66998       };
66999     } catch (std::exception& e) {
67000       {
67001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67002       };
67003     } catch (...) {
67004       {
67005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67006       };
67007     }
67008   }
67009   jresult = (void *)result;
67010   return jresult;
67011 }
67012
67013
67014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
67015   void * jresult ;
67016   Dali::Toolkit::FlexContainer *arg1 = 0 ;
67017   Dali::Toolkit::FlexContainer *result = 0 ;
67018
67019   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67020   if (!arg1) {
67021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
67022     return 0;
67023   }
67024   {
67025     try {
67026       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
67027     } catch (std::out_of_range& e) {
67028       {
67029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67030       };
67031     } catch (std::exception& e) {
67032       {
67033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67034       };
67035     } catch (...) {
67036       {
67037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67038       };
67039     }
67040   }
67041   jresult = (void *)result;
67042   return jresult;
67043 }
67044
67045
67046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
67047   void * jresult ;
67048   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
67049   Dali::Toolkit::FlexContainer *arg2 = 0 ;
67050   Dali::Toolkit::FlexContainer *result = 0 ;
67051
67052   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67053   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
67054   if (!arg2) {
67055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
67056     return 0;
67057   }
67058   {
67059     try {
67060       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
67061     } catch (std::out_of_range& e) {
67062       {
67063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67064       };
67065     } catch (std::exception& e) {
67066       {
67067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67068       };
67069     } catch (...) {
67070       {
67071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67072       };
67073     }
67074   }
67075   jresult = (void *)result;
67076   return jresult;
67077 }
67078
67079
67080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
67081   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
67082
67083   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
67084   {
67085     try {
67086       delete arg1;
67087     } catch (std::out_of_range& e) {
67088       {
67089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67090       };
67091     } catch (std::exception& e) {
67092       {
67093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67094       };
67095     } catch (...) {
67096       {
67097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67098       };
67099     }
67100   }
67101 }
67102
67103
67104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
67105   void * jresult ;
67106   Dali::Toolkit::FlexContainer result;
67107
67108   {
67109     try {
67110       result = Dali::Toolkit::FlexContainer::New();
67111     } catch (std::out_of_range& e) {
67112       {
67113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67114       };
67115     } catch (std::exception& e) {
67116       {
67117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67118       };
67119     } catch (...) {
67120       {
67121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67122       };
67123     }
67124   }
67125   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67126   return jresult;
67127 }
67128
67129
67130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
67131   void * jresult ;
67132   Dali::BaseHandle arg1 ;
67133   Dali::BaseHandle *argp1 ;
67134   Dali::Toolkit::FlexContainer result;
67135
67136   argp1 = (Dali::BaseHandle *)jarg1;
67137   if (!argp1) {
67138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67139     return 0;
67140   }
67141   arg1 = *argp1;
67142   {
67143     try {
67144       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
67145     } catch (std::out_of_range& e) {
67146       {
67147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67148       };
67149     } catch (std::exception& e) {
67150       {
67151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67152       };
67153     } catch (...) {
67154       {
67155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67156       };
67157     }
67158   }
67159   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
67160   return jresult;
67161 }
67162
67163
67164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
67165   int jresult ;
67166   int result;
67167
67168   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
67169   jresult = (int)result;
67170   return jresult;
67171 }
67172
67173
67174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
67175   int jresult ;
67176   int result;
67177
67178   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
67179   jresult = (int)result;
67180   return jresult;
67181 }
67182
67183
67184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
67185   int jresult ;
67186   int result;
67187
67188   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
67189   jresult = (int)result;
67190   return jresult;
67191 }
67192
67193
67194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
67195   int jresult ;
67196   int result;
67197
67198   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
67199   jresult = (int)result;
67200   return jresult;
67201 }
67202
67203
67204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
67205   void * jresult ;
67206   Dali::Toolkit::ImageView::Property *result = 0 ;
67207
67208   {
67209     try {
67210       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
67211     } catch (std::out_of_range& e) {
67212       {
67213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67214       };
67215     } catch (std::exception& e) {
67216       {
67217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67218       };
67219     } catch (...) {
67220       {
67221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67222       };
67223     }
67224   }
67225   jresult = (void *)result;
67226   return jresult;
67227 }
67228
67229
67230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
67231   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
67232
67233   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
67234   {
67235     try {
67236       delete arg1;
67237     } catch (std::out_of_range& e) {
67238       {
67239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67240       };
67241     } catch (std::exception& e) {
67242       {
67243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67244       };
67245     } catch (...) {
67246       {
67247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67248       };
67249     }
67250   }
67251 }
67252
67253
67254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
67255   void * jresult ;
67256   Dali::Toolkit::ImageView *result = 0 ;
67257
67258   {
67259     try {
67260       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
67261     } catch (std::out_of_range& e) {
67262       {
67263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67264       };
67265     } catch (std::exception& e) {
67266       {
67267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67268       };
67269     } catch (...) {
67270       {
67271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67272       };
67273     }
67274   }
67275   jresult = (void *)result;
67276   return jresult;
67277 }
67278
67279
67280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
67281   void * jresult ;
67282   Dali::Toolkit::ImageView result;
67283
67284   {
67285     try {
67286       result = Dali::Toolkit::ImageView::New();
67287     } catch (std::out_of_range& e) {
67288       {
67289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67290       };
67291     } catch (std::exception& e) {
67292       {
67293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67294       };
67295     } catch (...) {
67296       {
67297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67298       };
67299     }
67300   }
67301   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67302   return jresult;
67303 }
67304
67305
67306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
67307   void * jresult ;
67308   Dali::Image arg1 ;
67309   Dali::Image *argp1 ;
67310   Dali::Toolkit::ImageView result;
67311
67312   argp1 = (Dali::Image *)jarg1;
67313   if (!argp1) {
67314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67315     return 0;
67316   }
67317   arg1 = *argp1;
67318   {
67319     try {
67320       result = Dali::Toolkit::ImageView::New(arg1);
67321     } catch (std::out_of_range& e) {
67322       {
67323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67324       };
67325     } catch (std::exception& e) {
67326       {
67327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67328       };
67329     } catch (...) {
67330       {
67331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67332       };
67333     }
67334   }
67335   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67336   return jresult;
67337 }
67338
67339
67340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
67341   void * jresult ;
67342   std::string *arg1 = 0 ;
67343   Dali::Toolkit::ImageView result;
67344
67345   if (!jarg1) {
67346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67347     return 0;
67348   }
67349   std::string arg1_str(jarg1);
67350   arg1 = &arg1_str;
67351   {
67352     try {
67353       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
67354     } catch (std::out_of_range& e) {
67355       {
67356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67357       };
67358     } catch (std::exception& e) {
67359       {
67360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67361       };
67362     } catch (...) {
67363       {
67364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67365       };
67366     }
67367   }
67368   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67369
67370   //argout typemap for const std::string&
67371
67372   return jresult;
67373 }
67374
67375
67376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
67377   void * jresult ;
67378   std::string *arg1 = 0 ;
67379   Dali::ImageDimensions arg2 ;
67380   Dali::ImageDimensions *argp2 ;
67381   Dali::Toolkit::ImageView result;
67382
67383   if (!jarg1) {
67384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67385     return 0;
67386   }
67387   std::string arg1_str(jarg1);
67388   arg1 = &arg1_str;
67389   argp2 = (Dali::ImageDimensions *)jarg2;
67390   if (!argp2) {
67391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67392     return 0;
67393   }
67394   arg2 = *argp2;
67395   {
67396     try {
67397       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
67398     } catch (std::out_of_range& e) {
67399       {
67400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67401       };
67402     } catch (std::exception& e) {
67403       {
67404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67405       };
67406     } catch (...) {
67407       {
67408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67409       };
67410     }
67411   }
67412   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67413
67414   //argout typemap for const std::string&
67415
67416   return jresult;
67417 }
67418
67419
67420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
67421   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67422
67423   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67424   {
67425     try {
67426       delete arg1;
67427     } catch (std::out_of_range& e) {
67428       {
67429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67430       };
67431     } catch (std::exception& e) {
67432       {
67433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67434       };
67435     } catch (...) {
67436       {
67437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67438       };
67439     }
67440   }
67441 }
67442
67443
67444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
67445   void * jresult ;
67446   Dali::Toolkit::ImageView *arg1 = 0 ;
67447   Dali::Toolkit::ImageView *result = 0 ;
67448
67449   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67450   if (!arg1) {
67451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67452     return 0;
67453   }
67454   {
67455     try {
67456       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
67457     } catch (std::out_of_range& e) {
67458       {
67459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67460       };
67461     } catch (std::exception& e) {
67462       {
67463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67464       };
67465     } catch (...) {
67466       {
67467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67468       };
67469     }
67470   }
67471   jresult = (void *)result;
67472   return jresult;
67473 }
67474
67475
67476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
67477   void * jresult ;
67478   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67479   Dali::Toolkit::ImageView *arg2 = 0 ;
67480   Dali::Toolkit::ImageView *result = 0 ;
67481
67482   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67483   arg2 = (Dali::Toolkit::ImageView *)jarg2;
67484   if (!arg2) {
67485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67486     return 0;
67487   }
67488   {
67489     try {
67490       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
67491     } catch (std::out_of_range& e) {
67492       {
67493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67494       };
67495     } catch (std::exception& e) {
67496       {
67497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67498       };
67499     } catch (...) {
67500       {
67501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67502       };
67503     }
67504   }
67505   jresult = (void *)result;
67506   return jresult;
67507 }
67508
67509
67510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
67511   void * jresult ;
67512   Dali::BaseHandle arg1 ;
67513   Dali::BaseHandle *argp1 ;
67514   Dali::Toolkit::ImageView result;
67515
67516   argp1 = (Dali::BaseHandle *)jarg1;
67517   if (!argp1) {
67518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67519     return 0;
67520   }
67521   arg1 = *argp1;
67522   {
67523     try {
67524       result = Dali::Toolkit::ImageView::DownCast(arg1);
67525     } catch (std::out_of_range& e) {
67526       {
67527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67528       };
67529     } catch (std::exception& e) {
67530       {
67531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67532       };
67533     } catch (...) {
67534       {
67535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67536       };
67537     }
67538   }
67539   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67540   return jresult;
67541 }
67542
67543
67544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
67545   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67546   Dali::Image arg2 ;
67547   Dali::Image *argp2 ;
67548
67549   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67550   argp2 = (Dali::Image *)jarg2;
67551   if (!argp2) {
67552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67553     return ;
67554   }
67555   arg2 = *argp2;
67556   {
67557     try {
67558       (arg1)->SetImage(arg2);
67559     } catch (std::out_of_range& e) {
67560       {
67561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67562       };
67563     } catch (std::exception& e) {
67564       {
67565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67566       };
67567     } catch (...) {
67568       {
67569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67570       };
67571     }
67572   }
67573 }
67574
67575
67576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67577   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67578   std::string *arg2 = 0 ;
67579
67580   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67581   if (!jarg2) {
67582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67583     return ;
67584   }
67585   std::string arg2_str(jarg2);
67586   arg2 = &arg2_str;
67587   {
67588     try {
67589       (arg1)->SetImage((std::string const &)*arg2);
67590     } catch (std::out_of_range& e) {
67591       {
67592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67593       };
67594     } catch (std::exception& e) {
67595       {
67596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67597       };
67598     } catch (...) {
67599       {
67600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67601       };
67602     }
67603   }
67604
67605   //argout typemap for const std::string&
67606
67607 }
67608
67609
67610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67611   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67612   std::string *arg2 = 0 ;
67613   Dali::ImageDimensions arg3 ;
67614   Dali::ImageDimensions *argp3 ;
67615
67616   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67617   if (!jarg2) {
67618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67619     return ;
67620   }
67621   std::string arg2_str(jarg2);
67622   arg2 = &arg2_str;
67623   argp3 = (Dali::ImageDimensions *)jarg3;
67624   if (!argp3) {
67625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67626     return ;
67627   }
67628   arg3 = *argp3;
67629   {
67630     try {
67631       (arg1)->SetImage((std::string const &)*arg2,arg3);
67632     } catch (std::out_of_range& e) {
67633       {
67634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67635       };
67636     } catch (std::exception& e) {
67637       {
67638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67639       };
67640     } catch (...) {
67641       {
67642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67643       };
67644     }
67645   }
67646
67647   //argout typemap for const std::string&
67648
67649 }
67650
67651
67652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
67653   void * jresult ;
67654   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67655   Dali::Image result;
67656
67657   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67658   {
67659     try {
67660       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
67661     } catch (std::out_of_range& e) {
67662       {
67663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67664       };
67665     } catch (std::exception& e) {
67666       {
67667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67668       };
67669     } catch (...) {
67670       {
67671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67672       };
67673     }
67674   }
67675   jresult = new Dali::Image((const Dali::Image &)result);
67676   return jresult;
67677 }
67678
67679
67680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
67681   int jresult ;
67682   int result;
67683
67684   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67685   jresult = (int)result;
67686   return jresult;
67687 }
67688
67689
67690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
67691   int jresult ;
67692   int result;
67693
67694   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67695   jresult = (int)result;
67696   return jresult;
67697 }
67698
67699
67700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
67701   int jresult ;
67702   int result;
67703
67704   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67705   jresult = (int)result;
67706   return jresult;
67707 }
67708
67709
67710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
67711   int jresult ;
67712   int result;
67713
67714   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67715   jresult = (int)result;
67716   return jresult;
67717 }
67718
67719
67720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67721   int jresult ;
67722   int result;
67723
67724   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67725   jresult = (int)result;
67726   return jresult;
67727 }
67728
67729
67730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67731   int jresult ;
67732   int result;
67733
67734   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67735   jresult = (int)result;
67736   return jresult;
67737 }
67738
67739
67740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67741   int jresult ;
67742   int result;
67743
67744   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67745   jresult = (int)result;
67746   return jresult;
67747 }
67748
67749
67750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67751   int jresult ;
67752   int result;
67753
67754   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67755   jresult = (int)result;
67756   return jresult;
67757 }
67758
67759
67760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67761   void * jresult ;
67762   Dali::Toolkit::Model3dView::Property *result = 0 ;
67763
67764   {
67765     try {
67766       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67767     } catch (std::out_of_range& e) {
67768       {
67769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67770       };
67771     } catch (std::exception& e) {
67772       {
67773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67774       };
67775     } catch (...) {
67776       {
67777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67778       };
67779     }
67780   }
67781   jresult = (void *)result;
67782   return jresult;
67783 }
67784
67785
67786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67787   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67788
67789   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67790   {
67791     try {
67792       delete arg1;
67793     } catch (std::out_of_range& e) {
67794       {
67795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67796       };
67797     } catch (std::exception& e) {
67798       {
67799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67800       };
67801     } catch (...) {
67802       {
67803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67804       };
67805     }
67806   }
67807 }
67808
67809
67810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67811   void * jresult ;
67812   Dali::Toolkit::Model3dView result;
67813
67814   {
67815     try {
67816       result = Dali::Toolkit::Model3dView::New();
67817     } catch (std::out_of_range& e) {
67818       {
67819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67820       };
67821     } catch (std::exception& e) {
67822       {
67823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67824       };
67825     } catch (...) {
67826       {
67827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67828       };
67829     }
67830   }
67831   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67832   return jresult;
67833 }
67834
67835
67836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67837   void * jresult ;
67838   std::string *arg1 = 0 ;
67839   std::string *arg2 = 0 ;
67840   std::string *arg3 = 0 ;
67841   Dali::Toolkit::Model3dView result;
67842
67843   if (!jarg1) {
67844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67845     return 0;
67846   }
67847   std::string arg1_str(jarg1);
67848   arg1 = &arg1_str;
67849   if (!jarg2) {
67850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67851     return 0;
67852   }
67853   std::string arg2_str(jarg2);
67854   arg2 = &arg2_str;
67855   if (!jarg3) {
67856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67857     return 0;
67858   }
67859   std::string arg3_str(jarg3);
67860   arg3 = &arg3_str;
67861   {
67862     try {
67863       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67864     } catch (std::out_of_range& e) {
67865       {
67866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67867       };
67868     } catch (std::exception& e) {
67869       {
67870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67871       };
67872     } catch (...) {
67873       {
67874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67875       };
67876     }
67877   }
67878   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67879
67880   //argout typemap for const std::string&
67881
67882
67883   //argout typemap for const std::string&
67884
67885
67886   //argout typemap for const std::string&
67887
67888   return jresult;
67889 }
67890
67891
67892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67893   void * jresult ;
67894   Dali::Toolkit::Model3dView *result = 0 ;
67895
67896   {
67897     try {
67898       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67899     } catch (std::out_of_range& e) {
67900       {
67901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67902       };
67903     } catch (std::exception& e) {
67904       {
67905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67906       };
67907     } catch (...) {
67908       {
67909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67910       };
67911     }
67912   }
67913   jresult = (void *)result;
67914   return jresult;
67915 }
67916
67917
67918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67919   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67920
67921   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67922   {
67923     try {
67924       delete arg1;
67925     } catch (std::out_of_range& e) {
67926       {
67927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67928       };
67929     } catch (std::exception& e) {
67930       {
67931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67932       };
67933     } catch (...) {
67934       {
67935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67936       };
67937     }
67938   }
67939 }
67940
67941
67942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67943   void * jresult ;
67944   Dali::Toolkit::Model3dView *arg1 = 0 ;
67945   Dali::Toolkit::Model3dView *result = 0 ;
67946
67947   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67948   if (!arg1) {
67949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67950     return 0;
67951   }
67952   {
67953     try {
67954       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67955     } catch (std::out_of_range& e) {
67956       {
67957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67958       };
67959     } catch (std::exception& e) {
67960       {
67961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67962       };
67963     } catch (...) {
67964       {
67965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67966       };
67967     }
67968   }
67969   jresult = (void *)result;
67970   return jresult;
67971 }
67972
67973
67974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67975   void * jresult ;
67976   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67977   Dali::Toolkit::Model3dView *arg2 = 0 ;
67978   Dali::Toolkit::Model3dView *result = 0 ;
67979
67980   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67981   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67982   if (!arg2) {
67983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67984     return 0;
67985   }
67986   {
67987     try {
67988       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67989     } catch (std::out_of_range& e) {
67990       {
67991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67992       };
67993     } catch (std::exception& e) {
67994       {
67995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67996       };
67997     } catch (...) {
67998       {
67999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68000       };
68001     }
68002   }
68003   jresult = (void *)result;
68004   return jresult;
68005 }
68006
68007
68008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
68009   void * jresult ;
68010   Dali::BaseHandle arg1 ;
68011   Dali::BaseHandle *argp1 ;
68012   Dali::Toolkit::Model3dView result;
68013
68014   argp1 = (Dali::BaseHandle *)jarg1;
68015   if (!argp1) {
68016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68017     return 0;
68018   }
68019   arg1 = *argp1;
68020   {
68021     try {
68022       result = Dali::Toolkit::Model3dView::DownCast(arg1);
68023     } catch (std::out_of_range& e) {
68024       {
68025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68026       };
68027     } catch (std::exception& e) {
68028       {
68029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68030       };
68031     } catch (...) {
68032       {
68033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68034       };
68035     }
68036   }
68037   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
68038   return jresult;
68039 }
68040
68041
68042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
68043   int jresult ;
68044   int result;
68045
68046   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
68047   jresult = (int)result;
68048   return jresult;
68049 }
68050
68051
68052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
68053   int jresult ;
68054   int result;
68055
68056   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
68057   jresult = (int)result;
68058   return jresult;
68059 }
68060
68061
68062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
68063   int jresult ;
68064   int result;
68065
68066   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
68067   jresult = (int)result;
68068   return jresult;
68069 }
68070
68071
68072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
68073   int jresult ;
68074   int result;
68075
68076   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
68077   jresult = (int)result;
68078   return jresult;
68079 }
68080
68081
68082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
68083   int jresult ;
68084   int result;
68085
68086   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
68087   jresult = (int)result;
68088   return jresult;
68089 }
68090
68091
68092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
68093   int jresult ;
68094   int result;
68095
68096   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
68097   jresult = (int)result;
68098   return jresult;
68099 }
68100
68101
68102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
68103   int jresult ;
68104   int result;
68105
68106   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
68107   jresult = (int)result;
68108   return jresult;
68109 }
68110
68111
68112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
68113   int jresult ;
68114   int result;
68115
68116   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
68117   jresult = (int)result;
68118   return jresult;
68119 }
68120
68121
68122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
68123   int jresult ;
68124   int result;
68125
68126   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
68127   jresult = (int)result;
68128   return jresult;
68129 }
68130
68131
68132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
68133   void * jresult ;
68134   Dali::Toolkit::ScrollBar::Property *result = 0 ;
68135
68136   {
68137     try {
68138       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
68139     } catch (std::out_of_range& e) {
68140       {
68141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68142       };
68143     } catch (std::exception& e) {
68144       {
68145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68146       };
68147     } catch (...) {
68148       {
68149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68150       };
68151     }
68152   }
68153   jresult = (void *)result;
68154   return jresult;
68155 }
68156
68157
68158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
68159   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
68160
68161   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
68162   {
68163     try {
68164       delete arg1;
68165     } catch (std::out_of_range& e) {
68166       {
68167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68168       };
68169     } catch (std::exception& e) {
68170       {
68171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68172       };
68173     } catch (...) {
68174       {
68175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68176       };
68177     }
68178   }
68179 }
68180
68181
68182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
68183   void * jresult ;
68184   Dali::Toolkit::ScrollBar *result = 0 ;
68185
68186   {
68187     try {
68188       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
68189     } catch (std::out_of_range& e) {
68190       {
68191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68192       };
68193     } catch (std::exception& e) {
68194       {
68195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68196       };
68197     } catch (...) {
68198       {
68199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68200       };
68201     }
68202   }
68203   jresult = (void *)result;
68204   return jresult;
68205 }
68206
68207
68208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
68209   void * jresult ;
68210   Dali::Toolkit::ScrollBar *arg1 = 0 ;
68211   Dali::Toolkit::ScrollBar *result = 0 ;
68212
68213   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68214   if (!arg1) {
68215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68216     return 0;
68217   }
68218   {
68219     try {
68220       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
68221     } catch (std::out_of_range& e) {
68222       {
68223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68224       };
68225     } catch (std::exception& e) {
68226       {
68227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68228       };
68229     } catch (...) {
68230       {
68231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68232       };
68233     }
68234   }
68235   jresult = (void *)result;
68236   return jresult;
68237 }
68238
68239
68240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
68241   void * jresult ;
68242   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68243   Dali::Toolkit::ScrollBar *arg2 = 0 ;
68244   Dali::Toolkit::ScrollBar *result = 0 ;
68245
68246   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68247   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
68248   if (!arg2) {
68249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
68250     return 0;
68251   }
68252   {
68253     try {
68254       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
68255     } catch (std::out_of_range& e) {
68256       {
68257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68258       };
68259     } catch (std::exception& e) {
68260       {
68261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68262       };
68263     } catch (...) {
68264       {
68265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68266       };
68267     }
68268   }
68269   jresult = (void *)result;
68270   return jresult;
68271 }
68272
68273
68274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
68275   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68276
68277   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68278   {
68279     try {
68280       delete arg1;
68281     } catch (std::out_of_range& e) {
68282       {
68283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68284       };
68285     } catch (std::exception& e) {
68286       {
68287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68288       };
68289     } catch (...) {
68290       {
68291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68292       };
68293     }
68294   }
68295 }
68296
68297
68298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
68299   void * jresult ;
68300   Dali::Toolkit::ScrollBar::Direction arg1 ;
68301   Dali::Toolkit::ScrollBar result;
68302
68303   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
68304   {
68305     try {
68306       result = Dali::Toolkit::ScrollBar::New(arg1);
68307     } catch (std::out_of_range& e) {
68308       {
68309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68310       };
68311     } catch (std::exception& e) {
68312       {
68313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68314       };
68315     } catch (...) {
68316       {
68317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68318       };
68319     }
68320   }
68321   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68322   return jresult;
68323 }
68324
68325
68326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
68327   void * jresult ;
68328   Dali::Toolkit::ScrollBar result;
68329
68330   {
68331     try {
68332       result = Dali::Toolkit::ScrollBar::New();
68333     } catch (std::out_of_range& e) {
68334       {
68335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68336       };
68337     } catch (std::exception& e) {
68338       {
68339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68340       };
68341     } catch (...) {
68342       {
68343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68344       };
68345     }
68346   }
68347   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68348   return jresult;
68349 }
68350
68351
68352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
68353   void * jresult ;
68354   Dali::BaseHandle arg1 ;
68355   Dali::BaseHandle *argp1 ;
68356   Dali::Toolkit::ScrollBar result;
68357
68358   argp1 = (Dali::BaseHandle *)jarg1;
68359   if (!argp1) {
68360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68361     return 0;
68362   }
68363   arg1 = *argp1;
68364   {
68365     try {
68366       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
68367     } catch (std::out_of_range& e) {
68368       {
68369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68370       };
68371     } catch (std::exception& e) {
68372       {
68373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68374       };
68375     } catch (...) {
68376       {
68377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68378       };
68379     }
68380   }
68381   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68382   return jresult;
68383 }
68384
68385
68386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
68387   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68388   Dali::Handle arg2 ;
68389   Dali::Property::Index arg3 ;
68390   Dali::Property::Index arg4 ;
68391   Dali::Property::Index arg5 ;
68392   Dali::Property::Index arg6 ;
68393   Dali::Handle *argp2 ;
68394
68395   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68396   argp2 = (Dali::Handle *)jarg2;
68397   if (!argp2) {
68398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
68399     return ;
68400   }
68401   arg2 = *argp2;
68402   arg3 = (Dali::Property::Index)jarg3;
68403   arg4 = (Dali::Property::Index)jarg4;
68404   arg5 = (Dali::Property::Index)jarg5;
68405   arg6 = (Dali::Property::Index)jarg6;
68406   {
68407     try {
68408       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
68409     } catch (std::out_of_range& e) {
68410       {
68411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68412       };
68413     } catch (std::exception& e) {
68414       {
68415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68416       };
68417     } catch (...) {
68418       {
68419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68420       };
68421     }
68422   }
68423 }
68424
68425
68426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
68427   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68428   Dali::Actor arg2 ;
68429   Dali::Actor *argp2 ;
68430
68431   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68432   argp2 = (Dali::Actor *)jarg2;
68433   if (!argp2) {
68434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68435     return ;
68436   }
68437   arg2 = *argp2;
68438   {
68439     try {
68440       (arg1)->SetScrollIndicator(arg2);
68441     } catch (std::out_of_range& e) {
68442       {
68443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68444       };
68445     } catch (std::exception& e) {
68446       {
68447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68448       };
68449     } catch (...) {
68450       {
68451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68452       };
68453     }
68454   }
68455 }
68456
68457
68458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
68459   void * jresult ;
68460   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68461   Dali::Actor result;
68462
68463   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68464   {
68465     try {
68466       result = (arg1)->GetScrollIndicator();
68467     } catch (std::out_of_range& e) {
68468       {
68469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68470       };
68471     } catch (std::exception& e) {
68472       {
68473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68474       };
68475     } catch (...) {
68476       {
68477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68478       };
68479     }
68480   }
68481   jresult = new Dali::Actor((const Dali::Actor &)result);
68482   return jresult;
68483 }
68484
68485
68486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68487   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68488   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68489
68490   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68491   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68492   if (!arg2) {
68493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68494     return ;
68495   }
68496   {
68497     try {
68498       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68499     } catch (std::out_of_range& e) {
68500       {
68501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68502       };
68503     } catch (std::exception& e) {
68504       {
68505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68506       };
68507     } catch (...) {
68508       {
68509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68510       };
68511     }
68512   }
68513 }
68514
68515
68516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68517   void * jresult ;
68518   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68519   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
68520
68521   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68522   {
68523     try {
68524       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
68525     } catch (std::out_of_range& e) {
68526       {
68527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68528       };
68529     } catch (std::exception& e) {
68530       {
68531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68532       };
68533     } catch (...) {
68534       {
68535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68536       };
68537     }
68538   }
68539   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
68540   return jresult;
68541 }
68542
68543
68544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68545   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68546   Dali::Toolkit::ScrollBar::Direction arg2 ;
68547
68548   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68549   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68550   {
68551     try {
68552       (arg1)->SetScrollDirection(arg2);
68553     } catch (std::out_of_range& e) {
68554       {
68555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68556       };
68557     } catch (std::exception& e) {
68558       {
68559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68560       };
68561     } catch (...) {
68562       {
68563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68564       };
68565     }
68566   }
68567 }
68568
68569
68570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
68571   int jresult ;
68572   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68573   Dali::Toolkit::ScrollBar::Direction result;
68574
68575   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68576   {
68577     try {
68578       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68579     } catch (std::out_of_range& e) {
68580       {
68581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68582       };
68583     } catch (std::exception& e) {
68584       {
68585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68586       };
68587     } catch (...) {
68588       {
68589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68590       };
68591     }
68592   }
68593   jresult = (int)result;
68594   return jresult;
68595 }
68596
68597
68598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68599   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68600   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68601
68602   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68603   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68604   {
68605     try {
68606       (arg1)->SetIndicatorHeightPolicy(arg2);
68607     } catch (std::out_of_range& e) {
68608       {
68609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68610       };
68611     } catch (std::exception& e) {
68612       {
68613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68614       };
68615     } catch (...) {
68616       {
68617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68618       };
68619     }
68620   }
68621 }
68622
68623
68624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68625   int jresult ;
68626   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68627   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68628
68629   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68630   {
68631     try {
68632       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68633     } catch (std::out_of_range& e) {
68634       {
68635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68636       };
68637     } catch (std::exception& e) {
68638       {
68639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68640       };
68641     } catch (...) {
68642       {
68643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68644       };
68645     }
68646   }
68647   jresult = (int)result;
68648   return jresult;
68649 }
68650
68651
68652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68653   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68654   float arg2 ;
68655
68656   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68657   arg2 = (float)jarg2;
68658   {
68659     try {
68660       (arg1)->SetIndicatorFixedHeight(arg2);
68661     } catch (std::out_of_range& e) {
68662       {
68663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68664       };
68665     } catch (std::exception& e) {
68666       {
68667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68668       };
68669     } catch (...) {
68670       {
68671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68672       };
68673     }
68674   }
68675 }
68676
68677
68678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68679   float jresult ;
68680   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68681   float result;
68682
68683   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68684   {
68685     try {
68686       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68687     } catch (std::out_of_range& e) {
68688       {
68689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68690       };
68691     } catch (std::exception& e) {
68692       {
68693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68694       };
68695     } catch (...) {
68696       {
68697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68698       };
68699     }
68700   }
68701   jresult = result;
68702   return jresult;
68703 }
68704
68705
68706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68707   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68708   float arg2 ;
68709
68710   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68711   arg2 = (float)jarg2;
68712   {
68713     try {
68714       (arg1)->SetIndicatorShowDuration(arg2);
68715     } catch (std::out_of_range& e) {
68716       {
68717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68718       };
68719     } catch (std::exception& e) {
68720       {
68721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68722       };
68723     } catch (...) {
68724       {
68725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68726       };
68727     }
68728   }
68729 }
68730
68731
68732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68733   float jresult ;
68734   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68735   float result;
68736
68737   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68738   {
68739     try {
68740       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68741     } catch (std::out_of_range& e) {
68742       {
68743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68744       };
68745     } catch (std::exception& e) {
68746       {
68747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68748       };
68749     } catch (...) {
68750       {
68751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68752       };
68753     }
68754   }
68755   jresult = result;
68756   return jresult;
68757 }
68758
68759
68760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68761   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68762   float arg2 ;
68763
68764   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68765   arg2 = (float)jarg2;
68766   {
68767     try {
68768       (arg1)->SetIndicatorHideDuration(arg2);
68769     } catch (std::out_of_range& e) {
68770       {
68771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68772       };
68773     } catch (std::exception& e) {
68774       {
68775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68776       };
68777     } catch (...) {
68778       {
68779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68780       };
68781     }
68782   }
68783 }
68784
68785
68786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68787   float jresult ;
68788   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68789   float result;
68790
68791   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68792   {
68793     try {
68794       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68795     } catch (std::out_of_range& e) {
68796       {
68797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68798       };
68799     } catch (std::exception& e) {
68800       {
68801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68802       };
68803     } catch (...) {
68804       {
68805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68806       };
68807     }
68808   }
68809   jresult = result;
68810   return jresult;
68811 }
68812
68813
68814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68815   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68816
68817   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68818   {
68819     try {
68820       (arg1)->ShowIndicator();
68821     } catch (std::out_of_range& e) {
68822       {
68823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68824       };
68825     } catch (std::exception& e) {
68826       {
68827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68828       };
68829     } catch (...) {
68830       {
68831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68832       };
68833     }
68834   }
68835 }
68836
68837
68838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68839   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68840
68841   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68842   {
68843     try {
68844       (arg1)->HideIndicator();
68845     } catch (std::out_of_range& e) {
68846       {
68847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68848       };
68849     } catch (std::exception& e) {
68850       {
68851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68852       };
68853     } catch (...) {
68854       {
68855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68856       };
68857     }
68858   }
68859 }
68860
68861
68862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68863   void * jresult ;
68864   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68865   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68866
68867   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68868   {
68869     try {
68870       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68871     } catch (std::out_of_range& e) {
68872       {
68873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68874       };
68875     } catch (std::exception& e) {
68876       {
68877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68878       };
68879     } catch (...) {
68880       {
68881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68882       };
68883     }
68884   }
68885   jresult = (void *)result;
68886   return jresult;
68887 }
68888
68889
68890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68891   void * jresult ;
68892   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68893   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68894
68895   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68896   {
68897     try {
68898       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68899     } catch (std::out_of_range& e) {
68900       {
68901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68902       };
68903     } catch (std::exception& e) {
68904       {
68905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68906       };
68907     } catch (...) {
68908       {
68909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68910       };
68911     }
68912   }
68913   jresult = (void *)result;
68914   return jresult;
68915 }
68916
68917
68918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68919   int jresult ;
68920   int result;
68921
68922   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68923   jresult = (int)result;
68924   return jresult;
68925 }
68926
68927
68928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68929   int jresult ;
68930   int result;
68931
68932   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68933   jresult = (int)result;
68934   return jresult;
68935 }
68936
68937
68938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68939   int jresult ;
68940   int result;
68941
68942   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68943   jresult = (int)result;
68944   return jresult;
68945 }
68946
68947
68948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68949   int jresult ;
68950   int result;
68951
68952   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68953   jresult = (int)result;
68954   return jresult;
68955 }
68956
68957
68958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68959   int jresult ;
68960   int result;
68961
68962   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68963   jresult = (int)result;
68964   return jresult;
68965 }
68966
68967
68968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68969   int jresult ;
68970   int result;
68971
68972   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68973   jresult = (int)result;
68974   return jresult;
68975 }
68976
68977
68978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68979   int jresult ;
68980   int result;
68981
68982   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68983   jresult = (int)result;
68984   return jresult;
68985 }
68986
68987
68988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68989   int jresult ;
68990   int result;
68991
68992   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68993   jresult = (int)result;
68994   return jresult;
68995 }
68996
68997
68998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68999   int jresult ;
69000   int result;
69001
69002   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
69003   jresult = (int)result;
69004   return jresult;
69005 }
69006
69007
69008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
69009   int jresult ;
69010   int result;
69011
69012   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
69013   jresult = (int)result;
69014   return jresult;
69015 }
69016
69017
69018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
69019   int jresult ;
69020   int result;
69021
69022   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
69023   jresult = (int)result;
69024   return jresult;
69025 }
69026
69027
69028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
69029   int jresult ;
69030   int result;
69031
69032   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
69033   jresult = (int)result;
69034   return jresult;
69035 }
69036
69037
69038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
69039   int jresult ;
69040   int result;
69041
69042   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
69043   jresult = (int)result;
69044   return jresult;
69045 }
69046
69047
69048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
69049   int jresult ;
69050   int result;
69051
69052   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
69053   jresult = (int)result;
69054   return jresult;
69055 }
69056
69057
69058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
69059   void * jresult ;
69060   Dali::Toolkit::Scrollable::Property *result = 0 ;
69061
69062   {
69063     try {
69064       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
69065     } catch (std::out_of_range& e) {
69066       {
69067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69068       };
69069     } catch (std::exception& e) {
69070       {
69071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69072       };
69073     } catch (...) {
69074       {
69075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69076       };
69077     }
69078   }
69079   jresult = (void *)result;
69080   return jresult;
69081 }
69082
69083
69084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
69085   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
69086
69087   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
69088   {
69089     try {
69090       delete arg1;
69091     } catch (std::out_of_range& e) {
69092       {
69093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69094       };
69095     } catch (std::exception& e) {
69096       {
69097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69098       };
69099     } catch (...) {
69100       {
69101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69102       };
69103     }
69104   }
69105 }
69106
69107
69108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
69109   void * jresult ;
69110   Dali::Toolkit::Scrollable *result = 0 ;
69111
69112   {
69113     try {
69114       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
69115     } catch (std::out_of_range& e) {
69116       {
69117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69118       };
69119     } catch (std::exception& e) {
69120       {
69121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69122       };
69123     } catch (...) {
69124       {
69125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69126       };
69127     }
69128   }
69129   jresult = (void *)result;
69130   return jresult;
69131 }
69132
69133
69134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
69135   void * jresult ;
69136   Dali::Toolkit::Scrollable *arg1 = 0 ;
69137   Dali::Toolkit::Scrollable *result = 0 ;
69138
69139   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69140   if (!arg1) {
69141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69142     return 0;
69143   }
69144   {
69145     try {
69146       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
69147     } catch (std::out_of_range& e) {
69148       {
69149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69150       };
69151     } catch (std::exception& e) {
69152       {
69153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69154       };
69155     } catch (...) {
69156       {
69157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69158       };
69159     }
69160   }
69161   jresult = (void *)result;
69162   return jresult;
69163 }
69164
69165
69166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
69167   void * jresult ;
69168   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69169   Dali::Toolkit::Scrollable *arg2 = 0 ;
69170   Dali::Toolkit::Scrollable *result = 0 ;
69171
69172   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69173   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
69174   if (!arg2) {
69175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69176     return 0;
69177   }
69178   {
69179     try {
69180       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
69181     } catch (std::out_of_range& e) {
69182       {
69183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69184       };
69185     } catch (std::exception& e) {
69186       {
69187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69188       };
69189     } catch (...) {
69190       {
69191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69192       };
69193     }
69194   }
69195   jresult = (void *)result;
69196   return jresult;
69197 }
69198
69199
69200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
69201   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69202
69203   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69204   {
69205     try {
69206       delete arg1;
69207     } catch (std::out_of_range& e) {
69208       {
69209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69210       };
69211     } catch (std::exception& e) {
69212       {
69213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69214       };
69215     } catch (...) {
69216       {
69217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69218       };
69219     }
69220   }
69221 }
69222
69223
69224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
69225   void * jresult ;
69226   Dali::BaseHandle arg1 ;
69227   Dali::BaseHandle *argp1 ;
69228   Dali::Toolkit::Scrollable result;
69229
69230   argp1 = (Dali::BaseHandle *)jarg1;
69231   if (!argp1) {
69232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69233     return 0;
69234   }
69235   arg1 = *argp1;
69236   {
69237     try {
69238       result = Dali::Toolkit::Scrollable::DownCast(arg1);
69239     } catch (std::out_of_range& e) {
69240       {
69241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69242       };
69243     } catch (std::exception& e) {
69244       {
69245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69246       };
69247     } catch (...) {
69248       {
69249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69250       };
69251     }
69252   }
69253   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
69254   return jresult;
69255 }
69256
69257
69258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
69259   unsigned int jresult ;
69260   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69261   bool result;
69262
69263   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69264   {
69265     try {
69266       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
69267     } catch (std::out_of_range& e) {
69268       {
69269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69270       };
69271     } catch (std::exception& e) {
69272       {
69273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69274       };
69275     } catch (...) {
69276       {
69277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69278       };
69279     }
69280   }
69281   jresult = result;
69282   return jresult;
69283 }
69284
69285
69286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
69287   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69288   bool arg2 ;
69289
69290   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69291   arg2 = jarg2 ? true : false;
69292   {
69293     try {
69294       (arg1)->SetOvershootEnabled(arg2);
69295     } catch (std::out_of_range& e) {
69296       {
69297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69298       };
69299     } catch (std::exception& e) {
69300       {
69301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69302       };
69303     } catch (...) {
69304       {
69305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69306       };
69307     }
69308   }
69309 }
69310
69311
69312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
69313   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69314   Dali::Vector4 *arg2 = 0 ;
69315
69316   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69317   arg2 = (Dali::Vector4 *)jarg2;
69318   if (!arg2) {
69319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
69320     return ;
69321   }
69322   {
69323     try {
69324       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
69325     } catch (std::out_of_range& e) {
69326       {
69327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69328       };
69329     } catch (std::exception& e) {
69330       {
69331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69332       };
69333     } catch (...) {
69334       {
69335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69336       };
69337     }
69338   }
69339 }
69340
69341
69342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
69343   void * jresult ;
69344   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69345   Dali::Vector4 result;
69346
69347   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69348   {
69349     try {
69350       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
69351     } catch (std::out_of_range& e) {
69352       {
69353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69354       };
69355     } catch (std::exception& e) {
69356       {
69357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69358       };
69359     } catch (...) {
69360       {
69361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69362       };
69363     }
69364   }
69365   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
69366   return jresult;
69367 }
69368
69369
69370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
69371   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69372   float arg2 ;
69373
69374   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69375   arg2 = (float)jarg2;
69376   {
69377     try {
69378       (arg1)->SetOvershootAnimationSpeed(arg2);
69379     } catch (std::out_of_range& e) {
69380       {
69381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69382       };
69383     } catch (std::exception& e) {
69384       {
69385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69386       };
69387     } catch (...) {
69388       {
69389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69390       };
69391     }
69392   }
69393 }
69394
69395
69396 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69397   float jresult ;
69398   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69399   float result;
69400
69401   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69402   {
69403     try {
69404       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69405     } catch (std::out_of_range& e) {
69406       {
69407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69408       };
69409     } catch (std::exception& e) {
69410       {
69411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69412       };
69413     } catch (...) {
69414       {
69415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69416       };
69417     }
69418   }
69419   jresult = result;
69420   return jresult;
69421 }
69422
69423
69424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
69425   void * jresult ;
69426   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69427   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69428
69429   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69430   {
69431     try {
69432       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69433     } catch (std::out_of_range& e) {
69434       {
69435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69436       };
69437     } catch (std::exception& e) {
69438       {
69439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69440       };
69441     } catch (...) {
69442       {
69443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69444       };
69445     }
69446   }
69447   jresult = (void *)result;
69448   return jresult;
69449 }
69450
69451
69452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69453   void * jresult ;
69454   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69455   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69456
69457   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69458   {
69459     try {
69460       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69461     } catch (std::out_of_range& e) {
69462       {
69463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69464       };
69465     } catch (std::exception& e) {
69466       {
69467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69468       };
69469     } catch (...) {
69470       {
69471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69472       };
69473     }
69474   }
69475   jresult = (void *)result;
69476   return jresult;
69477 }
69478
69479
69480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69481   void * jresult ;
69482   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69483   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69484
69485   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69486   {
69487     try {
69488       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69489     } catch (std::out_of_range& e) {
69490       {
69491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69492       };
69493     } catch (std::exception& e) {
69494       {
69495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69496       };
69497     } catch (...) {
69498       {
69499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69500       };
69501     }
69502   }
69503   jresult = (void *)result;
69504   return jresult;
69505 }
69506
69507
69508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69509   unsigned int jresult ;
69510   Dali::Toolkit::ControlOrientation::Type arg1 ;
69511   bool result;
69512
69513   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69514   {
69515     try {
69516       result = (bool)Dali::Toolkit::IsVertical(arg1);
69517     } catch (std::out_of_range& e) {
69518       {
69519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69520       };
69521     } catch (std::exception& e) {
69522       {
69523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69524       };
69525     } catch (...) {
69526       {
69527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69528       };
69529     }
69530   }
69531   jresult = result;
69532   return jresult;
69533 }
69534
69535
69536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69537   unsigned int jresult ;
69538   Dali::Toolkit::ControlOrientation::Type arg1 ;
69539   bool result;
69540
69541   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69542   {
69543     try {
69544       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69545     } catch (std::out_of_range& e) {
69546       {
69547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69548       };
69549     } catch (std::exception& e) {
69550       {
69551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69552       };
69553     } catch (...) {
69554       {
69555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69556       };
69557     }
69558   }
69559   jresult = result;
69560   return jresult;
69561 }
69562
69563
69564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69565   void * jresult ;
69566   unsigned int arg1 ;
69567   unsigned int arg2 ;
69568   Dali::Toolkit::ItemRange *result = 0 ;
69569
69570   arg1 = (unsigned int)jarg1;
69571   arg2 = (unsigned int)jarg2;
69572   {
69573     try {
69574       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69575     } catch (std::out_of_range& e) {
69576       {
69577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69578       };
69579     } catch (std::exception& e) {
69580       {
69581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69582       };
69583     } catch (...) {
69584       {
69585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69586       };
69587     }
69588   }
69589   jresult = (void *)result;
69590   return jresult;
69591 }
69592
69593
69594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69595   void * jresult ;
69596   Dali::Toolkit::ItemRange *arg1 = 0 ;
69597   Dali::Toolkit::ItemRange *result = 0 ;
69598
69599   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69600   if (!arg1) {
69601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69602     return 0;
69603   }
69604   {
69605     try {
69606       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69607     } catch (std::out_of_range& e) {
69608       {
69609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69610       };
69611     } catch (std::exception& e) {
69612       {
69613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69614       };
69615     } catch (...) {
69616       {
69617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69618       };
69619     }
69620   }
69621   jresult = (void *)result;
69622   return jresult;
69623 }
69624
69625
69626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69627   void * jresult ;
69628   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69629   Dali::Toolkit::ItemRange *arg2 = 0 ;
69630   Dali::Toolkit::ItemRange *result = 0 ;
69631
69632   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69633   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69634   if (!arg2) {
69635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69636     return 0;
69637   }
69638   {
69639     try {
69640       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69641     } catch (std::out_of_range& e) {
69642       {
69643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69644       };
69645     } catch (std::exception& e) {
69646       {
69647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69648       };
69649     } catch (...) {
69650       {
69651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69652       };
69653     }
69654   }
69655   jresult = (void *)result;
69656   return jresult;
69657 }
69658
69659
69660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69661   unsigned int jresult ;
69662   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69663   unsigned int arg2 ;
69664   bool result;
69665
69666   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69667   arg2 = (unsigned int)jarg2;
69668   {
69669     try {
69670       result = (bool)(arg1)->Within(arg2);
69671     } catch (std::out_of_range& e) {
69672       {
69673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69674       };
69675     } catch (std::exception& e) {
69676       {
69677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69678       };
69679     } catch (...) {
69680       {
69681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69682       };
69683     }
69684   }
69685   jresult = result;
69686   return jresult;
69687 }
69688
69689
69690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69691   void * jresult ;
69692   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69693   Dali::Toolkit::ItemRange *arg2 = 0 ;
69694   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69695
69696   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69697   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69698   if (!arg2) {
69699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69700     return 0;
69701   }
69702   {
69703     try {
69704       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69705     } catch (std::out_of_range& e) {
69706       {
69707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69708       };
69709     } catch (std::exception& e) {
69710       {
69711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69712       };
69713     } catch (...) {
69714       {
69715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69716       };
69717     }
69718   }
69719   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69720   return jresult;
69721 }
69722
69723
69724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69725   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69726   unsigned int arg2 ;
69727
69728   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69729   arg2 = (unsigned int)jarg2;
69730   if (arg1) (arg1)->begin = arg2;
69731 }
69732
69733
69734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69735   unsigned int jresult ;
69736   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69737   unsigned int result;
69738
69739   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69740   result = (unsigned int) ((arg1)->begin);
69741   jresult = result;
69742   return jresult;
69743 }
69744
69745
69746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69747   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69748   unsigned int arg2 ;
69749
69750   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69751   arg2 = (unsigned int)jarg2;
69752   if (arg1) (arg1)->end = arg2;
69753 }
69754
69755
69756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69757   unsigned int jresult ;
69758   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69759   unsigned int result;
69760
69761   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69762   result = (unsigned int) ((arg1)->end);
69763   jresult = result;
69764   return jresult;
69765 }
69766
69767
69768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69769   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69770
69771   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69772   {
69773     try {
69774       delete arg1;
69775     } catch (std::out_of_range& e) {
69776       {
69777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69778       };
69779     } catch (std::exception& e) {
69780       {
69781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69782       };
69783     } catch (...) {
69784       {
69785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69786       };
69787     }
69788   }
69789 }
69790
69791
69792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69793   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69794
69795   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69796   {
69797     try {
69798       delete arg1;
69799     } catch (std::out_of_range& e) {
69800       {
69801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69802       };
69803     } catch (std::exception& e) {
69804       {
69805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69806       };
69807     } catch (...) {
69808       {
69809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69810       };
69811     }
69812   }
69813 }
69814
69815
69816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69817   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69818   Dali::Toolkit::ControlOrientation::Type arg2 ;
69819
69820   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69821   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69822   {
69823     try {
69824       (arg1)->SetOrientation(arg2);
69825     } catch (std::out_of_range& e) {
69826       {
69827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69828       };
69829     } catch (std::exception& e) {
69830       {
69831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69832       };
69833     } catch (...) {
69834       {
69835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69836       };
69837     }
69838   }
69839 }
69840
69841
69842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69843   int jresult ;
69844   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69845   Dali::Toolkit::ControlOrientation::Type result;
69846
69847   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69848   {
69849     try {
69850       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69851     } catch (std::out_of_range& e) {
69852       {
69853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69854       };
69855     } catch (std::exception& e) {
69856       {
69857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69858       };
69859     } catch (...) {
69860       {
69861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69862       };
69863     }
69864   }
69865   jresult = (int)result;
69866   return jresult;
69867 }
69868
69869
69870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69871   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69872   Dali::Property::Map *arg2 = 0 ;
69873
69874   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69875   arg2 = (Dali::Property::Map *)jarg2;
69876   if (!arg2) {
69877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69878     return ;
69879   }
69880   {
69881     try {
69882       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69883     } catch (std::out_of_range& e) {
69884       {
69885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69886       };
69887     } catch (std::exception& e) {
69888       {
69889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69890       };
69891     } catch (...) {
69892       {
69893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69894       };
69895     }
69896   }
69897 }
69898
69899
69900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69901   void * jresult ;
69902   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69903   Dali::Property::Map result;
69904
69905   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69906   {
69907     try {
69908       result = (arg1)->GetLayoutProperties();
69909     } catch (std::out_of_range& e) {
69910       {
69911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69912       };
69913     } catch (std::exception& e) {
69914       {
69915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69916       };
69917     } catch (...) {
69918       {
69919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69920       };
69921     }
69922   }
69923   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69924   return jresult;
69925 }
69926
69927
69928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69929   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69930   unsigned int arg2 ;
69931   Dali::Vector3 *arg3 = 0 ;
69932   Dali::Vector3 *arg4 = 0 ;
69933
69934   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69935   arg2 = (unsigned int)jarg2;
69936   arg3 = (Dali::Vector3 *)jarg3;
69937   if (!arg3) {
69938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69939     return ;
69940   }
69941   arg4 = (Dali::Vector3 *)jarg4;
69942   if (!arg4) {
69943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69944     return ;
69945   }
69946   {
69947     try {
69948       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69949     } catch (std::out_of_range& e) {
69950       {
69951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69952       };
69953     } catch (std::exception& e) {
69954       {
69955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69956       };
69957     } catch (...) {
69958       {
69959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69960       };
69961     }
69962   }
69963 }
69964
69965
69966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69967   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69968   Dali::Vector3 *arg2 = 0 ;
69969
69970   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69971   arg2 = (Dali::Vector3 *)jarg2;
69972   if (!arg2) {
69973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69974     return ;
69975   }
69976   {
69977     try {
69978       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69979     } catch (std::out_of_range& e) {
69980       {
69981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69982       };
69983     } catch (std::exception& e) {
69984       {
69985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69986       };
69987     } catch (...) {
69988       {
69989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69990       };
69991     }
69992   }
69993 }
69994
69995
69996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69997   float jresult ;
69998   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69999   unsigned int arg2 ;
70000   Dali::Vector3 arg3 ;
70001   Dali::Vector3 *argp3 ;
70002   float result;
70003
70004   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70005   arg2 = (unsigned int)jarg2;
70006   argp3 = (Dali::Vector3 *)jarg3;
70007   if (!argp3) {
70008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70009     return 0;
70010   }
70011   arg3 = *argp3;
70012   {
70013     try {
70014       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
70015     } catch (std::out_of_range& e) {
70016       {
70017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70018       };
70019     } catch (std::exception& e) {
70020       {
70021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70022       };
70023     } catch (...) {
70024       {
70025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70026       };
70027     }
70028   }
70029   jresult = result;
70030   return jresult;
70031 }
70032
70033
70034 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
70035   float jresult ;
70036   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70037   float arg2 ;
70038   float result;
70039
70040   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70041   arg2 = (float)jarg2;
70042   {
70043     try {
70044       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
70045     } catch (std::out_of_range& e) {
70046       {
70047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70048       };
70049     } catch (std::exception& e) {
70050       {
70051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70052       };
70053     } catch (...) {
70054       {
70055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70056       };
70057     }
70058   }
70059   jresult = result;
70060   return jresult;
70061 }
70062
70063
70064 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
70065   float jresult ;
70066   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70067   unsigned int arg2 ;
70068   float result;
70069
70070   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70071   arg2 = (unsigned int)jarg2;
70072   {
70073     try {
70074       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
70075     } catch (std::out_of_range& e) {
70076       {
70077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70078       };
70079     } catch (std::exception& e) {
70080       {
70081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70082       };
70083     } catch (...) {
70084       {
70085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70086       };
70087     }
70088   }
70089   jresult = result;
70090   return jresult;
70091 }
70092
70093
70094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
70095   void * jresult ;
70096   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70097   float arg2 ;
70098   Dali::Vector3 arg3 ;
70099   Dali::Vector3 *argp3 ;
70100   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
70101
70102   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70103   arg2 = (float)jarg2;
70104   argp3 = (Dali::Vector3 *)jarg3;
70105   if (!argp3) {
70106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70107     return 0;
70108   }
70109   arg3 = *argp3;
70110   {
70111     try {
70112       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
70113     } catch (std::out_of_range& e) {
70114       {
70115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70116       };
70117     } catch (std::exception& e) {
70118       {
70119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70120       };
70121     } catch (...) {
70122       {
70123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70124       };
70125     }
70126   }
70127   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
70128   return jresult;
70129 }
70130
70131
70132 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70133   float jresult ;
70134   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70135   int arg2 ;
70136   float arg3 ;
70137   Dali::Vector3 *arg4 = 0 ;
70138   float result;
70139
70140   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70141   arg2 = (int)jarg2;
70142   arg3 = (float)jarg3;
70143   arg4 = (Dali::Vector3 *)jarg4;
70144   if (!arg4) {
70145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70146     return 0;
70147   }
70148   {
70149     try {
70150       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70151     } catch (std::out_of_range& e) {
70152       {
70153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70154       };
70155     } catch (std::exception& e) {
70156       {
70157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70158       };
70159     } catch (...) {
70160       {
70161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70162       };
70163     }
70164   }
70165   jresult = result;
70166   return jresult;
70167 }
70168
70169
70170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
70171   unsigned int jresult ;
70172   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70173   Dali::Vector3 arg2 ;
70174   Dali::Vector3 *argp2 ;
70175   unsigned int result;
70176
70177   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70178   argp2 = (Dali::Vector3 *)jarg2;
70179   if (!argp2) {
70180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70181     return 0;
70182   }
70183   arg2 = *argp2;
70184   {
70185     try {
70186       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
70187     } catch (std::out_of_range& e) {
70188       {
70189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70190       };
70191     } catch (std::exception& e) {
70192       {
70193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70194       };
70195     } catch (...) {
70196       {
70197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70198       };
70199     }
70200   }
70201   jresult = result;
70202   return jresult;
70203 }
70204
70205
70206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70207   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70208   unsigned int arg2 ;
70209   Dali::Vector3 *arg3 = 0 ;
70210   Dali::Vector3 *arg4 = 0 ;
70211
70212   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70213   arg2 = (unsigned int)jarg2;
70214   arg3 = (Dali::Vector3 *)jarg3;
70215   if (!arg3) {
70216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70217     return ;
70218   }
70219   arg4 = (Dali::Vector3 *)jarg4;
70220   if (!arg4) {
70221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70222     return ;
70223   }
70224   {
70225     try {
70226       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
70227     } catch (std::out_of_range& e) {
70228       {
70229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70230       };
70231     } catch (std::exception& e) {
70232       {
70233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70234       };
70235     } catch (...) {
70236       {
70237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70238       };
70239     }
70240   }
70241 }
70242
70243
70244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
70245   void * jresult ;
70246   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70247   Dali::Degree result;
70248
70249   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70250   {
70251     try {
70252       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
70253     } catch (std::out_of_range& e) {
70254       {
70255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70256       };
70257     } catch (std::exception& e) {
70258       {
70259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70260       };
70261     } catch (...) {
70262       {
70263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70264       };
70265     }
70266   }
70267   jresult = new Dali::Degree((const Dali::Degree &)result);
70268   return jresult;
70269 }
70270
70271
70272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
70273   float jresult ;
70274   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70275   float result;
70276
70277   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70278   {
70279     try {
70280       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
70281     } catch (std::out_of_range& e) {
70282       {
70283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70284       };
70285     } catch (std::exception& e) {
70286       {
70287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70288       };
70289     } catch (...) {
70290       {
70291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70292       };
70293     }
70294   }
70295   jresult = result;
70296   return jresult;
70297 }
70298
70299
70300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
70301   float jresult ;
70302   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70303   float result;
70304
70305   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70306   {
70307     try {
70308       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
70309     } catch (std::out_of_range& e) {
70310       {
70311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70312       };
70313     } catch (std::exception& e) {
70314       {
70315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70316       };
70317     } catch (...) {
70318       {
70319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70320       };
70321     }
70322   }
70323   jresult = result;
70324   return jresult;
70325 }
70326
70327
70328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70329   float jresult ;
70330   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70331   float result;
70332
70333   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70334   {
70335     try {
70336       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70337     } catch (std::out_of_range& e) {
70338       {
70339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70340       };
70341     } catch (std::exception& e) {
70342       {
70343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70344       };
70345     } catch (...) {
70346       {
70347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70348       };
70349     }
70350   }
70351   jresult = result;
70352   return jresult;
70353 }
70354
70355
70356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70357   int jresult ;
70358   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70359   int arg2 ;
70360   int arg3 ;
70361   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70362   bool arg5 ;
70363   int result;
70364
70365   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70366   arg2 = (int)jarg2;
70367   arg3 = (int)jarg3;
70368   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70369   arg5 = jarg5 ? true : false;
70370   {
70371     try {
70372       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70373     } catch (std::out_of_range& e) {
70374       {
70375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70376       };
70377     } catch (std::exception& e) {
70378       {
70379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70380       };
70381     } catch (...) {
70382       {
70383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70384       };
70385     }
70386   }
70387   jresult = result;
70388   return jresult;
70389 }
70390
70391
70392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70393   float jresult ;
70394   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70395   float result;
70396
70397   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70398   {
70399     try {
70400       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70401     } catch (std::out_of_range& e) {
70402       {
70403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70404       };
70405     } catch (std::exception& e) {
70406       {
70407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70408       };
70409     } catch (...) {
70410       {
70411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70412       };
70413     }
70414   }
70415   jresult = result;
70416   return jresult;
70417 }
70418
70419
70420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70421   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70422   Dali::Actor *arg2 = 0 ;
70423   int arg3 ;
70424   Dali::Vector3 *arg4 = 0 ;
70425   Dali::Actor *arg5 = 0 ;
70426
70427   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70428   arg2 = (Dali::Actor *)jarg2;
70429   if (!arg2) {
70430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70431     return ;
70432   }
70433   arg3 = (int)jarg3;
70434   arg4 = (Dali::Vector3 *)jarg4;
70435   if (!arg4) {
70436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70437     return ;
70438   }
70439   arg5 = (Dali::Actor *)jarg5;
70440   if (!arg5) {
70441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70442     return ;
70443   }
70444   {
70445     try {
70446       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70447     } catch (std::out_of_range& e) {
70448       {
70449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70450       };
70451     } catch (std::exception& e) {
70452       {
70453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70454       };
70455     } catch (...) {
70456       {
70457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70458       };
70459     }
70460   }
70461 }
70462
70463
70464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70465   void * jresult ;
70466   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70467   int arg2 ;
70468   float arg3 ;
70469   Dali::Vector3 *arg4 = 0 ;
70470   Dali::Vector3 result;
70471
70472   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70473   arg2 = (int)jarg2;
70474   arg3 = (float)jarg3;
70475   arg4 = (Dali::Vector3 *)jarg4;
70476   if (!arg4) {
70477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70478     return 0;
70479   }
70480   {
70481     try {
70482       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70483     } catch (std::out_of_range& e) {
70484       {
70485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70486       };
70487     } catch (std::exception& e) {
70488       {
70489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70490       };
70491     } catch (...) {
70492       {
70493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70494       };
70495     }
70496   }
70497   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70498   return jresult;
70499 }
70500
70501
70502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70503   void * jresult ;
70504   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70505   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70506
70507   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70508   {
70509     try {
70510       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70511     } catch (std::out_of_range& e) {
70512       {
70513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70514       };
70515     } catch (std::exception& e) {
70516       {
70517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70518       };
70519     } catch (...) {
70520       {
70521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70522       };
70523     }
70524   }
70525   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70526   return jresult;
70527 }
70528
70529
70530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70531   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70532
70533   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70534   {
70535     try {
70536       delete arg1;
70537     } catch (std::out_of_range& e) {
70538       {
70539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70540       };
70541     } catch (std::exception& e) {
70542       {
70543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70544       };
70545     } catch (...) {
70546       {
70547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70548       };
70549     }
70550   }
70551 }
70552
70553
70554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70555   unsigned int jresult ;
70556   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70557   unsigned int result;
70558
70559   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70560   {
70561     try {
70562       result = (unsigned int)(arg1)->GetNumberOfItems();
70563     } catch (std::out_of_range& e) {
70564       {
70565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70566       };
70567     } catch (std::exception& e) {
70568       {
70569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70570       };
70571     } catch (...) {
70572       {
70573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70574       };
70575     }
70576   }
70577   jresult = result;
70578   return jresult;
70579 }
70580
70581
70582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70583   void * jresult ;
70584   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70585   unsigned int arg2 ;
70586   Dali::Actor result;
70587
70588   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70589   arg2 = (unsigned int)jarg2;
70590   {
70591     try {
70592       result = (arg1)->NewItem(arg2);
70593     } catch (std::out_of_range& e) {
70594       {
70595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70596       };
70597     } catch (std::exception& e) {
70598       {
70599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70600       };
70601     } catch (...) {
70602       {
70603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70604       };
70605     }
70606   }
70607   jresult = new Dali::Actor((const Dali::Actor &)result);
70608   return jresult;
70609 }
70610
70611
70612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70613   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70614   unsigned int arg2 ;
70615   Dali::Actor arg3 ;
70616   Dali::Actor *argp3 ;
70617
70618   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70619   arg2 = (unsigned int)jarg2;
70620   argp3 = (Dali::Actor *)jarg3;
70621   if (!argp3) {
70622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70623     return ;
70624   }
70625   arg3 = *argp3;
70626   {
70627     try {
70628       (arg1)->ItemReleased(arg2,arg3);
70629     } catch (std::out_of_range& e) {
70630       {
70631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70632       };
70633     } catch (std::exception& e) {
70634       {
70635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70636       };
70637     } catch (...) {
70638       {
70639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70640       };
70641     }
70642   }
70643 }
70644
70645
70646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70647   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70648   unsigned int arg2 ;
70649   Dali::Actor arg3 ;
70650   Dali::Actor *argp3 ;
70651
70652   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70653   arg2 = (unsigned int)jarg2;
70654   argp3 = (Dali::Actor *)jarg3;
70655   if (!argp3) {
70656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70657     return ;
70658   }
70659   arg3 = *argp3;
70660   {
70661     try {
70662       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70663     } catch (std::out_of_range& e) {
70664       {
70665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70666       };
70667     } catch (std::exception& e) {
70668       {
70669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70670       };
70671     } catch (...) {
70672       {
70673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70674       };
70675     }
70676   }
70677 }
70678
70679
70680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70681   void * jresult ;
70682   Dali::Toolkit::ItemFactory *result = 0 ;
70683
70684   {
70685     try {
70686       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70687     } catch (std::out_of_range& e) {
70688       {
70689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70690       };
70691     } catch (std::exception& e) {
70692       {
70693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70694       };
70695     } catch (...) {
70696       {
70697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70698       };
70699     }
70700   }
70701   jresult = (void *)result;
70702   return jresult;
70703 }
70704
70705
70706 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) {
70707   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70708   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70709   if (director) {
70710     director->swig_connect_director(callback0, callback1, callback2);
70711   }
70712 }
70713
70714
70715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70716   int jresult ;
70717   int result;
70718
70719   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70720   jresult = (int)result;
70721   return jresult;
70722 }
70723
70724
70725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70726   int jresult ;
70727   int result;
70728
70729   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70730   jresult = (int)result;
70731   return jresult;
70732 }
70733
70734
70735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70736   int jresult ;
70737   int result;
70738
70739   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70740   jresult = (int)result;
70741   return jresult;
70742 }
70743
70744
70745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70746   int jresult ;
70747   int result;
70748
70749   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70750   jresult = (int)result;
70751   return jresult;
70752 }
70753
70754
70755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70756   int jresult ;
70757   int result;
70758
70759   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70760   jresult = (int)result;
70761   return jresult;
70762 }
70763
70764
70765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70766   int jresult ;
70767   int result;
70768
70769   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70770   jresult = (int)result;
70771   return jresult;
70772 }
70773
70774
70775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70776   int jresult ;
70777   int result;
70778
70779   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70780   jresult = (int)result;
70781   return jresult;
70782 }
70783
70784
70785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70786   int jresult ;
70787   int result;
70788
70789   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70790   jresult = (int)result;
70791   return jresult;
70792 }
70793
70794
70795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70796   int jresult ;
70797   int result;
70798
70799   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70800   jresult = (int)result;
70801   return jresult;
70802 }
70803
70804
70805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70806   int jresult ;
70807   int result;
70808
70809   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70810   jresult = (int)result;
70811   return jresult;
70812 }
70813
70814
70815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70816   int jresult ;
70817   int result;
70818
70819   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70820   jresult = (int)result;
70821   return jresult;
70822 }
70823
70824
70825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70826   void * jresult ;
70827   Dali::Toolkit::ItemView::Property *result = 0 ;
70828
70829   {
70830     try {
70831       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70832     } catch (std::out_of_range& e) {
70833       {
70834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70835       };
70836     } catch (std::exception& e) {
70837       {
70838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70839       };
70840     } catch (...) {
70841       {
70842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70843       };
70844     }
70845   }
70846   jresult = (void *)result;
70847   return jresult;
70848 }
70849
70850
70851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70852   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70853
70854   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70855   {
70856     try {
70857       delete arg1;
70858     } catch (std::out_of_range& e) {
70859       {
70860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70861       };
70862     } catch (std::exception& e) {
70863       {
70864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70865       };
70866     } catch (...) {
70867       {
70868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70869       };
70870     }
70871   }
70872 }
70873
70874
70875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70876   void * jresult ;
70877   Dali::Toolkit::ItemView *result = 0 ;
70878
70879   {
70880     try {
70881       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70882     } catch (std::out_of_range& e) {
70883       {
70884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70885       };
70886     } catch (std::exception& e) {
70887       {
70888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70889       };
70890     } catch (...) {
70891       {
70892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70893       };
70894     }
70895   }
70896   jresult = (void *)result;
70897   return jresult;
70898 }
70899
70900
70901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70902   void * jresult ;
70903   Dali::Toolkit::ItemView *arg1 = 0 ;
70904   Dali::Toolkit::ItemView *result = 0 ;
70905
70906   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70907   if (!arg1) {
70908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70909     return 0;
70910   }
70911   {
70912     try {
70913       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70914     } catch (std::out_of_range& e) {
70915       {
70916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70917       };
70918     } catch (std::exception& e) {
70919       {
70920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70921       };
70922     } catch (...) {
70923       {
70924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70925       };
70926     }
70927   }
70928   jresult = (void *)result;
70929   return jresult;
70930 }
70931
70932
70933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70934   void * jresult ;
70935   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70936   Dali::Toolkit::ItemView *arg2 = 0 ;
70937   Dali::Toolkit::ItemView *result = 0 ;
70938
70939   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70940   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70941   if (!arg2) {
70942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70943     return 0;
70944   }
70945   {
70946     try {
70947       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70948     } catch (std::out_of_range& e) {
70949       {
70950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70951       };
70952     } catch (std::exception& e) {
70953       {
70954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70955       };
70956     } catch (...) {
70957       {
70958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70959       };
70960     }
70961   }
70962   jresult = (void *)result;
70963   return jresult;
70964 }
70965
70966
70967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70968   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70969
70970   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70971   {
70972     try {
70973       delete arg1;
70974     } catch (std::out_of_range& e) {
70975       {
70976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70977       };
70978     } catch (std::exception& e) {
70979       {
70980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70981       };
70982     } catch (...) {
70983       {
70984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70985       };
70986     }
70987   }
70988 }
70989
70990
70991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70992   void * jresult ;
70993   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70994   Dali::Toolkit::ItemView result;
70995
70996   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70997   if (!arg1) {
70998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70999     return 0;
71000   }
71001   {
71002     try {
71003       result = Dali::Toolkit::ItemView::New(*arg1);
71004     } catch (std::out_of_range& e) {
71005       {
71006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71007       };
71008     } catch (std::exception& e) {
71009       {
71010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71011       };
71012     } catch (...) {
71013       {
71014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71015       };
71016     }
71017   }
71018   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
71019   return jresult;
71020 }
71021
71022
71023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
71024   void * jresult ;
71025   Dali::BaseHandle arg1 ;
71026   Dali::BaseHandle *argp1 ;
71027   Dali::Toolkit::ItemView result;
71028
71029   argp1 = (Dali::BaseHandle *)jarg1;
71030   if (!argp1) {
71031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71032     return 0;
71033   }
71034   arg1 = *argp1;
71035   {
71036     try {
71037       result = Dali::Toolkit::ItemView::DownCast(arg1);
71038     } catch (std::out_of_range& e) {
71039       {
71040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71041       };
71042     } catch (std::exception& e) {
71043       {
71044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71045       };
71046     } catch (...) {
71047       {
71048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71049       };
71050     }
71051   }
71052   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
71053   return jresult;
71054 }
71055
71056
71057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
71058   unsigned int jresult ;
71059   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71060   unsigned int result;
71061
71062   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71063   {
71064     try {
71065       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
71066     } catch (std::out_of_range& e) {
71067       {
71068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71069       };
71070     } catch (std::exception& e) {
71071       {
71072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71073       };
71074     } catch (...) {
71075       {
71076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71077       };
71078     }
71079   }
71080   jresult = result;
71081   return jresult;
71082 }
71083
71084
71085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
71086   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71087   Dali::Toolkit::ItemLayout *arg2 = 0 ;
71088
71089   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71090   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
71091   if (!arg2) {
71092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
71093     return ;
71094   }
71095   {
71096     try {
71097       (arg1)->AddLayout(*arg2);
71098     } catch (std::out_of_range& e) {
71099       {
71100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71101       };
71102     } catch (std::exception& e) {
71103       {
71104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71105       };
71106     } catch (...) {
71107       {
71108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71109       };
71110     }
71111   }
71112 }
71113
71114
71115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
71116   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71117   unsigned int arg2 ;
71118
71119   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71120   arg2 = (unsigned int)jarg2;
71121   {
71122     try {
71123       (arg1)->RemoveLayout(arg2);
71124     } catch (std::out_of_range& e) {
71125       {
71126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71127       };
71128     } catch (std::exception& e) {
71129       {
71130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71131       };
71132     } catch (...) {
71133       {
71134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71135       };
71136     }
71137   }
71138 }
71139
71140
71141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
71142   void * jresult ;
71143   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71144   unsigned int arg2 ;
71145   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71146
71147   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71148   arg2 = (unsigned int)jarg2;
71149   {
71150     try {
71151       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
71152     } catch (std::out_of_range& e) {
71153       {
71154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71155       };
71156     } catch (std::exception& e) {
71157       {
71158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71159       };
71160     } catch (...) {
71161       {
71162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71163       };
71164     }
71165   }
71166   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71167   return jresult;
71168 }
71169
71170
71171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
71172   void * jresult ;
71173   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71174   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71175
71176   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71177   {
71178     try {
71179       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
71180     } catch (std::out_of_range& e) {
71181       {
71182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71183       };
71184     } catch (std::exception& e) {
71185       {
71186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71187       };
71188     } catch (...) {
71189       {
71190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71191       };
71192     }
71193   }
71194   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71195   return jresult;
71196 }
71197
71198
71199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
71200   float jresult ;
71201   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71202   Dali::Toolkit::ItemId arg2 ;
71203   float result;
71204
71205   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71206   arg2 = (Dali::Toolkit::ItemId)jarg2;
71207   {
71208     try {
71209       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71210     } catch (std::out_of_range& e) {
71211       {
71212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71213       };
71214     } catch (std::exception& e) {
71215       {
71216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71217       };
71218     } catch (...) {
71219       {
71220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71221       };
71222     }
71223   }
71224   jresult = result;
71225   return jresult;
71226 }
71227
71228
71229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71230   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71231   unsigned int arg2 ;
71232   Dali::Vector3 arg3 ;
71233   float arg4 ;
71234   Dali::Vector3 *argp3 ;
71235
71236   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71237   arg2 = (unsigned int)jarg2;
71238   argp3 = (Dali::Vector3 *)jarg3;
71239   if (!argp3) {
71240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71241     return ;
71242   }
71243   arg3 = *argp3;
71244   arg4 = (float)jarg4;
71245   {
71246     try {
71247       (arg1)->ActivateLayout(arg2,arg3,arg4);
71248     } catch (std::out_of_range& e) {
71249       {
71250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71251       };
71252     } catch (std::exception& e) {
71253       {
71254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71255       };
71256     } catch (...) {
71257       {
71258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71259       };
71260     }
71261   }
71262 }
71263
71264
71265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71266   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71267
71268   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71269   {
71270     try {
71271       (arg1)->DeactivateCurrentLayout();
71272     } catch (std::out_of_range& e) {
71273       {
71274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71275       };
71276     } catch (std::exception& e) {
71277       {
71278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71279       };
71280     } catch (...) {
71281       {
71282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71283       };
71284     }
71285   }
71286 }
71287
71288
71289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71290   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71291   float arg2 ;
71292
71293   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71294   arg2 = (float)jarg2;
71295   {
71296     try {
71297       (arg1)->SetMinimumSwipeSpeed(arg2);
71298     } catch (std::out_of_range& e) {
71299       {
71300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71301       };
71302     } catch (std::exception& e) {
71303       {
71304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71305       };
71306     } catch (...) {
71307       {
71308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71309       };
71310     }
71311   }
71312 }
71313
71314
71315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71316   float jresult ;
71317   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71318   float result;
71319
71320   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71321   {
71322     try {
71323       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71324     } catch (std::out_of_range& e) {
71325       {
71326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71327       };
71328     } catch (std::exception& e) {
71329       {
71330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71331       };
71332     } catch (...) {
71333       {
71334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71335       };
71336     }
71337   }
71338   jresult = result;
71339   return jresult;
71340 }
71341
71342
71343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71344   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71345   float arg2 ;
71346
71347   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71348   arg2 = (float)jarg2;
71349   {
71350     try {
71351       (arg1)->SetMinimumSwipeDistance(arg2);
71352     } catch (std::out_of_range& e) {
71353       {
71354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71355       };
71356     } catch (std::exception& e) {
71357       {
71358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71359       };
71360     } catch (...) {
71361       {
71362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71363       };
71364     }
71365   }
71366 }
71367
71368
71369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71370   float jresult ;
71371   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71372   float result;
71373
71374   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71375   {
71376     try {
71377       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71378     } catch (std::out_of_range& e) {
71379       {
71380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71381       };
71382     } catch (std::exception& e) {
71383       {
71384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71385       };
71386     } catch (...) {
71387       {
71388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71389       };
71390     }
71391   }
71392   jresult = result;
71393   return jresult;
71394 }
71395
71396
71397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71398   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71399   float arg2 ;
71400
71401   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71402   arg2 = (float)jarg2;
71403   {
71404     try {
71405       (arg1)->SetWheelScrollDistanceStep(arg2);
71406     } catch (std::out_of_range& e) {
71407       {
71408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71409       };
71410     } catch (std::exception& e) {
71411       {
71412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71413       };
71414     } catch (...) {
71415       {
71416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71417       };
71418     }
71419   }
71420 }
71421
71422
71423 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71424   float jresult ;
71425   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71426   float result;
71427
71428   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71429   {
71430     try {
71431       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71432     } catch (std::out_of_range& e) {
71433       {
71434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71435       };
71436     } catch (std::exception& e) {
71437       {
71438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71439       };
71440     } catch (...) {
71441       {
71442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71443       };
71444     }
71445   }
71446   jresult = result;
71447   return jresult;
71448 }
71449
71450
71451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71452   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71453   bool arg2 ;
71454
71455   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71456   arg2 = jarg2 ? true : false;
71457   {
71458     try {
71459       (arg1)->SetAnchoring(arg2);
71460     } catch (std::out_of_range& e) {
71461       {
71462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71463       };
71464     } catch (std::exception& e) {
71465       {
71466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71467       };
71468     } catch (...) {
71469       {
71470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71471       };
71472     }
71473   }
71474 }
71475
71476
71477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71478   unsigned int jresult ;
71479   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71480   bool result;
71481
71482   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71483   {
71484     try {
71485       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71486     } catch (std::out_of_range& e) {
71487       {
71488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71489       };
71490     } catch (std::exception& e) {
71491       {
71492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71493       };
71494     } catch (...) {
71495       {
71496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71497       };
71498     }
71499   }
71500   jresult = result;
71501   return jresult;
71502 }
71503
71504
71505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71506   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71507   float arg2 ;
71508
71509   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71510   arg2 = (float)jarg2;
71511   {
71512     try {
71513       (arg1)->SetAnchoringDuration(arg2);
71514     } catch (std::out_of_range& e) {
71515       {
71516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71517       };
71518     } catch (std::exception& e) {
71519       {
71520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71521       };
71522     } catch (...) {
71523       {
71524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71525       };
71526     }
71527   }
71528 }
71529
71530
71531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71532   float jresult ;
71533   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71534   float result;
71535
71536   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71537   {
71538     try {
71539       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71540     } catch (std::out_of_range& e) {
71541       {
71542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71543       };
71544     } catch (std::exception& e) {
71545       {
71546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71547       };
71548     } catch (...) {
71549       {
71550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71551       };
71552     }
71553   }
71554   jresult = result;
71555   return jresult;
71556 }
71557
71558
71559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71560   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71561   Dali::Toolkit::ItemId arg2 ;
71562   float arg3 ;
71563
71564   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71565   arg2 = (Dali::Toolkit::ItemId)jarg2;
71566   arg3 = (float)jarg3;
71567   {
71568     try {
71569       (arg1)->ScrollToItem(arg2,arg3);
71570     } catch (std::out_of_range& e) {
71571       {
71572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71573       };
71574     } catch (std::exception& e) {
71575       {
71576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71577       };
71578     } catch (...) {
71579       {
71580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71581       };
71582     }
71583   }
71584 }
71585
71586
71587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71588   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71589   float arg2 ;
71590
71591   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71592   arg2 = (float)jarg2;
71593   {
71594     try {
71595       (arg1)->SetRefreshInterval(arg2);
71596     } catch (std::out_of_range& e) {
71597       {
71598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71599       };
71600     } catch (std::exception& e) {
71601       {
71602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71603       };
71604     } catch (...) {
71605       {
71606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71607       };
71608     }
71609   }
71610 }
71611
71612
71613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71614   float jresult ;
71615   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71616   float result;
71617
71618   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71619   {
71620     try {
71621       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71622     } catch (std::out_of_range& e) {
71623       {
71624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71625       };
71626     } catch (std::exception& e) {
71627       {
71628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71629       };
71630     } catch (...) {
71631       {
71632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71633       };
71634     }
71635   }
71636   jresult = result;
71637   return jresult;
71638 }
71639
71640
71641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71642   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71643
71644   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71645   {
71646     try {
71647       (arg1)->Refresh();
71648     } catch (std::out_of_range& e) {
71649       {
71650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71651       };
71652     } catch (std::exception& e) {
71653       {
71654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71655       };
71656     } catch (...) {
71657       {
71658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71659       };
71660     }
71661   }
71662 }
71663
71664
71665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71666   void * jresult ;
71667   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71668   Dali::Toolkit::ItemId arg2 ;
71669   Dali::Actor result;
71670
71671   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71672   arg2 = (Dali::Toolkit::ItemId)jarg2;
71673   {
71674     try {
71675       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71676     } catch (std::out_of_range& e) {
71677       {
71678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71679       };
71680     } catch (std::exception& e) {
71681       {
71682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71683       };
71684     } catch (...) {
71685       {
71686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71687       };
71688     }
71689   }
71690   jresult = new Dali::Actor((const Dali::Actor &)result);
71691   return jresult;
71692 }
71693
71694
71695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71696   unsigned int jresult ;
71697   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71698   Dali::Actor arg2 ;
71699   Dali::Actor *argp2 ;
71700   Dali::Toolkit::ItemId result;
71701
71702   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71703   argp2 = (Dali::Actor *)jarg2;
71704   if (!argp2) {
71705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71706     return 0;
71707   }
71708   arg2 = *argp2;
71709   {
71710     try {
71711       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71712     } catch (std::out_of_range& e) {
71713       {
71714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71715       };
71716     } catch (std::exception& e) {
71717       {
71718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71719       };
71720     } catch (...) {
71721       {
71722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71723       };
71724     }
71725   }
71726   jresult = result;
71727   return jresult;
71728 }
71729
71730
71731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71732   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71733   Dali::Toolkit::Item arg2 ;
71734   float arg3 ;
71735   Dali::Toolkit::Item *argp2 ;
71736
71737   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71738   argp2 = (Dali::Toolkit::Item *)jarg2;
71739   if (!argp2) {
71740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71741     return ;
71742   }
71743   arg2 = *argp2;
71744   arg3 = (float)jarg3;
71745   {
71746     try {
71747       (arg1)->InsertItem(arg2,arg3);
71748     } catch (std::out_of_range& e) {
71749       {
71750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71751       };
71752     } catch (std::exception& e) {
71753       {
71754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71755       };
71756     } catch (...) {
71757       {
71758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71759       };
71760     }
71761   }
71762 }
71763
71764
71765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71766   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71767   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71768   float arg3 ;
71769
71770   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71771   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71772   if (!arg2) {
71773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71774     return ;
71775   }
71776   arg3 = (float)jarg3;
71777   {
71778     try {
71779       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71780     } catch (std::out_of_range& e) {
71781       {
71782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71783       };
71784     } catch (std::exception& e) {
71785       {
71786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71787       };
71788     } catch (...) {
71789       {
71790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71791       };
71792     }
71793   }
71794 }
71795
71796
71797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71798   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71799   Dali::Toolkit::ItemId arg2 ;
71800   float arg3 ;
71801
71802   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71803   arg2 = (Dali::Toolkit::ItemId)jarg2;
71804   arg3 = (float)jarg3;
71805   {
71806     try {
71807       (arg1)->RemoveItem(arg2,arg3);
71808     } catch (std::out_of_range& e) {
71809       {
71810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71811       };
71812     } catch (std::exception& e) {
71813       {
71814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71815       };
71816     } catch (...) {
71817       {
71818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71819       };
71820     }
71821   }
71822 }
71823
71824
71825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71826   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71827   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71828   float arg3 ;
71829
71830   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71831   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71832   if (!arg2) {
71833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71834     return ;
71835   }
71836   arg3 = (float)jarg3;
71837   {
71838     try {
71839       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71840     } catch (std::out_of_range& e) {
71841       {
71842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71843       };
71844     } catch (std::exception& e) {
71845       {
71846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71847       };
71848     } catch (...) {
71849       {
71850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71851       };
71852     }
71853   }
71854 }
71855
71856
71857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71858   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71859   Dali::Toolkit::Item arg2 ;
71860   float arg3 ;
71861   Dali::Toolkit::Item *argp2 ;
71862
71863   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71864   argp2 = (Dali::Toolkit::Item *)jarg2;
71865   if (!argp2) {
71866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71867     return ;
71868   }
71869   arg2 = *argp2;
71870   arg3 = (float)jarg3;
71871   {
71872     try {
71873       (arg1)->ReplaceItem(arg2,arg3);
71874     } catch (std::out_of_range& e) {
71875       {
71876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71877       };
71878     } catch (std::exception& e) {
71879       {
71880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71881       };
71882     } catch (...) {
71883       {
71884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71885       };
71886     }
71887   }
71888 }
71889
71890
71891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71892   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71893   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71894   float arg3 ;
71895
71896   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71897   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71898   if (!arg2) {
71899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71900     return ;
71901   }
71902   arg3 = (float)jarg3;
71903   {
71904     try {
71905       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71906     } catch (std::out_of_range& e) {
71907       {
71908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71909       };
71910     } catch (std::exception& e) {
71911       {
71912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71913       };
71914     } catch (...) {
71915       {
71916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71917       };
71918     }
71919   }
71920 }
71921
71922
71923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71924   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71925   Dali::Vector3 *arg2 = 0 ;
71926
71927   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71928   arg2 = (Dali::Vector3 *)jarg2;
71929   if (!arg2) {
71930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71931     return ;
71932   }
71933   {
71934     try {
71935       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71936     } catch (std::out_of_range& e) {
71937       {
71938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71939       };
71940     } catch (std::exception& e) {
71941       {
71942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71943       };
71944     } catch (...) {
71945       {
71946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71947       };
71948     }
71949   }
71950 }
71951
71952
71953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71954   void * jresult ;
71955   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71956   Dali::Vector3 result;
71957
71958   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71959   {
71960     try {
71961       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71962     } catch (std::out_of_range& e) {
71963       {
71964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71965       };
71966     } catch (std::exception& e) {
71967       {
71968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71969       };
71970     } catch (...) {
71971       {
71972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71973       };
71974     }
71975   }
71976   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71977   return jresult;
71978 }
71979
71980
71981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71982   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71983   Dali::Vector3 *arg2 = 0 ;
71984
71985   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71986   arg2 = (Dali::Vector3 *)jarg2;
71987   if (!arg2) {
71988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71989     return ;
71990   }
71991   {
71992     try {
71993       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71994     } catch (std::out_of_range& e) {
71995       {
71996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71997       };
71998     } catch (std::exception& e) {
71999       {
72000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72001       };
72002     } catch (...) {
72003       {
72004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72005       };
72006     }
72007   }
72008 }
72009
72010
72011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
72012   void * jresult ;
72013   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72014   Dali::Vector3 result;
72015
72016   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72017   {
72018     try {
72019       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
72020     } catch (std::out_of_range& e) {
72021       {
72022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72023       };
72024     } catch (std::exception& e) {
72025       {
72026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72027       };
72028     } catch (...) {
72029       {
72030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72031       };
72032     }
72033   }
72034   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
72035   return jresult;
72036 }
72037
72038
72039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
72040   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72041   Dali::Toolkit::ItemRange *arg2 = 0 ;
72042
72043   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72044   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
72045   if (!arg2) {
72046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
72047     return ;
72048   }
72049   {
72050     try {
72051       (arg1)->GetItemsRange(*arg2);
72052     } catch (std::out_of_range& e) {
72053       {
72054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72055       };
72056     } catch (std::exception& e) {
72057       {
72058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72059       };
72060     } catch (...) {
72061       {
72062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72063       };
72064     }
72065   }
72066 }
72067
72068
72069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
72070   void * jresult ;
72071   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72072   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
72073
72074   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72075   {
72076     try {
72077       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
72078     } catch (std::out_of_range& e) {
72079       {
72080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72081       };
72082     } catch (std::exception& e) {
72083       {
72084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72085       };
72086     } catch (...) {
72087       {
72088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72089       };
72090     }
72091   }
72092   jresult = (void *)result;
72093   return jresult;
72094 }
72095
72096
72097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
72098   Dali::Vector3 *arg1 = 0 ;
72099   PropertyInputContainer *arg2 = 0 ;
72100
72101   arg1 = (Dali::Vector3 *)jarg1;
72102   if (!arg1) {
72103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72104     return ;
72105   }
72106   arg2 = (PropertyInputContainer *)jarg2;
72107   if (!arg2) {
72108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72109     return ;
72110   }
72111   {
72112     try {
72113       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72114     } catch (std::out_of_range& e) {
72115       {
72116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72117       };
72118     } catch (std::exception& e) {
72119       {
72120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72121       };
72122     } catch (...) {
72123       {
72124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72125       };
72126     }
72127   }
72128 }
72129
72130
72131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
72132   Dali::Vector3 *arg1 = 0 ;
72133   PropertyInputContainer *arg2 = 0 ;
72134
72135   arg1 = (Dali::Vector3 *)jarg1;
72136   if (!arg1) {
72137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72138     return ;
72139   }
72140   arg2 = (PropertyInputContainer *)jarg2;
72141   if (!arg2) {
72142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72143     return ;
72144   }
72145   {
72146     try {
72147       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72148     } catch (std::out_of_range& e) {
72149       {
72150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72151       };
72152     } catch (std::exception& e) {
72153       {
72154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72155       };
72156     } catch (...) {
72157       {
72158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72159       };
72160     }
72161   }
72162 }
72163
72164
72165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72166   void * jresult ;
72167   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72168
72169   {
72170     try {
72171       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72172     } catch (std::out_of_range& e) {
72173       {
72174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72175       };
72176     } catch (std::exception& e) {
72177       {
72178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72179       };
72180     } catch (...) {
72181       {
72182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72183       };
72184     }
72185   }
72186   jresult = (void *)result;
72187   return jresult;
72188 }
72189
72190
72191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72192   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72193
72194   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72195   {
72196     try {
72197       delete arg1;
72198     } catch (std::out_of_range& e) {
72199       {
72200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72201       };
72202     } catch (std::exception& e) {
72203       {
72204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72205       };
72206     } catch (...) {
72207       {
72208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72209       };
72210     }
72211   }
72212 }
72213
72214
72215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72216   void * jresult ;
72217   Dali::Path arg1 ;
72218   Dali::Vector3 *arg2 = 0 ;
72219   Dali::Property::Index arg3 ;
72220   Dali::Vector3 *arg4 = 0 ;
72221   unsigned int arg5 ;
72222   Dali::Path *argp1 ;
72223   Dali::Toolkit::ScrollViewPagePathEffect result;
72224
72225   argp1 = (Dali::Path *)jarg1;
72226   if (!argp1) {
72227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72228     return 0;
72229   }
72230   arg1 = *argp1;
72231   arg2 = (Dali::Vector3 *)jarg2;
72232   if (!arg2) {
72233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72234     return 0;
72235   }
72236   arg3 = (Dali::Property::Index)jarg3;
72237   arg4 = (Dali::Vector3 *)jarg4;
72238   if (!arg4) {
72239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72240     return 0;
72241   }
72242   arg5 = (unsigned int)jarg5;
72243   {
72244     try {
72245       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72246     } catch (std::out_of_range& e) {
72247       {
72248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72249       };
72250     } catch (std::exception& e) {
72251       {
72252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72253       };
72254     } catch (...) {
72255       {
72256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72257       };
72258     }
72259   }
72260   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72261   return jresult;
72262 }
72263
72264
72265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72266   void * jresult ;
72267   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72268
72269   {
72270     try {
72271       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72272     } catch (std::out_of_range& e) {
72273       {
72274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72275       };
72276     } catch (std::exception& e) {
72277       {
72278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72279       };
72280     } catch (...) {
72281       {
72282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72283       };
72284     }
72285   }
72286   jresult = (void *)result;
72287   return jresult;
72288 }
72289
72290
72291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72292   void * jresult ;
72293   Dali::BaseHandle arg1 ;
72294   Dali::BaseHandle *argp1 ;
72295   Dali::Toolkit::ScrollViewPagePathEffect result;
72296
72297   argp1 = (Dali::BaseHandle *)jarg1;
72298   if (!argp1) {
72299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72300     return 0;
72301   }
72302   arg1 = *argp1;
72303   {
72304     try {
72305       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72306     } catch (std::out_of_range& e) {
72307       {
72308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72309       };
72310     } catch (std::exception& e) {
72311       {
72312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72313       };
72314     } catch (...) {
72315       {
72316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72317       };
72318     }
72319   }
72320   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72321   return jresult;
72322 }
72323
72324
72325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72326   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72327   Dali::Actor arg2 ;
72328   unsigned int arg3 ;
72329   Dali::Actor *argp2 ;
72330
72331   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72332   argp2 = (Dali::Actor *)jarg2;
72333   if (!argp2) {
72334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72335     return ;
72336   }
72337   arg2 = *argp2;
72338   arg3 = (unsigned int)jarg3;
72339   {
72340     try {
72341       (arg1)->ApplyToPage(arg2,arg3);
72342     } catch (std::out_of_range& e) {
72343       {
72344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72345       };
72346     } catch (std::exception& e) {
72347       {
72348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72349       };
72350     } catch (...) {
72351       {
72352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72353       };
72354     }
72355   }
72356 }
72357
72358
72359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72360   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72361
72362   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72363   {
72364     try {
72365       delete arg1;
72366     } catch (std::out_of_range& e) {
72367       {
72368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72369       };
72370     } catch (std::exception& e) {
72371       {
72372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72373       };
72374     } catch (...) {
72375       {
72376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72377       };
72378     }
72379   }
72380 }
72381
72382
72383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72384   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72385   Dali::Toolkit::ClampState arg2 ;
72386
72387   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72388   arg2 = (Dali::Toolkit::ClampState)jarg2;
72389   if (arg1) (arg1)->x = arg2;
72390 }
72391
72392
72393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72394   int jresult ;
72395   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72396   Dali::Toolkit::ClampState result;
72397
72398   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72399   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72400   jresult = (int)result;
72401   return jresult;
72402 }
72403
72404
72405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72406   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72407   Dali::Toolkit::ClampState arg2 ;
72408
72409   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72410   arg2 = (Dali::Toolkit::ClampState)jarg2;
72411   if (arg1) (arg1)->y = arg2;
72412 }
72413
72414
72415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72416   int jresult ;
72417   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72418   Dali::Toolkit::ClampState result;
72419
72420   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72421   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72422   jresult = (int)result;
72423   return jresult;
72424 }
72425
72426
72427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72428   void * jresult ;
72429   Dali::Toolkit::ClampState2D *result = 0 ;
72430
72431   {
72432     try {
72433       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72434     } catch (std::out_of_range& e) {
72435       {
72436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72437       };
72438     } catch (std::exception& e) {
72439       {
72440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72441       };
72442     } catch (...) {
72443       {
72444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72445       };
72446     }
72447   }
72448   jresult = (void *)result;
72449   return jresult;
72450 }
72451
72452
72453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72454   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72455
72456   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72457   {
72458     try {
72459       delete arg1;
72460     } catch (std::out_of_range& e) {
72461       {
72462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72463       };
72464     } catch (std::exception& e) {
72465       {
72466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72467       };
72468     } catch (...) {
72469       {
72470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72471       };
72472     }
72473   }
72474 }
72475
72476
72477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72478   void * jresult ;
72479   float arg1 ;
72480   float arg2 ;
72481   bool arg3 ;
72482   Dali::Toolkit::RulerDomain *result = 0 ;
72483
72484   arg1 = (float)jarg1;
72485   arg2 = (float)jarg2;
72486   arg3 = jarg3 ? true : false;
72487   {
72488     try {
72489       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72490     } catch (std::out_of_range& e) {
72491       {
72492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72493       };
72494     } catch (std::exception& e) {
72495       {
72496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72497       };
72498     } catch (...) {
72499       {
72500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72501       };
72502     }
72503   }
72504   jresult = (void *)result;
72505   return jresult;
72506 }
72507
72508
72509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72510   void * jresult ;
72511   float arg1 ;
72512   float arg2 ;
72513   Dali::Toolkit::RulerDomain *result = 0 ;
72514
72515   arg1 = (float)jarg1;
72516   arg2 = (float)jarg2;
72517   {
72518     try {
72519       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72520     } catch (std::out_of_range& e) {
72521       {
72522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72523       };
72524     } catch (std::exception& e) {
72525       {
72526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72527       };
72528     } catch (...) {
72529       {
72530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72531       };
72532     }
72533   }
72534   jresult = (void *)result;
72535   return jresult;
72536 }
72537
72538
72539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72540   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72541   float arg2 ;
72542
72543   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72544   arg2 = (float)jarg2;
72545   if (arg1) (arg1)->min = arg2;
72546 }
72547
72548
72549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72550   float jresult ;
72551   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72552   float result;
72553
72554   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72555   result = (float) ((arg1)->min);
72556   jresult = result;
72557   return jresult;
72558 }
72559
72560
72561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72562   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72563   float arg2 ;
72564
72565   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72566   arg2 = (float)jarg2;
72567   if (arg1) (arg1)->max = arg2;
72568 }
72569
72570
72571 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72572   float jresult ;
72573   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72574   float result;
72575
72576   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72577   result = (float) ((arg1)->max);
72578   jresult = result;
72579   return jresult;
72580 }
72581
72582
72583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72584   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72585   bool arg2 ;
72586
72587   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72588   arg2 = jarg2 ? true : false;
72589   if (arg1) (arg1)->enabled = arg2;
72590 }
72591
72592
72593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72594   unsigned int jresult ;
72595   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72596   bool result;
72597
72598   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72599   result = (bool) ((arg1)->enabled);
72600   jresult = result;
72601   return jresult;
72602 }
72603
72604
72605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72606   float jresult ;
72607   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72608   float arg2 ;
72609   float arg3 ;
72610   float arg4 ;
72611   float result;
72612
72613   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72614   arg2 = (float)jarg2;
72615   arg3 = (float)jarg3;
72616   arg4 = (float)jarg4;
72617   {
72618     try {
72619       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72620     } catch (std::out_of_range& e) {
72621       {
72622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72623       };
72624     } catch (std::exception& e) {
72625       {
72626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72627       };
72628     } catch (...) {
72629       {
72630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72631       };
72632     }
72633   }
72634   jresult = result;
72635   return jresult;
72636 }
72637
72638
72639 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72640   float jresult ;
72641   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72642   float arg2 ;
72643   float arg3 ;
72644   float result;
72645
72646   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72647   arg2 = (float)jarg2;
72648   arg3 = (float)jarg3;
72649   {
72650     try {
72651       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72652     } catch (std::out_of_range& e) {
72653       {
72654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72655       };
72656     } catch (std::exception& e) {
72657       {
72658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72659       };
72660     } catch (...) {
72661       {
72662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72663       };
72664     }
72665   }
72666   jresult = result;
72667   return jresult;
72668 }
72669
72670
72671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72672   float jresult ;
72673   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72674   float arg2 ;
72675   float result;
72676
72677   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72678   arg2 = (float)jarg2;
72679   {
72680     try {
72681       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72682     } catch (std::out_of_range& e) {
72683       {
72684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72685       };
72686     } catch (std::exception& e) {
72687       {
72688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72689       };
72690     } catch (...) {
72691       {
72692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72693       };
72694     }
72695   }
72696   jresult = result;
72697   return jresult;
72698 }
72699
72700
72701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72702   float jresult ;
72703   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72704   float arg2 ;
72705   float arg3 ;
72706   float arg4 ;
72707   Dali::Toolkit::ClampState *arg5 = 0 ;
72708   float result;
72709
72710   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72711   arg2 = (float)jarg2;
72712   arg3 = (float)jarg3;
72713   arg4 = (float)jarg4;
72714   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72715   if (!arg5) {
72716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72717     return 0;
72718   }
72719   {
72720     try {
72721       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72722     } catch (std::out_of_range& e) {
72723       {
72724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72725       };
72726     } catch (std::exception& e) {
72727       {
72728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72729       };
72730     } catch (...) {
72731       {
72732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72733       };
72734     }
72735   }
72736   jresult = result;
72737   return jresult;
72738 }
72739
72740
72741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72742   float jresult ;
72743   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72744   float result;
72745
72746   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72747   {
72748     try {
72749       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72750     } catch (std::out_of_range& e) {
72751       {
72752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72753       };
72754     } catch (std::exception& e) {
72755       {
72756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72757       };
72758     } catch (...) {
72759       {
72760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72761       };
72762     }
72763   }
72764   jresult = result;
72765   return jresult;
72766 }
72767
72768
72769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72770   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72771
72772   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72773   {
72774     try {
72775       delete arg1;
72776     } catch (std::out_of_range& e) {
72777       {
72778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72779       };
72780     } catch (std::exception& e) {
72781       {
72782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72783       };
72784     } catch (...) {
72785       {
72786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72787       };
72788     }
72789   }
72790 }
72791
72792
72793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72794   float jresult ;
72795   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72796   float arg2 ;
72797   float arg3 ;
72798   float result;
72799
72800   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72801   arg2 = (float)jarg2;
72802   arg3 = (float)jarg3;
72803   {
72804     try {
72805       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72806     } catch (std::out_of_range& e) {
72807       {
72808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72809       };
72810     } catch (std::exception& e) {
72811       {
72812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72813       };
72814     } catch (...) {
72815       {
72816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72817       };
72818     }
72819   }
72820   jresult = result;
72821   return jresult;
72822 }
72823
72824
72825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72826   float jresult ;
72827   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72828   float arg2 ;
72829   float result;
72830
72831   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72832   arg2 = (float)jarg2;
72833   {
72834     try {
72835       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72836     } catch (std::out_of_range& e) {
72837       {
72838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72839       };
72840     } catch (std::exception& e) {
72841       {
72842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72843       };
72844     } catch (...) {
72845       {
72846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72847       };
72848     }
72849   }
72850   jresult = result;
72851   return jresult;
72852 }
72853
72854
72855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72856   float jresult ;
72857   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72858   unsigned int arg2 ;
72859   unsigned int *arg3 = 0 ;
72860   bool arg4 ;
72861   float result;
72862
72863   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72864   arg2 = (unsigned int)jarg2;
72865   arg3 = (unsigned int *)jarg3;
72866   arg4 = jarg4 ? true : false;
72867   {
72868     try {
72869       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72870     } catch (std::out_of_range& e) {
72871       {
72872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72873       };
72874     } catch (std::exception& e) {
72875       {
72876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72877       };
72878     } catch (...) {
72879       {
72880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72881       };
72882     }
72883   }
72884   jresult = result;
72885   return jresult;
72886 }
72887
72888
72889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72890   unsigned int jresult ;
72891   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72892   float arg2 ;
72893   bool arg3 ;
72894   unsigned int result;
72895
72896   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72897   arg2 = (float)jarg2;
72898   arg3 = jarg3 ? true : false;
72899   {
72900     try {
72901       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72902     } catch (std::out_of_range& e) {
72903       {
72904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72905       };
72906     } catch (std::exception& e) {
72907       {
72908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72909       };
72910     } catch (...) {
72911       {
72912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72913       };
72914     }
72915   }
72916   jresult = result;
72917   return jresult;
72918 }
72919
72920
72921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72922   unsigned int jresult ;
72923   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72924   unsigned int result;
72925
72926   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72927   {
72928     try {
72929       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72930     } catch (std::out_of_range& e) {
72931       {
72932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72933       };
72934     } catch (std::exception& e) {
72935       {
72936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72937       };
72938     } catch (...) {
72939       {
72940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72941       };
72942     }
72943   }
72944   jresult = result;
72945   return jresult;
72946 }
72947
72948
72949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72950   int jresult ;
72951   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72952   Dali::Toolkit::Ruler::RulerType result;
72953
72954   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72955   {
72956     try {
72957       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72958     } catch (std::out_of_range& e) {
72959       {
72960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72961       };
72962     } catch (std::exception& e) {
72963       {
72964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72965       };
72966     } catch (...) {
72967       {
72968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72969       };
72970     }
72971   }
72972   jresult = (int)result;
72973   return jresult;
72974 }
72975
72976
72977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72978   unsigned int jresult ;
72979   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72980   bool result;
72981
72982   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72983   {
72984     try {
72985       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72986     } catch (std::out_of_range& e) {
72987       {
72988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72989       };
72990     } catch (std::exception& e) {
72991       {
72992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72993       };
72994     } catch (...) {
72995       {
72996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72997       };
72998     }
72999   }
73000   jresult = result;
73001   return jresult;
73002 }
73003
73004
73005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
73006   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73007
73008   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73009   {
73010     try {
73011       (arg1)->Enable();
73012     } catch (std::out_of_range& e) {
73013       {
73014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73015       };
73016     } catch (std::exception& e) {
73017       {
73018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73019       };
73020     } catch (...) {
73021       {
73022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73023       };
73024     }
73025   }
73026 }
73027
73028
73029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
73030   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73031
73032   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73033   {
73034     try {
73035       (arg1)->Disable();
73036     } catch (std::out_of_range& e) {
73037       {
73038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73039       };
73040     } catch (std::exception& e) {
73041       {
73042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73043       };
73044     } catch (...) {
73045       {
73046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73047       };
73048     }
73049   }
73050 }
73051
73052
73053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73054   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73055   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73056   Dali::Toolkit::RulerDomain *argp2 ;
73057
73058   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73059   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73060   if (!argp2) {
73061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73062     return ;
73063   }
73064   arg2 = *argp2;
73065   {
73066     try {
73067       (arg1)->SetDomain(arg2);
73068     } catch (std::out_of_range& e) {
73069       {
73070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73071       };
73072     } catch (std::exception& e) {
73073       {
73074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73075       };
73076     } catch (...) {
73077       {
73078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73079       };
73080     }
73081   }
73082 }
73083
73084
73085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73086   void * jresult ;
73087   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73088   Dali::Toolkit::RulerDomain *result = 0 ;
73089
73090   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73091   {
73092     try {
73093       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73094     } catch (std::out_of_range& e) {
73095       {
73096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73097       };
73098     } catch (std::exception& e) {
73099       {
73100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73101       };
73102     } catch (...) {
73103       {
73104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73105       };
73106     }
73107   }
73108   jresult = (void *)result;
73109   return jresult;
73110 }
73111
73112
73113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73114   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73115
73116   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73117   {
73118     try {
73119       (arg1)->DisableDomain();
73120     } catch (std::out_of_range& e) {
73121       {
73122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73123       };
73124     } catch (std::exception& e) {
73125       {
73126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73127       };
73128     } catch (...) {
73129       {
73130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73131       };
73132     }
73133   }
73134 }
73135
73136
73137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73138   float jresult ;
73139   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73140   float arg2 ;
73141   float arg3 ;
73142   float arg4 ;
73143   float result;
73144
73145   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73146   arg2 = (float)jarg2;
73147   arg3 = (float)jarg3;
73148   arg4 = (float)jarg4;
73149   {
73150     try {
73151       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73152     } catch (std::out_of_range& e) {
73153       {
73154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73155       };
73156     } catch (std::exception& e) {
73157       {
73158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73159       };
73160     } catch (...) {
73161       {
73162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73163       };
73164     }
73165   }
73166   jresult = result;
73167   return jresult;
73168 }
73169
73170
73171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73172   float jresult ;
73173   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73174   float arg2 ;
73175   float arg3 ;
73176   float result;
73177
73178   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73179   arg2 = (float)jarg2;
73180   arg3 = (float)jarg3;
73181   {
73182     try {
73183       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73184     } catch (std::out_of_range& e) {
73185       {
73186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73187       };
73188     } catch (std::exception& e) {
73189       {
73190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73191       };
73192     } catch (...) {
73193       {
73194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73195       };
73196     }
73197   }
73198   jresult = result;
73199   return jresult;
73200 }
73201
73202
73203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73204   float jresult ;
73205   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73206   float arg2 ;
73207   float result;
73208
73209   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73210   arg2 = (float)jarg2;
73211   {
73212     try {
73213       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73214     } catch (std::out_of_range& e) {
73215       {
73216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73217       };
73218     } catch (std::exception& e) {
73219       {
73220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73221       };
73222     } catch (...) {
73223       {
73224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73225       };
73226     }
73227   }
73228   jresult = result;
73229   return jresult;
73230 }
73231
73232
73233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73234   float jresult ;
73235   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73236   float arg2 ;
73237   float arg3 ;
73238   float arg4 ;
73239   Dali::Toolkit::ClampState *arg5 = 0 ;
73240   float result;
73241
73242   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73243   arg2 = (float)jarg2;
73244   arg3 = (float)jarg3;
73245   arg4 = (float)jarg4;
73246   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73247   if (!arg5) {
73248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73249     return 0;
73250   }
73251   {
73252     try {
73253       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73254     } catch (std::out_of_range& e) {
73255       {
73256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73257       };
73258     } catch (std::exception& e) {
73259       {
73260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73261       };
73262     } catch (...) {
73263       {
73264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73265       };
73266     }
73267   }
73268   jresult = result;
73269   return jresult;
73270 }
73271
73272
73273 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73274   float jresult ;
73275   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73276   float arg2 ;
73277   float arg3 ;
73278   float arg4 ;
73279   float arg5 ;
73280   float result;
73281
73282   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73283   arg2 = (float)jarg2;
73284   arg3 = (float)jarg3;
73285   arg4 = (float)jarg4;
73286   arg5 = (float)jarg5;
73287   {
73288     try {
73289       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73290     } catch (std::out_of_range& e) {
73291       {
73292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73293       };
73294     } catch (std::exception& e) {
73295       {
73296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73297       };
73298     } catch (...) {
73299       {
73300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73301       };
73302     }
73303   }
73304   jresult = result;
73305   return jresult;
73306 }
73307
73308
73309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73310   float jresult ;
73311   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73312   float arg2 ;
73313   float arg3 ;
73314   float arg4 ;
73315   float result;
73316
73317   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73318   arg2 = (float)jarg2;
73319   arg3 = (float)jarg3;
73320   arg4 = (float)jarg4;
73321   {
73322     try {
73323       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73324     } catch (std::out_of_range& e) {
73325       {
73326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73327       };
73328     } catch (std::exception& e) {
73329       {
73330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73331       };
73332     } catch (...) {
73333       {
73334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73335       };
73336     }
73337   }
73338   jresult = result;
73339   return jresult;
73340 }
73341
73342
73343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73344   float jresult ;
73345   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73346   float arg2 ;
73347   float arg3 ;
73348   float result;
73349
73350   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73351   arg2 = (float)jarg2;
73352   arg3 = (float)jarg3;
73353   {
73354     try {
73355       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73356     } catch (std::out_of_range& e) {
73357       {
73358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73359       };
73360     } catch (std::exception& e) {
73361       {
73362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73363       };
73364     } catch (...) {
73365       {
73366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73367       };
73368     }
73369   }
73370   jresult = result;
73371   return jresult;
73372 }
73373
73374
73375 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73376   float jresult ;
73377   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73378   float arg2 ;
73379   float result;
73380
73381   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73382   arg2 = (float)jarg2;
73383   {
73384     try {
73385       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73386     } catch (std::out_of_range& e) {
73387       {
73388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73389       };
73390     } catch (std::exception& e) {
73391       {
73392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73393       };
73394     } catch (...) {
73395       {
73396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73397       };
73398     }
73399   }
73400   jresult = result;
73401   return jresult;
73402 }
73403
73404
73405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73406   float jresult ;
73407   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73408   float arg2 ;
73409   float arg3 ;
73410   float arg4 ;
73411   float arg5 ;
73412   Dali::Toolkit::ClampState *arg6 = 0 ;
73413   float result;
73414
73415   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73416   arg2 = (float)jarg2;
73417   arg3 = (float)jarg3;
73418   arg4 = (float)jarg4;
73419   arg5 = (float)jarg5;
73420   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73421   if (!arg6) {
73422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73423     return 0;
73424   }
73425   {
73426     try {
73427       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73428     } catch (std::out_of_range& e) {
73429       {
73430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73431       };
73432     } catch (std::exception& e) {
73433       {
73434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73435       };
73436     } catch (...) {
73437       {
73438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73439       };
73440     }
73441   }
73442   jresult = result;
73443   return jresult;
73444 }
73445
73446
73447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73448   void * jresult ;
73449   Dali::Toolkit::DefaultRuler *result = 0 ;
73450
73451   {
73452     try {
73453       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73454     } catch (std::out_of_range& e) {
73455       {
73456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73457       };
73458     } catch (std::exception& e) {
73459       {
73460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73461       };
73462     } catch (...) {
73463       {
73464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73465       };
73466     }
73467   }
73468   jresult = (void *)result;
73469   return jresult;
73470 }
73471
73472
73473 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73474   float jresult ;
73475   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73476   float arg2 ;
73477   float arg3 ;
73478   float result;
73479
73480   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73481   arg2 = (float)jarg2;
73482   arg3 = (float)jarg3;
73483   {
73484     try {
73485       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73486     } catch (std::out_of_range& e) {
73487       {
73488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73489       };
73490     } catch (std::exception& e) {
73491       {
73492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73493       };
73494     } catch (...) {
73495       {
73496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73497       };
73498     }
73499   }
73500   jresult = result;
73501   return jresult;
73502 }
73503
73504
73505 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73506   float jresult ;
73507   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73508   unsigned int arg2 ;
73509   unsigned int *arg3 = 0 ;
73510   bool arg4 ;
73511   float result;
73512
73513   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73514   arg2 = (unsigned int)jarg2;
73515   arg3 = (unsigned int *)jarg3;
73516   arg4 = jarg4 ? true : false;
73517   {
73518     try {
73519       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73520     } catch (std::out_of_range& e) {
73521       {
73522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73523       };
73524     } catch (std::exception& e) {
73525       {
73526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73527       };
73528     } catch (...) {
73529       {
73530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73531       };
73532     }
73533   }
73534   jresult = result;
73535   return jresult;
73536 }
73537
73538
73539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73540   unsigned int jresult ;
73541   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73542   float arg2 ;
73543   bool arg3 ;
73544   unsigned int result;
73545
73546   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73547   arg2 = (float)jarg2;
73548   arg3 = jarg3 ? true : false;
73549   {
73550     try {
73551       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73552     } catch (std::out_of_range& e) {
73553       {
73554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73555       };
73556     } catch (std::exception& e) {
73557       {
73558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73559       };
73560     } catch (...) {
73561       {
73562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73563       };
73564     }
73565   }
73566   jresult = result;
73567   return jresult;
73568 }
73569
73570
73571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73572   unsigned int jresult ;
73573   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73574   unsigned int result;
73575
73576   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73577   {
73578     try {
73579       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73580     } catch (std::out_of_range& e) {
73581       {
73582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73583       };
73584     } catch (std::exception& e) {
73585       {
73586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73587       };
73588     } catch (...) {
73589       {
73590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73591       };
73592     }
73593   }
73594   jresult = result;
73595   return jresult;
73596 }
73597
73598
73599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73600   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73601
73602   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73603   {
73604     try {
73605       delete arg1;
73606     } catch (std::out_of_range& e) {
73607       {
73608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73609       };
73610     } catch (std::exception& e) {
73611       {
73612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73613       };
73614     } catch (...) {
73615       {
73616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73617       };
73618     }
73619   }
73620 }
73621
73622
73623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73624   void * jresult ;
73625   float arg1 ;
73626   Dali::Toolkit::FixedRuler *result = 0 ;
73627
73628   arg1 = (float)jarg1;
73629   {
73630     try {
73631       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73632     } catch (std::out_of_range& e) {
73633       {
73634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73635       };
73636     } catch (std::exception& e) {
73637       {
73638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73639       };
73640     } catch (...) {
73641       {
73642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73643       };
73644     }
73645   }
73646   jresult = (void *)result;
73647   return jresult;
73648 }
73649
73650
73651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73652   void * jresult ;
73653   Dali::Toolkit::FixedRuler *result = 0 ;
73654
73655   {
73656     try {
73657       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73658     } catch (std::out_of_range& e) {
73659       {
73660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73661       };
73662     } catch (std::exception& e) {
73663       {
73664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73665       };
73666     } catch (...) {
73667       {
73668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73669       };
73670     }
73671   }
73672   jresult = (void *)result;
73673   return jresult;
73674 }
73675
73676
73677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73678   float jresult ;
73679   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73680   float arg2 ;
73681   float arg3 ;
73682   float result;
73683
73684   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73685   arg2 = (float)jarg2;
73686   arg3 = (float)jarg3;
73687   {
73688     try {
73689       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73690     } catch (std::out_of_range& e) {
73691       {
73692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73693       };
73694     } catch (std::exception& e) {
73695       {
73696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73697       };
73698     } catch (...) {
73699       {
73700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73701       };
73702     }
73703   }
73704   jresult = result;
73705   return jresult;
73706 }
73707
73708
73709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73710   float jresult ;
73711   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73712   unsigned int arg2 ;
73713   unsigned int *arg3 = 0 ;
73714   bool arg4 ;
73715   float result;
73716
73717   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73718   arg2 = (unsigned int)jarg2;
73719   arg3 = (unsigned int *)jarg3;
73720   arg4 = jarg4 ? true : false;
73721   {
73722     try {
73723       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73724     } catch (std::out_of_range& e) {
73725       {
73726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73727       };
73728     } catch (std::exception& e) {
73729       {
73730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73731       };
73732     } catch (...) {
73733       {
73734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73735       };
73736     }
73737   }
73738   jresult = result;
73739   return jresult;
73740 }
73741
73742
73743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73744   unsigned int jresult ;
73745   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73746   float arg2 ;
73747   bool arg3 ;
73748   unsigned int result;
73749
73750   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73751   arg2 = (float)jarg2;
73752   arg3 = jarg3 ? true : false;
73753   {
73754     try {
73755       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73756     } catch (std::out_of_range& e) {
73757       {
73758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73759       };
73760     } catch (std::exception& e) {
73761       {
73762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73763       };
73764     } catch (...) {
73765       {
73766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73767       };
73768     }
73769   }
73770   jresult = result;
73771   return jresult;
73772 }
73773
73774
73775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73776   unsigned int jresult ;
73777   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73778   unsigned int result;
73779
73780   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73781   {
73782     try {
73783       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73784     } catch (std::out_of_range& e) {
73785       {
73786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73787       };
73788     } catch (std::exception& e) {
73789       {
73790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73791       };
73792     } catch (...) {
73793       {
73794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73795       };
73796     }
73797   }
73798   jresult = result;
73799   return jresult;
73800 }
73801
73802
73803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73804   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73805
73806   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73807   {
73808     try {
73809       delete arg1;
73810     } catch (std::out_of_range& e) {
73811       {
73812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73813       };
73814     } catch (std::exception& e) {
73815       {
73816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73817       };
73818     } catch (...) {
73819       {
73820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73821       };
73822     }
73823   }
73824 }
73825
73826
73827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73828   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73829   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73830
73831   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73832   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73833   if (arg1) (arg1)->scale = *arg2;
73834 }
73835
73836
73837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
73838   void * jresult ;
73839   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73840   Dali::Toolkit::ClampState2D *result = 0 ;
73841
73842   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73843   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73844   jresult = (void *)result;
73845   return jresult;
73846 }
73847
73848
73849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73850   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73851   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73852
73853   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73854   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73855   if (arg1) (arg1)->position = *arg2;
73856 }
73857
73858
73859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73860   void * jresult ;
73861   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73862   Dali::Toolkit::ClampState2D *result = 0 ;
73863
73864   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73865   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73866   jresult = (void *)result;
73867   return jresult;
73868 }
73869
73870
73871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73872   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73873   Dali::Toolkit::ClampState arg2 ;
73874
73875   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73876   arg2 = (Dali::Toolkit::ClampState)jarg2;
73877   if (arg1) (arg1)->rotation = arg2;
73878 }
73879
73880
73881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73882   int jresult ;
73883   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73884   Dali::Toolkit::ClampState result;
73885
73886   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73887   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73888   jresult = (int)result;
73889   return jresult;
73890 }
73891
73892
73893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73894   void * jresult ;
73895   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73896
73897   {
73898     try {
73899       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73900     } catch (std::out_of_range& e) {
73901       {
73902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73903       };
73904     } catch (std::exception& e) {
73905       {
73906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73907       };
73908     } catch (...) {
73909       {
73910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73911       };
73912     }
73913   }
73914   jresult = (void *)result;
73915   return jresult;
73916 }
73917
73918
73919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
73920   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73921
73922   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73923   {
73924     try {
73925       delete arg1;
73926     } catch (std::out_of_range& e) {
73927       {
73928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73929       };
73930     } catch (std::exception& e) {
73931       {
73932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73933       };
73934     } catch (...) {
73935       {
73936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73937       };
73938     }
73939   }
73940 }
73941
73942
73943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73944   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73945   Dali::Toolkit::SnapType arg2 ;
73946
73947   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73948   arg2 = (Dali::Toolkit::SnapType)jarg2;
73949   if (arg1) (arg1)->type = arg2;
73950 }
73951
73952
73953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
73954   int jresult ;
73955   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73956   Dali::Toolkit::SnapType result;
73957
73958   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73959   result = (Dali::Toolkit::SnapType) ((arg1)->type);
73960   jresult = (int)result;
73961   return jresult;
73962 }
73963
73964
73965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
73966   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73967   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
73968
73969   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73970   arg2 = (Dali::Vector2 *)jarg2;
73971   if (arg1) (arg1)->position = *arg2;
73972 }
73973
73974
73975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
73976   void * jresult ;
73977   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73978   Dali::Vector2 *result = 0 ;
73979
73980   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73981   result = (Dali::Vector2 *)& ((arg1)->position);
73982   jresult = (void *)result;
73983   return jresult;
73984 }
73985
73986
73987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
73988   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73989   float arg2 ;
73990
73991   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73992   arg2 = (float)jarg2;
73993   if (arg1) (arg1)->duration = arg2;
73994 }
73995
73996
73997 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
73998   float jresult ;
73999   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74000   float result;
74001
74002   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74003   result = (float) ((arg1)->duration);
74004   jresult = result;
74005   return jresult;
74006 }
74007
74008
74009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74010   void * jresult ;
74011   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74012
74013   {
74014     try {
74015       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74016     } catch (std::out_of_range& e) {
74017       {
74018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74019       };
74020     } catch (std::exception& e) {
74021       {
74022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74023       };
74024     } catch (...) {
74025       {
74026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74027       };
74028     }
74029   }
74030   jresult = (void *)result;
74031   return jresult;
74032 }
74033
74034
74035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74036   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74037
74038   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74039   {
74040     try {
74041       delete arg1;
74042     } catch (std::out_of_range& e) {
74043       {
74044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74045       };
74046     } catch (std::exception& e) {
74047       {
74048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74049       };
74050     } catch (...) {
74051       {
74052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74053       };
74054     }
74055   }
74056 }
74057
74058
74059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74060   int jresult ;
74061   int result;
74062
74063   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74064   jresult = (int)result;
74065   return jresult;
74066 }
74067
74068
74069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74070   int jresult ;
74071   int result;
74072
74073   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74074   jresult = (int)result;
74075   return jresult;
74076 }
74077
74078
74079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74080   int jresult ;
74081   int result;
74082
74083   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74084   jresult = (int)result;
74085   return jresult;
74086 }
74087
74088
74089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74090   int jresult ;
74091   int result;
74092
74093   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74094   jresult = (int)result;
74095   return jresult;
74096 }
74097
74098
74099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74100   int jresult ;
74101   int result;
74102
74103   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74104   jresult = (int)result;
74105   return jresult;
74106 }
74107
74108
74109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74110   int jresult ;
74111   int result;
74112
74113   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74114   jresult = (int)result;
74115   return jresult;
74116 }
74117
74118
74119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74120   int jresult ;
74121   int result;
74122
74123   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74124   jresult = (int)result;
74125   return jresult;
74126 }
74127
74128
74129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74130   int jresult ;
74131   int result;
74132
74133   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74134   jresult = (int)result;
74135   return jresult;
74136 }
74137
74138
74139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74140   int jresult ;
74141   int result;
74142
74143   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74144   jresult = (int)result;
74145   return jresult;
74146 }
74147
74148
74149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74150   int jresult ;
74151   int result;
74152
74153   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74154   jresult = (int)result;
74155   return jresult;
74156 }
74157
74158
74159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74160   int jresult ;
74161   int result;
74162
74163   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74164   jresult = (int)result;
74165   return jresult;
74166 }
74167
74168
74169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74170   int jresult ;
74171   int result;
74172
74173   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74174   jresult = (int)result;
74175   return jresult;
74176 }
74177
74178
74179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74180   int jresult ;
74181   int result;
74182
74183   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74184   jresult = (int)result;
74185   return jresult;
74186 }
74187
74188
74189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74190   int jresult ;
74191   int result;
74192
74193   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74194   jresult = (int)result;
74195   return jresult;
74196 }
74197
74198
74199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74200   int jresult ;
74201   int result;
74202
74203   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74204   jresult = (int)result;
74205   return jresult;
74206 }
74207
74208
74209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74210   int jresult ;
74211   int result;
74212
74213   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74214   jresult = (int)result;
74215   return jresult;
74216 }
74217
74218
74219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74220   int jresult ;
74221   int result;
74222
74223   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74224   jresult = (int)result;
74225   return jresult;
74226 }
74227
74228
74229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74230   int jresult ;
74231   int result;
74232
74233   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74234   jresult = (int)result;
74235   return jresult;
74236 }
74237
74238
74239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74240   int jresult ;
74241   int result;
74242
74243   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74244   jresult = (int)result;
74245   return jresult;
74246 }
74247
74248
74249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74250   int jresult ;
74251   int result;
74252
74253   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74254   jresult = (int)result;
74255   return jresult;
74256 }
74257
74258
74259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74260   int jresult ;
74261   int result;
74262
74263   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74264   jresult = (int)result;
74265   return jresult;
74266 }
74267
74268
74269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74270   int jresult ;
74271   int result;
74272
74273   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74274   jresult = (int)result;
74275   return jresult;
74276 }
74277
74278
74279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74280   int jresult ;
74281   int result;
74282
74283   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74284   jresult = (int)result;
74285   return jresult;
74286 }
74287
74288
74289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74290   int jresult ;
74291   int result;
74292
74293   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74294   jresult = (int)result;
74295   return jresult;
74296 }
74297
74298
74299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74300   int jresult ;
74301   int result;
74302
74303   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74304   jresult = (int)result;
74305   return jresult;
74306 }
74307
74308
74309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74310   void * jresult ;
74311   Dali::Toolkit::ScrollView::Property *result = 0 ;
74312
74313   {
74314     try {
74315       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74316     } catch (std::out_of_range& e) {
74317       {
74318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74319       };
74320     } catch (std::exception& e) {
74321       {
74322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74323       };
74324     } catch (...) {
74325       {
74326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74327       };
74328     }
74329   }
74330   jresult = (void *)result;
74331   return jresult;
74332 }
74333
74334
74335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74336   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74337
74338   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74339   {
74340     try {
74341       delete arg1;
74342     } catch (std::out_of_range& e) {
74343       {
74344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74345       };
74346     } catch (std::exception& e) {
74347       {
74348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74349       };
74350     } catch (...) {
74351       {
74352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74353       };
74354     }
74355   }
74356 }
74357
74358
74359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74360   void * jresult ;
74361   Dali::Toolkit::ScrollView *result = 0 ;
74362
74363   {
74364     try {
74365       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74366     } catch (std::out_of_range& e) {
74367       {
74368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74369       };
74370     } catch (std::exception& e) {
74371       {
74372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74373       };
74374     } catch (...) {
74375       {
74376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74377       };
74378     }
74379   }
74380   jresult = (void *)result;
74381   return jresult;
74382 }
74383
74384
74385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74386   void * jresult ;
74387   Dali::Toolkit::ScrollView *arg1 = 0 ;
74388   Dali::Toolkit::ScrollView *result = 0 ;
74389
74390   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74391   if (!arg1) {
74392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74393     return 0;
74394   }
74395   {
74396     try {
74397       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74398     } catch (std::out_of_range& e) {
74399       {
74400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74401       };
74402     } catch (std::exception& e) {
74403       {
74404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74405       };
74406     } catch (...) {
74407       {
74408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74409       };
74410     }
74411   }
74412   jresult = (void *)result;
74413   return jresult;
74414 }
74415
74416
74417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74418   void * jresult ;
74419   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74420   Dali::Toolkit::ScrollView *arg2 = 0 ;
74421   Dali::Toolkit::ScrollView *result = 0 ;
74422
74423   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74424   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74425   if (!arg2) {
74426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74427     return 0;
74428   }
74429   {
74430     try {
74431       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74432     } catch (std::out_of_range& e) {
74433       {
74434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74435       };
74436     } catch (std::exception& e) {
74437       {
74438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74439       };
74440     } catch (...) {
74441       {
74442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74443       };
74444     }
74445   }
74446   jresult = (void *)result;
74447   return jresult;
74448 }
74449
74450
74451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74452   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74453
74454   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74455   {
74456     try {
74457       delete arg1;
74458     } catch (std::out_of_range& e) {
74459       {
74460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74461       };
74462     } catch (std::exception& e) {
74463       {
74464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74465       };
74466     } catch (...) {
74467       {
74468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74469       };
74470     }
74471   }
74472 }
74473
74474
74475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74476   void * jresult ;
74477   Dali::Toolkit::ScrollView result;
74478
74479   {
74480     try {
74481       result = Dali::Toolkit::ScrollView::New();
74482     } catch (std::out_of_range& e) {
74483       {
74484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74485       };
74486     } catch (std::exception& e) {
74487       {
74488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74489       };
74490     } catch (...) {
74491       {
74492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74493       };
74494     }
74495   }
74496   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74497   return jresult;
74498 }
74499
74500
74501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74502   void * jresult ;
74503   Dali::BaseHandle arg1 ;
74504   Dali::BaseHandle *argp1 ;
74505   Dali::Toolkit::ScrollView result;
74506
74507   argp1 = (Dali::BaseHandle *)jarg1;
74508   if (!argp1) {
74509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74510     return 0;
74511   }
74512   arg1 = *argp1;
74513   {
74514     try {
74515       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74516     } catch (std::out_of_range& e) {
74517       {
74518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74519       };
74520     } catch (std::exception& e) {
74521       {
74522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74523       };
74524     } catch (...) {
74525       {
74526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74527       };
74528     }
74529   }
74530   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74531   return jresult;
74532 }
74533
74534
74535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74536   void * jresult ;
74537   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74538   Dali::AlphaFunction result;
74539
74540   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74541   {
74542     try {
74543       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74544     } catch (std::out_of_range& e) {
74545       {
74546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74547       };
74548     } catch (std::exception& e) {
74549       {
74550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74551       };
74552     } catch (...) {
74553       {
74554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74555       };
74556     }
74557   }
74558   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74559   return jresult;
74560 }
74561
74562
74563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74564   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74565   Dali::AlphaFunction arg2 ;
74566   Dali::AlphaFunction *argp2 ;
74567
74568   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74569   argp2 = (Dali::AlphaFunction *)jarg2;
74570   if (!argp2) {
74571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74572     return ;
74573   }
74574   arg2 = *argp2;
74575   {
74576     try {
74577       (arg1)->SetScrollSnapAlphaFunction(arg2);
74578     } catch (std::out_of_range& e) {
74579       {
74580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74581       };
74582     } catch (std::exception& e) {
74583       {
74584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74585       };
74586     } catch (...) {
74587       {
74588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74589       };
74590     }
74591   }
74592 }
74593
74594
74595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74596   void * jresult ;
74597   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74598   Dali::AlphaFunction result;
74599
74600   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74601   {
74602     try {
74603       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74604     } catch (std::out_of_range& e) {
74605       {
74606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74607       };
74608     } catch (std::exception& e) {
74609       {
74610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74611       };
74612     } catch (...) {
74613       {
74614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74615       };
74616     }
74617   }
74618   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74619   return jresult;
74620 }
74621
74622
74623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74624   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74625   Dali::AlphaFunction arg2 ;
74626   Dali::AlphaFunction *argp2 ;
74627
74628   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74629   argp2 = (Dali::AlphaFunction *)jarg2;
74630   if (!argp2) {
74631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74632     return ;
74633   }
74634   arg2 = *argp2;
74635   {
74636     try {
74637       (arg1)->SetScrollFlickAlphaFunction(arg2);
74638     } catch (std::out_of_range& e) {
74639       {
74640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74641       };
74642     } catch (std::exception& e) {
74643       {
74644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74645       };
74646     } catch (...) {
74647       {
74648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74649       };
74650     }
74651   }
74652 }
74653
74654
74655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74656   float jresult ;
74657   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74658   float result;
74659
74660   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74661   {
74662     try {
74663       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74664     } catch (std::out_of_range& e) {
74665       {
74666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74667       };
74668     } catch (std::exception& e) {
74669       {
74670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74671       };
74672     } catch (...) {
74673       {
74674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74675       };
74676     }
74677   }
74678   jresult = result;
74679   return jresult;
74680 }
74681
74682
74683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74684   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74685   float arg2 ;
74686
74687   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74688   arg2 = (float)jarg2;
74689   {
74690     try {
74691       (arg1)->SetScrollSnapDuration(arg2);
74692     } catch (std::out_of_range& e) {
74693       {
74694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74695       };
74696     } catch (std::exception& e) {
74697       {
74698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74699       };
74700     } catch (...) {
74701       {
74702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74703       };
74704     }
74705   }
74706 }
74707
74708
74709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74710   float jresult ;
74711   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74712   float result;
74713
74714   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74715   {
74716     try {
74717       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74718     } catch (std::out_of_range& e) {
74719       {
74720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74721       };
74722     } catch (std::exception& e) {
74723       {
74724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74725       };
74726     } catch (...) {
74727       {
74728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74729       };
74730     }
74731   }
74732   jresult = result;
74733   return jresult;
74734 }
74735
74736
74737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74738   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74739   float arg2 ;
74740
74741   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74742   arg2 = (float)jarg2;
74743   {
74744     try {
74745       (arg1)->SetScrollFlickDuration(arg2);
74746     } catch (std::out_of_range& e) {
74747       {
74748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74749       };
74750     } catch (std::exception& e) {
74751       {
74752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74753       };
74754     } catch (...) {
74755       {
74756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74757       };
74758     }
74759   }
74760 }
74761
74762
74763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74764   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74765   Dali::Toolkit::RulerPtr arg2 ;
74766   Dali::Toolkit::RulerPtr *argp2 ;
74767
74768   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74769   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74770   if (!argp2) {
74771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74772     return ;
74773   }
74774   arg2 = *argp2;
74775   {
74776     try {
74777       (arg1)->SetRulerX(arg2);
74778     } catch (std::out_of_range& e) {
74779       {
74780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74781       };
74782     } catch (std::exception& e) {
74783       {
74784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74785       };
74786     } catch (...) {
74787       {
74788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74789       };
74790     }
74791   }
74792 }
74793
74794
74795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74796   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74797   Dali::Toolkit::RulerPtr arg2 ;
74798   Dali::Toolkit::RulerPtr *argp2 ;
74799
74800   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74801   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74802   if (!argp2) {
74803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74804     return ;
74805   }
74806   arg2 = *argp2;
74807   {
74808     try {
74809       (arg1)->SetRulerY(arg2);
74810     } catch (std::out_of_range& e) {
74811       {
74812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74813       };
74814     } catch (std::exception& e) {
74815       {
74816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74817       };
74818     } catch (...) {
74819       {
74820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74821       };
74822     }
74823   }
74824 }
74825
74826
74827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74828   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74829   bool arg2 ;
74830
74831   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74832   arg2 = jarg2 ? true : false;
74833   {
74834     try {
74835       (arg1)->SetScrollSensitive(arg2);
74836     } catch (std::out_of_range& e) {
74837       {
74838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74839       };
74840     } catch (std::exception& e) {
74841       {
74842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74843       };
74844     } catch (...) {
74845       {
74846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74847       };
74848     }
74849   }
74850 }
74851
74852
74853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
74854   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74855   float arg2 ;
74856   float arg3 ;
74857
74858   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74859   arg2 = (float)jarg2;
74860   arg3 = (float)jarg3;
74861   {
74862     try {
74863       (arg1)->SetMaxOvershoot(arg2,arg3);
74864     } catch (std::out_of_range& e) {
74865       {
74866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74867       };
74868     } catch (std::exception& e) {
74869       {
74870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74871       };
74872     } catch (...) {
74873       {
74874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74875       };
74876     }
74877   }
74878 }
74879
74880
74881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
74882   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74883   Dali::AlphaFunction arg2 ;
74884   Dali::AlphaFunction *argp2 ;
74885
74886   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74887   argp2 = (Dali::AlphaFunction *)jarg2;
74888   if (!argp2) {
74889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74890     return ;
74891   }
74892   arg2 = *argp2;
74893   {
74894     try {
74895       (arg1)->SetSnapOvershootAlphaFunction(arg2);
74896     } catch (std::out_of_range& e) {
74897       {
74898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74899       };
74900     } catch (std::exception& e) {
74901       {
74902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74903       };
74904     } catch (...) {
74905       {
74906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74907       };
74908     }
74909   }
74910 }
74911
74912
74913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
74914   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74915   float arg2 ;
74916
74917   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74918   arg2 = (float)jarg2;
74919   {
74920     try {
74921       (arg1)->SetSnapOvershootDuration(arg2);
74922     } catch (std::out_of_range& e) {
74923       {
74924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74925       };
74926     } catch (std::exception& e) {
74927       {
74928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74929       };
74930     } catch (...) {
74931       {
74932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74933       };
74934     }
74935   }
74936 }
74937
74938
74939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
74940   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74941   bool arg2 ;
74942
74943   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74944   arg2 = jarg2 ? true : false;
74945   {
74946     try {
74947       (arg1)->SetActorAutoSnap(arg2);
74948     } catch (std::out_of_range& e) {
74949       {
74950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74951       };
74952     } catch (std::exception& e) {
74953       {
74954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74955       };
74956     } catch (...) {
74957       {
74958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74959       };
74960     }
74961   }
74962 }
74963
74964
74965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
74966   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74967   bool arg2 ;
74968
74969   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74970   arg2 = jarg2 ? true : false;
74971   {
74972     try {
74973       (arg1)->SetWrapMode(arg2);
74974     } catch (std::out_of_range& e) {
74975       {
74976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74977       };
74978     } catch (std::exception& e) {
74979       {
74980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74981       };
74982     } catch (...) {
74983       {
74984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74985       };
74986     }
74987   }
74988 }
74989
74990
74991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
74992   int jresult ;
74993   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74994   int result;
74995
74996   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74997   {
74998     try {
74999       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75000     } catch (std::out_of_range& e) {
75001       {
75002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75003       };
75004     } catch (std::exception& e) {
75005       {
75006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75007       };
75008     } catch (...) {
75009       {
75010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75011       };
75012     }
75013   }
75014   jresult = result;
75015   return jresult;
75016 }
75017
75018
75019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75020   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75021   int arg2 ;
75022
75023   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75024   arg2 = (int)jarg2;
75025   {
75026     try {
75027       (arg1)->SetScrollUpdateDistance(arg2);
75028     } catch (std::out_of_range& e) {
75029       {
75030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75031       };
75032     } catch (std::exception& e) {
75033       {
75034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75035       };
75036     } catch (...) {
75037       {
75038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75039       };
75040     }
75041   }
75042 }
75043
75044
75045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75046   unsigned int jresult ;
75047   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75048   bool result;
75049
75050   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75051   {
75052     try {
75053       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75054     } catch (std::out_of_range& e) {
75055       {
75056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75057       };
75058     } catch (std::exception& e) {
75059       {
75060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75061       };
75062     } catch (...) {
75063       {
75064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75065       };
75066     }
75067   }
75068   jresult = result;
75069   return jresult;
75070 }
75071
75072
75073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75074   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75075   bool arg2 ;
75076
75077   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75078   arg2 = jarg2 ? true : false;
75079   {
75080     try {
75081       (arg1)->SetAxisAutoLock(arg2);
75082     } catch (std::out_of_range& e) {
75083       {
75084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75085       };
75086     } catch (std::exception& e) {
75087       {
75088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75089       };
75090     } catch (...) {
75091       {
75092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75093       };
75094     }
75095   }
75096 }
75097
75098
75099 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75100   float jresult ;
75101   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75102   float result;
75103
75104   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75105   {
75106     try {
75107       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75108     } catch (std::out_of_range& e) {
75109       {
75110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75111       };
75112     } catch (std::exception& e) {
75113       {
75114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75115       };
75116     } catch (...) {
75117       {
75118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75119       };
75120     }
75121   }
75122   jresult = result;
75123   return jresult;
75124 }
75125
75126
75127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75128   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75129   float arg2 ;
75130
75131   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75132   arg2 = (float)jarg2;
75133   {
75134     try {
75135       (arg1)->SetAxisAutoLockGradient(arg2);
75136     } catch (std::out_of_range& e) {
75137       {
75138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75139       };
75140     } catch (std::exception& e) {
75141       {
75142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75143       };
75144     } catch (...) {
75145       {
75146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75147       };
75148     }
75149   }
75150 }
75151
75152
75153 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75154   float jresult ;
75155   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75156   float result;
75157
75158   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75159   {
75160     try {
75161       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75162     } catch (std::out_of_range& e) {
75163       {
75164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75165       };
75166     } catch (std::exception& e) {
75167       {
75168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75169       };
75170     } catch (...) {
75171       {
75172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75173       };
75174     }
75175   }
75176   jresult = result;
75177   return jresult;
75178 }
75179
75180
75181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75182   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75183   float arg2 ;
75184
75185   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75186   arg2 = (float)jarg2;
75187   {
75188     try {
75189       (arg1)->SetFrictionCoefficient(arg2);
75190     } catch (std::out_of_range& e) {
75191       {
75192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75193       };
75194     } catch (std::exception& e) {
75195       {
75196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75197       };
75198     } catch (...) {
75199       {
75200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75201       };
75202     }
75203   }
75204 }
75205
75206
75207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75208   float jresult ;
75209   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75210   float result;
75211
75212   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75213   {
75214     try {
75215       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75216     } catch (std::out_of_range& e) {
75217       {
75218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75219       };
75220     } catch (std::exception& e) {
75221       {
75222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75223       };
75224     } catch (...) {
75225       {
75226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75227       };
75228     }
75229   }
75230   jresult = result;
75231   return jresult;
75232 }
75233
75234
75235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75236   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75237   float arg2 ;
75238
75239   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75240   arg2 = (float)jarg2;
75241   {
75242     try {
75243       (arg1)->SetFlickSpeedCoefficient(arg2);
75244     } catch (std::out_of_range& e) {
75245       {
75246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75247       };
75248     } catch (std::exception& e) {
75249       {
75250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75251       };
75252     } catch (...) {
75253       {
75254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75255       };
75256     }
75257   }
75258 }
75259
75260
75261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75262   void * jresult ;
75263   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75264   Dali::Vector2 result;
75265
75266   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75267   {
75268     try {
75269       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75270     } catch (std::out_of_range& e) {
75271       {
75272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75273       };
75274     } catch (std::exception& e) {
75275       {
75276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75277       };
75278     } catch (...) {
75279       {
75280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75281       };
75282     }
75283   }
75284   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75285   return jresult;
75286 }
75287
75288
75289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75290   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75291   Dali::Vector2 *arg2 = 0 ;
75292
75293   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75294   arg2 = (Dali::Vector2 *)jarg2;
75295   if (!arg2) {
75296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75297     return ;
75298   }
75299   {
75300     try {
75301       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75302     } catch (std::out_of_range& e) {
75303       {
75304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75305       };
75306     } catch (std::exception& e) {
75307       {
75308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75309       };
75310     } catch (...) {
75311       {
75312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75313       };
75314     }
75315   }
75316 }
75317
75318
75319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75320   float jresult ;
75321   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75322   float result;
75323
75324   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75325   {
75326     try {
75327       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75328     } catch (std::out_of_range& e) {
75329       {
75330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75331       };
75332     } catch (std::exception& e) {
75333       {
75334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75335       };
75336     } catch (...) {
75337       {
75338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75339       };
75340     }
75341   }
75342   jresult = result;
75343   return jresult;
75344 }
75345
75346
75347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75348   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75349   float arg2 ;
75350
75351   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75352   arg2 = (float)jarg2;
75353   {
75354     try {
75355       (arg1)->SetMinimumSpeedForFlick(arg2);
75356     } catch (std::out_of_range& e) {
75357       {
75358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75359       };
75360     } catch (std::exception& e) {
75361       {
75362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75363       };
75364     } catch (...) {
75365       {
75366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75367       };
75368     }
75369   }
75370 }
75371
75372
75373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75374   float jresult ;
75375   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75376   float result;
75377
75378   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75379   {
75380     try {
75381       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75382     } catch (std::out_of_range& e) {
75383       {
75384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75385       };
75386     } catch (std::exception& e) {
75387       {
75388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75389       };
75390     } catch (...) {
75391       {
75392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75393       };
75394     }
75395   }
75396   jresult = result;
75397   return jresult;
75398 }
75399
75400
75401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75402   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75403   float arg2 ;
75404
75405   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75406   arg2 = (float)jarg2;
75407   {
75408     try {
75409       (arg1)->SetMaxFlickSpeed(arg2);
75410     } catch (std::out_of_range& e) {
75411       {
75412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75413       };
75414     } catch (std::exception& e) {
75415       {
75416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75417       };
75418     } catch (...) {
75419       {
75420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75421       };
75422     }
75423   }
75424 }
75425
75426
75427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75428   void * jresult ;
75429   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75430   Dali::Vector2 result;
75431
75432   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75433   {
75434     try {
75435       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75436     } catch (std::out_of_range& e) {
75437       {
75438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75439       };
75440     } catch (std::exception& e) {
75441       {
75442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75443       };
75444     } catch (...) {
75445       {
75446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75447       };
75448     }
75449   }
75450   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75451   return jresult;
75452 }
75453
75454
75455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75456   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75457   Dali::Vector2 arg2 ;
75458   Dali::Vector2 *argp2 ;
75459
75460   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75461   argp2 = (Dali::Vector2 *)jarg2;
75462   if (!argp2) {
75463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75464     return ;
75465   }
75466   arg2 = *argp2;
75467   {
75468     try {
75469       (arg1)->SetWheelScrollDistanceStep(arg2);
75470     } catch (std::out_of_range& e) {
75471       {
75472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75473       };
75474     } catch (std::exception& e) {
75475       {
75476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75477       };
75478     } catch (...) {
75479       {
75480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75481       };
75482     }
75483   }
75484 }
75485
75486
75487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75488   void * jresult ;
75489   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75490   Dali::Vector2 result;
75491
75492   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75493   {
75494     try {
75495       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75496     } catch (std::out_of_range& e) {
75497       {
75498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75499       };
75500     } catch (std::exception& e) {
75501       {
75502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75503       };
75504     } catch (...) {
75505       {
75506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75507       };
75508     }
75509   }
75510   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75511   return jresult;
75512 }
75513
75514
75515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75516   unsigned int jresult ;
75517   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75518   unsigned int result;
75519
75520   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75521   {
75522     try {
75523       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75524     } catch (std::out_of_range& e) {
75525       {
75526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75527       };
75528     } catch (std::exception& e) {
75529       {
75530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75531       };
75532     } catch (...) {
75533       {
75534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75535       };
75536     }
75537   }
75538   jresult = result;
75539   return jresult;
75540 }
75541
75542
75543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75544   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75545   Dali::Vector2 *arg2 = 0 ;
75546
75547   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75548   arg2 = (Dali::Vector2 *)jarg2;
75549   if (!arg2) {
75550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75551     return ;
75552   }
75553   {
75554     try {
75555       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75556     } catch (std::out_of_range& e) {
75557       {
75558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75559       };
75560     } catch (std::exception& e) {
75561       {
75562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75563       };
75564     } catch (...) {
75565       {
75566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75567       };
75568     }
75569   }
75570 }
75571
75572
75573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75574   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75575   Dali::Vector2 *arg2 = 0 ;
75576   float arg3 ;
75577
75578   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75579   arg2 = (Dali::Vector2 *)jarg2;
75580   if (!arg2) {
75581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75582     return ;
75583   }
75584   arg3 = (float)jarg3;
75585   {
75586     try {
75587       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75588     } catch (std::out_of_range& e) {
75589       {
75590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75591       };
75592     } catch (std::exception& e) {
75593       {
75594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75595       };
75596     } catch (...) {
75597       {
75598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75599       };
75600     }
75601   }
75602 }
75603
75604
75605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75606   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75607   Dali::Vector2 *arg2 = 0 ;
75608   float arg3 ;
75609   Dali::AlphaFunction arg4 ;
75610   Dali::AlphaFunction *argp4 ;
75611
75612   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75613   arg2 = (Dali::Vector2 *)jarg2;
75614   if (!arg2) {
75615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75616     return ;
75617   }
75618   arg3 = (float)jarg3;
75619   argp4 = (Dali::AlphaFunction *)jarg4;
75620   if (!argp4) {
75621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75622     return ;
75623   }
75624   arg4 = *argp4;
75625   {
75626     try {
75627       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75628     } catch (std::out_of_range& e) {
75629       {
75630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75631       };
75632     } catch (std::exception& e) {
75633       {
75634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75635       };
75636     } catch (...) {
75637       {
75638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75639       };
75640     }
75641   }
75642 }
75643
75644
75645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75646   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75647   Dali::Vector2 *arg2 = 0 ;
75648   float arg3 ;
75649   Dali::Toolkit::DirectionBias arg4 ;
75650   Dali::Toolkit::DirectionBias arg5 ;
75651
75652   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75653   arg2 = (Dali::Vector2 *)jarg2;
75654   if (!arg2) {
75655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75656     return ;
75657   }
75658   arg3 = (float)jarg3;
75659   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75660   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75661   {
75662     try {
75663       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75664     } catch (std::out_of_range& e) {
75665       {
75666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75667       };
75668     } catch (std::exception& e) {
75669       {
75670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75671       };
75672     } catch (...) {
75673       {
75674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75675       };
75676     }
75677   }
75678 }
75679
75680
75681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75682   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75683   Dali::Vector2 *arg2 = 0 ;
75684   float arg3 ;
75685   Dali::AlphaFunction arg4 ;
75686   Dali::Toolkit::DirectionBias arg5 ;
75687   Dali::Toolkit::DirectionBias arg6 ;
75688   Dali::AlphaFunction *argp4 ;
75689
75690   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75691   arg2 = (Dali::Vector2 *)jarg2;
75692   if (!arg2) {
75693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75694     return ;
75695   }
75696   arg3 = (float)jarg3;
75697   argp4 = (Dali::AlphaFunction *)jarg4;
75698   if (!argp4) {
75699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75700     return ;
75701   }
75702   arg4 = *argp4;
75703   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75704   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
75705   {
75706     try {
75707       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
75708     } catch (std::out_of_range& e) {
75709       {
75710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75711       };
75712     } catch (std::exception& e) {
75713       {
75714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75715       };
75716     } catch (...) {
75717       {
75718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75719       };
75720     }
75721   }
75722 }
75723
75724
75725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
75726   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75727   unsigned int arg2 ;
75728
75729   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75730   arg2 = (unsigned int)jarg2;
75731   {
75732     try {
75733       (arg1)->ScrollTo(arg2);
75734     } catch (std::out_of_range& e) {
75735       {
75736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75737       };
75738     } catch (std::exception& e) {
75739       {
75740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75741       };
75742     } catch (...) {
75743       {
75744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75745       };
75746     }
75747   }
75748 }
75749
75750
75751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
75752   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75753   unsigned int arg2 ;
75754   float arg3 ;
75755
75756   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75757   arg2 = (unsigned int)jarg2;
75758   arg3 = (float)jarg3;
75759   {
75760     try {
75761       (arg1)->ScrollTo(arg2,arg3);
75762     } catch (std::out_of_range& e) {
75763       {
75764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75765       };
75766     } catch (std::exception& e) {
75767       {
75768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75769       };
75770     } catch (...) {
75771       {
75772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75773       };
75774     }
75775   }
75776 }
75777
75778
75779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
75780   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75781   unsigned int arg2 ;
75782   float arg3 ;
75783   Dali::Toolkit::DirectionBias arg4 ;
75784
75785   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75786   arg2 = (unsigned int)jarg2;
75787   arg3 = (float)jarg3;
75788   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75789   {
75790     try {
75791       (arg1)->ScrollTo(arg2,arg3,arg4);
75792     } catch (std::out_of_range& e) {
75793       {
75794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75795       };
75796     } catch (std::exception& e) {
75797       {
75798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75799       };
75800     } catch (...) {
75801       {
75802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75803       };
75804     }
75805   }
75806 }
75807
75808
75809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
75810   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75811   Dali::Actor *arg2 = 0 ;
75812
75813   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75814   arg2 = (Dali::Actor *)jarg2;
75815   if (!arg2) {
75816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75817     return ;
75818   }
75819   {
75820     try {
75821       (arg1)->ScrollTo(*arg2);
75822     } catch (std::out_of_range& e) {
75823       {
75824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75825       };
75826     } catch (std::exception& e) {
75827       {
75828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75829       };
75830     } catch (...) {
75831       {
75832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75833       };
75834     }
75835   }
75836 }
75837
75838
75839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
75840   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75841   Dali::Actor *arg2 = 0 ;
75842   float arg3 ;
75843
75844   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75845   arg2 = (Dali::Actor *)jarg2;
75846   if (!arg2) {
75847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75848     return ;
75849   }
75850   arg3 = (float)jarg3;
75851   {
75852     try {
75853       (arg1)->ScrollTo(*arg2,arg3);
75854     } catch (std::out_of_range& e) {
75855       {
75856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75857       };
75858     } catch (std::exception& e) {
75859       {
75860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75861       };
75862     } catch (...) {
75863       {
75864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75865       };
75866     }
75867   }
75868 }
75869
75870
75871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
75872   unsigned int jresult ;
75873   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75874   bool result;
75875
75876   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75877   {
75878     try {
75879       result = (bool)(arg1)->ScrollToSnapPoint();
75880     } catch (std::out_of_range& e) {
75881       {
75882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75883       };
75884     } catch (std::exception& e) {
75885       {
75886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75887       };
75888     } catch (...) {
75889       {
75890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75891       };
75892     }
75893   }
75894   jresult = result;
75895   return jresult;
75896 }
75897
75898
75899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
75900   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75901   Dali::Constraint arg2 ;
75902   Dali::Constraint *argp2 ;
75903
75904   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75905   argp2 = (Dali::Constraint *)jarg2;
75906   if (!argp2) {
75907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
75908     return ;
75909   }
75910   arg2 = *argp2;
75911   {
75912     try {
75913       (arg1)->ApplyConstraintToChildren(arg2);
75914     } catch (std::out_of_range& e) {
75915       {
75916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75917       };
75918     } catch (std::exception& e) {
75919       {
75920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75921       };
75922     } catch (...) {
75923       {
75924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75925       };
75926     }
75927   }
75928 }
75929
75930
75931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
75932   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75933
75934   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75935   {
75936     try {
75937       (arg1)->RemoveConstraintsFromChildren();
75938     } catch (std::out_of_range& e) {
75939       {
75940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75941       };
75942     } catch (std::exception& e) {
75943       {
75944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75945       };
75946     } catch (...) {
75947       {
75948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75949       };
75950     }
75951   }
75952 }
75953
75954
75955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
75956   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75957   Dali::Toolkit::ScrollViewEffect arg2 ;
75958   Dali::Toolkit::ScrollViewEffect *argp2 ;
75959
75960   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75961   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75962   if (!argp2) {
75963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75964     return ;
75965   }
75966   arg2 = *argp2;
75967   {
75968     try {
75969       (arg1)->ApplyEffect(arg2);
75970     } catch (std::out_of_range& e) {
75971       {
75972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75973       };
75974     } catch (std::exception& e) {
75975       {
75976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75977       };
75978     } catch (...) {
75979       {
75980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75981       };
75982     }
75983   }
75984 }
75985
75986
75987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
75988   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75989   Dali::Toolkit::ScrollViewEffect arg2 ;
75990   Dali::Toolkit::ScrollViewEffect *argp2 ;
75991
75992   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75993   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
75994   if (!argp2) {
75995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
75996     return ;
75997   }
75998   arg2 = *argp2;
75999   {
76000     try {
76001       (arg1)->RemoveEffect(arg2);
76002     } catch (std::out_of_range& e) {
76003       {
76004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76005       };
76006     } catch (std::exception& e) {
76007       {
76008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76009       };
76010     } catch (...) {
76011       {
76012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76013       };
76014     }
76015   }
76016 }
76017
76018
76019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76020   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76021
76022   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76023   {
76024     try {
76025       (arg1)->RemoveAllEffects();
76026     } catch (std::out_of_range& e) {
76027       {
76028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76029       };
76030     } catch (std::exception& e) {
76031       {
76032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76033       };
76034     } catch (...) {
76035       {
76036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76037       };
76038     }
76039   }
76040 }
76041
76042
76043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76044   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76045   Dali::Actor arg2 ;
76046   Dali::Actor *argp2 ;
76047
76048   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76049   argp2 = (Dali::Actor *)jarg2;
76050   if (!argp2) {
76051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76052     return ;
76053   }
76054   arg2 = *argp2;
76055   {
76056     try {
76057       (arg1)->BindActor(arg2);
76058     } catch (std::out_of_range& e) {
76059       {
76060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76061       };
76062     } catch (std::exception& e) {
76063       {
76064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76065       };
76066     } catch (...) {
76067       {
76068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76069       };
76070     }
76071   }
76072 }
76073
76074
76075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76076   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76077   Dali::Actor arg2 ;
76078   Dali::Actor *argp2 ;
76079
76080   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76081   argp2 = (Dali::Actor *)jarg2;
76082   if (!argp2) {
76083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76084     return ;
76085   }
76086   arg2 = *argp2;
76087   {
76088     try {
76089       (arg1)->UnbindActor(arg2);
76090     } catch (std::out_of_range& e) {
76091       {
76092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76093       };
76094     } catch (std::exception& e) {
76095       {
76096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76097       };
76098     } catch (...) {
76099       {
76100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76101       };
76102     }
76103   }
76104 }
76105
76106
76107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76108   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76109   Dali::Radian arg2 ;
76110   Dali::Radian arg3 ;
76111   Dali::Radian *argp2 ;
76112   Dali::Radian *argp3 ;
76113
76114   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76115   argp2 = (Dali::Radian *)jarg2;
76116   if (!argp2) {
76117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76118     return ;
76119   }
76120   arg2 = *argp2;
76121   argp3 = (Dali::Radian *)jarg3;
76122   if (!argp3) {
76123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76124     return ;
76125   }
76126   arg3 = *argp3;
76127   {
76128     try {
76129       (arg1)->SetScrollingDirection(arg2,arg3);
76130     } catch (std::out_of_range& e) {
76131       {
76132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76133       };
76134     } catch (std::exception& e) {
76135       {
76136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76137       };
76138     } catch (...) {
76139       {
76140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76141       };
76142     }
76143   }
76144 }
76145
76146
76147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76148   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76149   Dali::Radian arg2 ;
76150   Dali::Radian *argp2 ;
76151
76152   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76153   argp2 = (Dali::Radian *)jarg2;
76154   if (!argp2) {
76155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76156     return ;
76157   }
76158   arg2 = *argp2;
76159   {
76160     try {
76161       (arg1)->SetScrollingDirection(arg2);
76162     } catch (std::out_of_range& e) {
76163       {
76164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76165       };
76166     } catch (std::exception& e) {
76167       {
76168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76169       };
76170     } catch (...) {
76171       {
76172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76173       };
76174     }
76175   }
76176 }
76177
76178
76179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76180   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76181   Dali::Radian arg2 ;
76182   Dali::Radian *argp2 ;
76183
76184   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76185   argp2 = (Dali::Radian *)jarg2;
76186   if (!argp2) {
76187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76188     return ;
76189   }
76190   arg2 = *argp2;
76191   {
76192     try {
76193       (arg1)->RemoveScrollingDirection(arg2);
76194     } catch (std::out_of_range& e) {
76195       {
76196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76197       };
76198     } catch (std::exception& e) {
76199       {
76200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76201       };
76202     } catch (...) {
76203       {
76204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76205       };
76206     }
76207   }
76208 }
76209
76210
76211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76212   void * jresult ;
76213   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76214   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76215
76216   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76217   {
76218     try {
76219       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76220     } catch (std::out_of_range& e) {
76221       {
76222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76223       };
76224     } catch (std::exception& e) {
76225       {
76226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76227       };
76228     } catch (...) {
76229       {
76230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76231       };
76232     }
76233   }
76234   jresult = (void *)result;
76235   return jresult;
76236 }
76237
76238
76239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76240   int jresult ;
76241   int result;
76242
76243   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76244   jresult = (int)result;
76245   return jresult;
76246 }
76247
76248
76249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76250   int jresult ;
76251   int result;
76252
76253   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76254   jresult = (int)result;
76255   return jresult;
76256 }
76257
76258
76259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76260   int jresult ;
76261   int result;
76262
76263   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76264   jresult = (int)result;
76265   return jresult;
76266 }
76267
76268
76269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76270   int jresult ;
76271   int result;
76272
76273   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76274   jresult = (int)result;
76275   return jresult;
76276 }
76277
76278
76279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76280   int jresult ;
76281   int result;
76282
76283   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76284   jresult = (int)result;
76285   return jresult;
76286 }
76287
76288
76289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76290   void * jresult ;
76291   Dali::Toolkit::TableView::Property *result = 0 ;
76292
76293   {
76294     try {
76295       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76296     } catch (std::out_of_range& e) {
76297       {
76298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76299       };
76300     } catch (std::exception& e) {
76301       {
76302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76303       };
76304     } catch (...) {
76305       {
76306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76307       };
76308     }
76309   }
76310   jresult = (void *)result;
76311   return jresult;
76312 }
76313
76314
76315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76316   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76317
76318   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76319   {
76320     try {
76321       delete arg1;
76322     } catch (std::out_of_range& e) {
76323       {
76324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76325       };
76326     } catch (std::exception& e) {
76327       {
76328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76329       };
76330     } catch (...) {
76331       {
76332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76333       };
76334     }
76335   }
76336 }
76337
76338
76339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76340   int jresult ;
76341   int result;
76342
76343   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76344   jresult = (int)result;
76345   return jresult;
76346 }
76347
76348
76349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76350   int jresult ;
76351   int result;
76352
76353   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76354   jresult = (int)result;
76355   return jresult;
76356 }
76357
76358
76359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76360   int jresult ;
76361   int result;
76362
76363   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76364   jresult = (int)result;
76365   return jresult;
76366 }
76367
76368
76369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76370   int jresult ;
76371   int result;
76372
76373   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76374   jresult = (int)result;
76375   return jresult;
76376 }
76377
76378
76379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76380   int jresult ;
76381   int result;
76382
76383   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76384   jresult = (int)result;
76385   return jresult;
76386 }
76387
76388
76389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76390   void * jresult ;
76391   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76392
76393   {
76394     try {
76395       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76396     } catch (std::out_of_range& e) {
76397       {
76398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76399       };
76400     } catch (std::exception& e) {
76401       {
76402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76403       };
76404     } catch (...) {
76405       {
76406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76407       };
76408     }
76409   }
76410   jresult = (void *)result;
76411   return jresult;
76412 }
76413
76414
76415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76416   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76417
76418   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76419   {
76420     try {
76421       delete arg1;
76422     } catch (std::out_of_range& e) {
76423       {
76424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76425       };
76426     } catch (std::exception& e) {
76427       {
76428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76429       };
76430     } catch (...) {
76431       {
76432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76433       };
76434     }
76435   }
76436 }
76437
76438
76439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76440   void * jresult ;
76441   unsigned int arg1 ;
76442   unsigned int arg2 ;
76443   unsigned int arg3 ;
76444   unsigned int arg4 ;
76445   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76446
76447   arg1 = (unsigned int)jarg1;
76448   arg2 = (unsigned int)jarg2;
76449   arg3 = (unsigned int)jarg3;
76450   arg4 = (unsigned int)jarg4;
76451   {
76452     try {
76453       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76454     } catch (std::out_of_range& e) {
76455       {
76456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76457       };
76458     } catch (std::exception& e) {
76459       {
76460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76461       };
76462     } catch (...) {
76463       {
76464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76465       };
76466     }
76467   }
76468   jresult = (void *)result;
76469   return jresult;
76470 }
76471
76472
76473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76474   void * jresult ;
76475   unsigned int arg1 ;
76476   unsigned int arg2 ;
76477   unsigned int arg3 ;
76478   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76479
76480   arg1 = (unsigned int)jarg1;
76481   arg2 = (unsigned int)jarg2;
76482   arg3 = (unsigned int)jarg3;
76483   {
76484     try {
76485       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76486     } catch (std::out_of_range& e) {
76487       {
76488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76489       };
76490     } catch (std::exception& e) {
76491       {
76492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76493       };
76494     } catch (...) {
76495       {
76496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76497       };
76498     }
76499   }
76500   jresult = (void *)result;
76501   return jresult;
76502 }
76503
76504
76505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76506   void * jresult ;
76507   unsigned int arg1 ;
76508   unsigned int arg2 ;
76509   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76510
76511   arg1 = (unsigned int)jarg1;
76512   arg2 = (unsigned int)jarg2;
76513   {
76514     try {
76515       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76516     } catch (std::out_of_range& e) {
76517       {
76518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76519       };
76520     } catch (std::exception& e) {
76521       {
76522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76523       };
76524     } catch (...) {
76525       {
76526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76527       };
76528     }
76529   }
76530   jresult = (void *)result;
76531   return jresult;
76532 }
76533
76534
76535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76536   void * jresult ;
76537   unsigned int arg1 ;
76538   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76539
76540   arg1 = (unsigned int)jarg1;
76541   {
76542     try {
76543       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76544     } catch (std::out_of_range& e) {
76545       {
76546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76547       };
76548     } catch (std::exception& e) {
76549       {
76550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76551       };
76552     } catch (...) {
76553       {
76554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76555       };
76556     }
76557   }
76558   jresult = (void *)result;
76559   return jresult;
76560 }
76561
76562
76563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
76564   void * jresult ;
76565   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76566
76567   {
76568     try {
76569       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
76570     } catch (std::out_of_range& e) {
76571       {
76572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76573       };
76574     } catch (std::exception& e) {
76575       {
76576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76577       };
76578     } catch (...) {
76579       {
76580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76581       };
76582     }
76583   }
76584   jresult = (void *)result;
76585   return jresult;
76586 }
76587
76588
76589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
76590   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76591   unsigned int arg2 ;
76592
76593   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76594   arg2 = (unsigned int)jarg2;
76595   if (arg1) (arg1)->rowIndex = arg2;
76596 }
76597
76598
76599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
76600   unsigned int jresult ;
76601   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76602   unsigned int result;
76603
76604   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76605   result = (unsigned int) ((arg1)->rowIndex);
76606   jresult = result;
76607   return jresult;
76608 }
76609
76610
76611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
76612   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76613   unsigned int arg2 ;
76614
76615   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76616   arg2 = (unsigned int)jarg2;
76617   if (arg1) (arg1)->columnIndex = arg2;
76618 }
76619
76620
76621 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
76622   unsigned int jresult ;
76623   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76624   unsigned int result;
76625
76626   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76627   result = (unsigned int) ((arg1)->columnIndex);
76628   jresult = result;
76629   return jresult;
76630 }
76631
76632
76633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
76634   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76635   unsigned int arg2 ;
76636
76637   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76638   arg2 = (unsigned int)jarg2;
76639   if (arg1) (arg1)->rowSpan = arg2;
76640 }
76641
76642
76643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
76644   unsigned int jresult ;
76645   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76646   unsigned int result;
76647
76648   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76649   result = (unsigned int) ((arg1)->rowSpan);
76650   jresult = result;
76651   return jresult;
76652 }
76653
76654
76655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
76656   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76657   unsigned int arg2 ;
76658
76659   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76660   arg2 = (unsigned int)jarg2;
76661   if (arg1) (arg1)->columnSpan = arg2;
76662 }
76663
76664
76665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
76666   unsigned int jresult ;
76667   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76668   unsigned int result;
76669
76670   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76671   result = (unsigned int) ((arg1)->columnSpan);
76672   jresult = result;
76673   return jresult;
76674 }
76675
76676
76677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
76678   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76679
76680   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76681   {
76682     try {
76683       delete arg1;
76684     } catch (std::out_of_range& e) {
76685       {
76686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76687       };
76688     } catch (std::exception& e) {
76689       {
76690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76691       };
76692     } catch (...) {
76693       {
76694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76695       };
76696     }
76697   }
76698 }
76699
76700
76701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
76702   void * jresult ;
76703   Dali::Toolkit::TableView *result = 0 ;
76704
76705   {
76706     try {
76707       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
76708     } catch (std::out_of_range& e) {
76709       {
76710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76711       };
76712     } catch (std::exception& e) {
76713       {
76714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76715       };
76716     } catch (...) {
76717       {
76718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76719       };
76720     }
76721   }
76722   jresult = (void *)result;
76723   return jresult;
76724 }
76725
76726
76727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
76728   void * jresult ;
76729   Dali::Toolkit::TableView *arg1 = 0 ;
76730   Dali::Toolkit::TableView *result = 0 ;
76731
76732   arg1 = (Dali::Toolkit::TableView *)jarg1;
76733   if (!arg1) {
76734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76735     return 0;
76736   }
76737   {
76738     try {
76739       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
76740     } catch (std::out_of_range& e) {
76741       {
76742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76743       };
76744     } catch (std::exception& e) {
76745       {
76746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76747       };
76748     } catch (...) {
76749       {
76750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76751       };
76752     }
76753   }
76754   jresult = (void *)result;
76755   return jresult;
76756 }
76757
76758
76759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
76760   void * jresult ;
76761   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76762   Dali::Toolkit::TableView *arg2 = 0 ;
76763   Dali::Toolkit::TableView *result = 0 ;
76764
76765   arg1 = (Dali::Toolkit::TableView *)jarg1;
76766   arg2 = (Dali::Toolkit::TableView *)jarg2;
76767   if (!arg2) {
76768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
76769     return 0;
76770   }
76771   {
76772     try {
76773       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
76774     } catch (std::out_of_range& e) {
76775       {
76776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76777       };
76778     } catch (std::exception& e) {
76779       {
76780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76781       };
76782     } catch (...) {
76783       {
76784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76785       };
76786     }
76787   }
76788   jresult = (void *)result;
76789   return jresult;
76790 }
76791
76792
76793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
76794   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76795
76796   arg1 = (Dali::Toolkit::TableView *)jarg1;
76797   {
76798     try {
76799       delete arg1;
76800     } catch (std::out_of_range& e) {
76801       {
76802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76803       };
76804     } catch (std::exception& e) {
76805       {
76806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76807       };
76808     } catch (...) {
76809       {
76810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76811       };
76812     }
76813   }
76814 }
76815
76816
76817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
76818   void * jresult ;
76819   unsigned int arg1 ;
76820   unsigned int arg2 ;
76821   Dali::Toolkit::TableView result;
76822
76823   arg1 = (unsigned int)jarg1;
76824   arg2 = (unsigned int)jarg2;
76825   {
76826     try {
76827       result = Dali::Toolkit::TableView::New(arg1,arg2);
76828     } catch (std::out_of_range& e) {
76829       {
76830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76831       };
76832     } catch (std::exception& e) {
76833       {
76834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76835       };
76836     } catch (...) {
76837       {
76838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76839       };
76840     }
76841   }
76842   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76843   return jresult;
76844 }
76845
76846
76847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
76848   void * jresult ;
76849   Dali::BaseHandle arg1 ;
76850   Dali::BaseHandle *argp1 ;
76851   Dali::Toolkit::TableView result;
76852
76853   argp1 = (Dali::BaseHandle *)jarg1;
76854   if (!argp1) {
76855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76856     return 0;
76857   }
76858   arg1 = *argp1;
76859   {
76860     try {
76861       result = Dali::Toolkit::TableView::DownCast(arg1);
76862     } catch (std::out_of_range& e) {
76863       {
76864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76865       };
76866     } catch (std::exception& e) {
76867       {
76868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76869       };
76870     } catch (...) {
76871       {
76872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76873       };
76874     }
76875   }
76876   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
76877   return jresult;
76878 }
76879
76880
76881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
76882   unsigned int jresult ;
76883   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76884   Dali::Actor arg2 ;
76885   Dali::Toolkit::TableView::CellPosition arg3 ;
76886   Dali::Actor *argp2 ;
76887   Dali::Toolkit::TableView::CellPosition *argp3 ;
76888   bool result;
76889
76890   arg1 = (Dali::Toolkit::TableView *)jarg1;
76891   argp2 = (Dali::Actor *)jarg2;
76892   if (!argp2) {
76893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76894     return 0;
76895   }
76896   arg2 = *argp2;
76897   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
76898   if (!argp3) {
76899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76900     return 0;
76901   }
76902   arg3 = *argp3;
76903   {
76904     try {
76905       result = (bool)(arg1)->AddChild(arg2,arg3);
76906     } catch (std::out_of_range& e) {
76907       {
76908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76909       };
76910     } catch (std::exception& e) {
76911       {
76912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76913       };
76914     } catch (...) {
76915       {
76916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76917       };
76918     }
76919   }
76920   jresult = result;
76921   return jresult;
76922 }
76923
76924
76925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
76926   void * jresult ;
76927   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76928   Dali::Toolkit::TableView::CellPosition arg2 ;
76929   Dali::Toolkit::TableView::CellPosition *argp2 ;
76930   Dali::Actor result;
76931
76932   arg1 = (Dali::Toolkit::TableView *)jarg1;
76933   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76934   if (!argp2) {
76935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76936     return 0;
76937   }
76938   arg2 = *argp2;
76939   {
76940     try {
76941       result = (arg1)->GetChildAt(arg2);
76942     } catch (std::out_of_range& e) {
76943       {
76944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76945       };
76946     } catch (std::exception& e) {
76947       {
76948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76949       };
76950     } catch (...) {
76951       {
76952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76953       };
76954     }
76955   }
76956   jresult = new Dali::Actor((const Dali::Actor &)result);
76957   return jresult;
76958 }
76959
76960
76961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
76962   void * jresult ;
76963   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76964   Dali::Toolkit::TableView::CellPosition arg2 ;
76965   Dali::Toolkit::TableView::CellPosition *argp2 ;
76966   Dali::Actor result;
76967
76968   arg1 = (Dali::Toolkit::TableView *)jarg1;
76969   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76970   if (!argp2) {
76971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76972     return 0;
76973   }
76974   arg2 = *argp2;
76975   {
76976     try {
76977       result = (arg1)->RemoveChildAt(arg2);
76978     } catch (std::out_of_range& e) {
76979       {
76980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76981       };
76982     } catch (std::exception& e) {
76983       {
76984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76985       };
76986     } catch (...) {
76987       {
76988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76989       };
76990     }
76991   }
76992   jresult = new Dali::Actor((const Dali::Actor &)result);
76993   return jresult;
76994 }
76995
76996
76997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
76998   unsigned int jresult ;
76999   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77000   Dali::Actor arg2 ;
77001   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77002   Dali::Actor *argp2 ;
77003   bool result;
77004
77005   arg1 = (Dali::Toolkit::TableView *)jarg1;
77006   argp2 = (Dali::Actor *)jarg2;
77007   if (!argp2) {
77008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77009     return 0;
77010   }
77011   arg2 = *argp2;
77012   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77013   if (!arg3) {
77014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77015     return 0;
77016   }
77017   {
77018     try {
77019       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77020     } catch (std::out_of_range& e) {
77021       {
77022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77023       };
77024     } catch (std::exception& e) {
77025       {
77026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77027       };
77028     } catch (...) {
77029       {
77030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77031       };
77032     }
77033   }
77034   jresult = result;
77035   return jresult;
77036 }
77037
77038
77039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77040   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77041   unsigned int arg2 ;
77042
77043   arg1 = (Dali::Toolkit::TableView *)jarg1;
77044   arg2 = (unsigned int)jarg2;
77045   {
77046     try {
77047       (arg1)->InsertRow(arg2);
77048     } catch (std::out_of_range& e) {
77049       {
77050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77051       };
77052     } catch (std::exception& e) {
77053       {
77054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77055       };
77056     } catch (...) {
77057       {
77058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77059       };
77060     }
77061   }
77062 }
77063
77064
77065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77066   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77067   unsigned int arg2 ;
77068
77069   arg1 = (Dali::Toolkit::TableView *)jarg1;
77070   arg2 = (unsigned int)jarg2;
77071   {
77072     try {
77073       (arg1)->DeleteRow(arg2);
77074     } catch (std::out_of_range& e) {
77075       {
77076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77077       };
77078     } catch (std::exception& e) {
77079       {
77080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77081       };
77082     } catch (...) {
77083       {
77084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77085       };
77086     }
77087   }
77088 }
77089
77090
77091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77092   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77093   unsigned int arg2 ;
77094   std::vector< Dali::Actor > *arg3 = 0 ;
77095
77096   arg1 = (Dali::Toolkit::TableView *)jarg1;
77097   arg2 = (unsigned int)jarg2;
77098   arg3 = (std::vector< Dali::Actor > *)jarg3;
77099   if (!arg3) {
77100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77101     return ;
77102   }
77103   {
77104     try {
77105       (arg1)->DeleteRow(arg2,*arg3);
77106     } catch (std::out_of_range& e) {
77107       {
77108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77109       };
77110     } catch (std::exception& e) {
77111       {
77112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77113       };
77114     } catch (...) {
77115       {
77116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77117       };
77118     }
77119   }
77120 }
77121
77122
77123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77124   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77125   unsigned int arg2 ;
77126
77127   arg1 = (Dali::Toolkit::TableView *)jarg1;
77128   arg2 = (unsigned int)jarg2;
77129   {
77130     try {
77131       (arg1)->InsertColumn(arg2);
77132     } catch (std::out_of_range& e) {
77133       {
77134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77135       };
77136     } catch (std::exception& e) {
77137       {
77138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77139       };
77140     } catch (...) {
77141       {
77142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77143       };
77144     }
77145   }
77146 }
77147
77148
77149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77150   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77151   unsigned int arg2 ;
77152
77153   arg1 = (Dali::Toolkit::TableView *)jarg1;
77154   arg2 = (unsigned int)jarg2;
77155   {
77156     try {
77157       (arg1)->DeleteColumn(arg2);
77158     } catch (std::out_of_range& e) {
77159       {
77160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77161       };
77162     } catch (std::exception& e) {
77163       {
77164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77165       };
77166     } catch (...) {
77167       {
77168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77169       };
77170     }
77171   }
77172 }
77173
77174
77175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77176   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77177   unsigned int arg2 ;
77178   std::vector< Dali::Actor > *arg3 = 0 ;
77179
77180   arg1 = (Dali::Toolkit::TableView *)jarg1;
77181   arg2 = (unsigned int)jarg2;
77182   arg3 = (std::vector< Dali::Actor > *)jarg3;
77183   if (!arg3) {
77184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77185     return ;
77186   }
77187   {
77188     try {
77189       (arg1)->DeleteColumn(arg2,*arg3);
77190     } catch (std::out_of_range& e) {
77191       {
77192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77193       };
77194     } catch (std::exception& e) {
77195       {
77196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77197       };
77198     } catch (...) {
77199       {
77200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77201       };
77202     }
77203   }
77204 }
77205
77206
77207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77208   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77209   unsigned int arg2 ;
77210   unsigned int arg3 ;
77211
77212   arg1 = (Dali::Toolkit::TableView *)jarg1;
77213   arg2 = (unsigned int)jarg2;
77214   arg3 = (unsigned int)jarg3;
77215   {
77216     try {
77217       (arg1)->Resize(arg2,arg3);
77218     } catch (std::out_of_range& e) {
77219       {
77220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77221       };
77222     } catch (std::exception& e) {
77223       {
77224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77225       };
77226     } catch (...) {
77227       {
77228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77229       };
77230     }
77231   }
77232 }
77233
77234
77235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77236   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77237   unsigned int arg2 ;
77238   unsigned int arg3 ;
77239   std::vector< Dali::Actor > *arg4 = 0 ;
77240
77241   arg1 = (Dali::Toolkit::TableView *)jarg1;
77242   arg2 = (unsigned int)jarg2;
77243   arg3 = (unsigned int)jarg3;
77244   arg4 = (std::vector< Dali::Actor > *)jarg4;
77245   if (!arg4) {
77246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77247     return ;
77248   }
77249   {
77250     try {
77251       (arg1)->Resize(arg2,arg3,*arg4);
77252     } catch (std::out_of_range& e) {
77253       {
77254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77255       };
77256     } catch (std::exception& e) {
77257       {
77258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77259       };
77260     } catch (...) {
77261       {
77262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77263       };
77264     }
77265   }
77266 }
77267
77268
77269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77270   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77271   Dali::Size arg2 ;
77272   Dali::Size *argp2 ;
77273
77274   arg1 = (Dali::Toolkit::TableView *)jarg1;
77275   argp2 = (Dali::Size *)jarg2;
77276   if (!argp2) {
77277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77278     return ;
77279   }
77280   arg2 = *argp2;
77281   {
77282     try {
77283       (arg1)->SetCellPadding(arg2);
77284     } catch (std::out_of_range& e) {
77285       {
77286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77287       };
77288     } catch (std::exception& e) {
77289       {
77290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77291       };
77292     } catch (...) {
77293       {
77294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77295       };
77296     }
77297   }
77298 }
77299
77300
77301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77302   void * jresult ;
77303   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77304   Dali::Size result;
77305
77306   arg1 = (Dali::Toolkit::TableView *)jarg1;
77307   {
77308     try {
77309       result = (arg1)->GetCellPadding();
77310     } catch (std::out_of_range& e) {
77311       {
77312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77313       };
77314     } catch (std::exception& e) {
77315       {
77316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77317       };
77318     } catch (...) {
77319       {
77320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77321       };
77322     }
77323   }
77324   jresult = new Dali::Size((const Dali::Size &)result);
77325   return jresult;
77326 }
77327
77328
77329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77330   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77331   unsigned int arg2 ;
77332
77333   arg1 = (Dali::Toolkit::TableView *)jarg1;
77334   arg2 = (unsigned int)jarg2;
77335   {
77336     try {
77337       (arg1)->SetFitHeight(arg2);
77338     } catch (std::out_of_range& e) {
77339       {
77340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77341       };
77342     } catch (std::exception& e) {
77343       {
77344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77345       };
77346     } catch (...) {
77347       {
77348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77349       };
77350     }
77351   }
77352 }
77353
77354
77355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77356   unsigned int jresult ;
77357   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77358   unsigned int arg2 ;
77359   bool result;
77360
77361   arg1 = (Dali::Toolkit::TableView *)jarg1;
77362   arg2 = (unsigned int)jarg2;
77363   {
77364     try {
77365       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77366     } catch (std::out_of_range& e) {
77367       {
77368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77369       };
77370     } catch (std::exception& e) {
77371       {
77372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77373       };
77374     } catch (...) {
77375       {
77376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77377       };
77378     }
77379   }
77380   jresult = result;
77381   return jresult;
77382 }
77383
77384
77385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
77386   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77387   unsigned int arg2 ;
77388
77389   arg1 = (Dali::Toolkit::TableView *)jarg1;
77390   arg2 = (unsigned int)jarg2;
77391   {
77392     try {
77393       (arg1)->SetFitWidth(arg2);
77394     } catch (std::out_of_range& e) {
77395       {
77396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77397       };
77398     } catch (std::exception& e) {
77399       {
77400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77401       };
77402     } catch (...) {
77403       {
77404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77405       };
77406     }
77407   }
77408 }
77409
77410
77411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77412   unsigned int jresult ;
77413   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77414   unsigned int arg2 ;
77415   bool result;
77416
77417   arg1 = (Dali::Toolkit::TableView *)jarg1;
77418   arg2 = (unsigned int)jarg2;
77419   {
77420     try {
77421       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
77422     } catch (std::out_of_range& e) {
77423       {
77424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77425       };
77426     } catch (std::exception& e) {
77427       {
77428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77429       };
77430     } catch (...) {
77431       {
77432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77433       };
77434     }
77435   }
77436   jresult = result;
77437   return jresult;
77438 }
77439
77440
77441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77442   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77443   unsigned int arg2 ;
77444   float arg3 ;
77445
77446   arg1 = (Dali::Toolkit::TableView *)jarg1;
77447   arg2 = (unsigned int)jarg2;
77448   arg3 = (float)jarg3;
77449   {
77450     try {
77451       (arg1)->SetFixedHeight(arg2,arg3);
77452     } catch (std::out_of_range& e) {
77453       {
77454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77455       };
77456     } catch (std::exception& e) {
77457       {
77458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77459       };
77460     } catch (...) {
77461       {
77462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77463       };
77464     }
77465   }
77466 }
77467
77468
77469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
77470   float jresult ;
77471   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77472   unsigned int arg2 ;
77473   float result;
77474
77475   arg1 = (Dali::Toolkit::TableView *)jarg1;
77476   arg2 = (unsigned int)jarg2;
77477   {
77478     try {
77479       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
77480     } catch (std::out_of_range& e) {
77481       {
77482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77483       };
77484     } catch (std::exception& e) {
77485       {
77486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77487       };
77488     } catch (...) {
77489       {
77490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77491       };
77492     }
77493   }
77494   jresult = result;
77495   return jresult;
77496 }
77497
77498
77499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77500   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77501   unsigned int arg2 ;
77502   float arg3 ;
77503
77504   arg1 = (Dali::Toolkit::TableView *)jarg1;
77505   arg2 = (unsigned int)jarg2;
77506   arg3 = (float)jarg3;
77507   {
77508     try {
77509       (arg1)->SetRelativeHeight(arg2,arg3);
77510     } catch (std::out_of_range& e) {
77511       {
77512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77513       };
77514     } catch (std::exception& e) {
77515       {
77516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77517       };
77518     } catch (...) {
77519       {
77520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77521       };
77522     }
77523   }
77524 }
77525
77526
77527 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
77528   float jresult ;
77529   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77530   unsigned int arg2 ;
77531   float result;
77532
77533   arg1 = (Dali::Toolkit::TableView *)jarg1;
77534   arg2 = (unsigned int)jarg2;
77535   {
77536     try {
77537       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
77538     } catch (std::out_of_range& e) {
77539       {
77540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77541       };
77542     } catch (std::exception& e) {
77543       {
77544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77545       };
77546     } catch (...) {
77547       {
77548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77549       };
77550     }
77551   }
77552   jresult = result;
77553   return jresult;
77554 }
77555
77556
77557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77558   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77559   unsigned int arg2 ;
77560   float arg3 ;
77561
77562   arg1 = (Dali::Toolkit::TableView *)jarg1;
77563   arg2 = (unsigned int)jarg2;
77564   arg3 = (float)jarg3;
77565   {
77566     try {
77567       (arg1)->SetFixedWidth(arg2,arg3);
77568     } catch (std::out_of_range& e) {
77569       {
77570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77571       };
77572     } catch (std::exception& e) {
77573       {
77574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77575       };
77576     } catch (...) {
77577       {
77578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77579       };
77580     }
77581   }
77582 }
77583
77584
77585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
77586   float jresult ;
77587   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77588   unsigned int arg2 ;
77589   float result;
77590
77591   arg1 = (Dali::Toolkit::TableView *)jarg1;
77592   arg2 = (unsigned int)jarg2;
77593   {
77594     try {
77595       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
77596     } catch (std::out_of_range& e) {
77597       {
77598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77599       };
77600     } catch (std::exception& e) {
77601       {
77602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77603       };
77604     } catch (...) {
77605       {
77606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77607       };
77608     }
77609   }
77610   jresult = result;
77611   return jresult;
77612 }
77613
77614
77615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77616   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77617   unsigned int arg2 ;
77618   float arg3 ;
77619
77620   arg1 = (Dali::Toolkit::TableView *)jarg1;
77621   arg2 = (unsigned int)jarg2;
77622   arg3 = (float)jarg3;
77623   {
77624     try {
77625       (arg1)->SetRelativeWidth(arg2,arg3);
77626     } catch (std::out_of_range& e) {
77627       {
77628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77629       };
77630     } catch (std::exception& e) {
77631       {
77632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77633       };
77634     } catch (...) {
77635       {
77636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77637       };
77638     }
77639   }
77640 }
77641
77642
77643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
77644   float jresult ;
77645   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77646   unsigned int arg2 ;
77647   float result;
77648
77649   arg1 = (Dali::Toolkit::TableView *)jarg1;
77650   arg2 = (unsigned int)jarg2;
77651   {
77652     try {
77653       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
77654     } catch (std::out_of_range& e) {
77655       {
77656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77657       };
77658     } catch (std::exception& e) {
77659       {
77660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77661       };
77662     } catch (...) {
77663       {
77664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77665       };
77666     }
77667   }
77668   jresult = result;
77669   return jresult;
77670 }
77671
77672
77673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
77674   unsigned int jresult ;
77675   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77676   unsigned int result;
77677
77678   arg1 = (Dali::Toolkit::TableView *)jarg1;
77679   {
77680     try {
77681       result = (unsigned int)(arg1)->GetRows();
77682     } catch (std::out_of_range& e) {
77683       {
77684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77685       };
77686     } catch (std::exception& e) {
77687       {
77688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77689       };
77690     } catch (...) {
77691       {
77692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77693       };
77694     }
77695   }
77696   jresult = result;
77697   return jresult;
77698 }
77699
77700
77701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
77702   unsigned int jresult ;
77703   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77704   unsigned int result;
77705
77706   arg1 = (Dali::Toolkit::TableView *)jarg1;
77707   {
77708     try {
77709       result = (unsigned int)(arg1)->GetColumns();
77710     } catch (std::out_of_range& e) {
77711       {
77712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77713       };
77714     } catch (std::exception& e) {
77715       {
77716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77717       };
77718     } catch (...) {
77719       {
77720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77721       };
77722     }
77723   }
77724   jresult = result;
77725   return jresult;
77726 }
77727
77728
77729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
77730   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77731   Dali::Toolkit::TableView::CellPosition arg2 ;
77732   Dali::HorizontalAlignment::Type arg3 ;
77733   Dali::VerticalAlignment::Type arg4 ;
77734   Dali::Toolkit::TableView::CellPosition *argp2 ;
77735
77736   arg1 = (Dali::Toolkit::TableView *)jarg1;
77737   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77738   if (!argp2) {
77739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77740     return ;
77741   }
77742   arg2 = *argp2;
77743   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
77744   arg4 = (Dali::VerticalAlignment::Type)jarg4;
77745   {
77746     try {
77747       (arg1)->SetCellAlignment(arg2,arg3,arg4);
77748     } catch (std::out_of_range& e) {
77749       {
77750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77751       };
77752     } catch (std::exception& e) {
77753       {
77754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77755       };
77756     } catch (...) {
77757       {
77758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77759       };
77760     }
77761   }
77762 }
77763
77764
77765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
77766   unsigned int jresult ;
77767   unsigned int result;
77768
77769   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
77770   jresult = result;
77771   return jresult;
77772 }
77773
77774
77775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
77776   int jresult ;
77777   int result;
77778
77779   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
77780   jresult = (int)result;
77781   return jresult;
77782 }
77783
77784
77785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
77786   int jresult ;
77787   int result;
77788
77789   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
77790   jresult = (int)result;
77791   return jresult;
77792 }
77793
77794
77795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
77796   int jresult ;
77797   int result;
77798
77799   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
77800   jresult = (int)result;
77801   return jresult;
77802 }
77803
77804
77805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
77806   int jresult ;
77807   int result;
77808
77809   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
77810   jresult = (int)result;
77811   return jresult;
77812 }
77813
77814
77815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
77816   int jresult ;
77817   int result;
77818
77819   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
77820   jresult = (int)result;
77821   return jresult;
77822 }
77823
77824
77825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
77826   int jresult ;
77827   int result;
77828
77829   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
77830   jresult = (int)result;
77831   return jresult;
77832 }
77833
77834
77835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
77836   int jresult ;
77837   int result;
77838
77839   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
77840   jresult = (int)result;
77841   return jresult;
77842 }
77843
77844
77845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
77846   int jresult ;
77847   int result;
77848
77849   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
77850   jresult = (int)result;
77851   return jresult;
77852 }
77853
77854
77855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
77856   int jresult ;
77857   int result;
77858
77859   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
77860   jresult = (int)result;
77861   return jresult;
77862 }
77863
77864
77865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
77866   int jresult ;
77867   int result;
77868
77869   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
77870   jresult = (int)result;
77871   return jresult;
77872 }
77873
77874
77875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
77876   int jresult ;
77877   int result;
77878
77879   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
77880   jresult = (int)result;
77881   return jresult;
77882 }
77883
77884
77885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
77886   int jresult ;
77887   int result;
77888
77889   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
77890   jresult = (int)result;
77891   return jresult;
77892 }
77893
77894
77895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
77896   int jresult ;
77897   int result;
77898
77899   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
77900   jresult = (int)result;
77901   return jresult;
77902 }
77903
77904
77905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
77906   int jresult ;
77907   int result;
77908
77909   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
77910   jresult = (int)result;
77911   return jresult;
77912 }
77913
77914
77915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
77916   int jresult ;
77917   int result;
77918
77919   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
77920   jresult = (int)result;
77921   return jresult;
77922 }
77923
77924
77925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
77926   int jresult ;
77927   int result;
77928
77929   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
77930   jresult = (int)result;
77931   return jresult;
77932 }
77933
77934
77935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77936   int jresult ;
77937   int result;
77938
77939   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
77940   jresult = (int)result;
77941   return jresult;
77942 }
77943
77944
77945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77946   int jresult ;
77947   int result;
77948
77949   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
77950   jresult = (int)result;
77951   return jresult;
77952 }
77953
77954
77955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77956   int jresult ;
77957   int result;
77958
77959   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77960   jresult = (int)result;
77961   return jresult;
77962 }
77963
77964
77965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77966   int jresult ;
77967   int result;
77968
77969   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77970   jresult = (int)result;
77971   return jresult;
77972 }
77973
77974
77975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77976   int jresult ;
77977   int result;
77978
77979   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77980   jresult = (int)result;
77981   return jresult;
77982 }
77983
77984
77985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77986   int jresult ;
77987   int result;
77988
77989   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77990   jresult = (int)result;
77991   return jresult;
77992 }
77993
77994
77995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77996   int jresult ;
77997   int result;
77998
77999   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
78000   jresult = (int)result;
78001   return jresult;
78002 }
78003
78004
78005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
78006   int jresult ;
78007   int result;
78008
78009   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
78010   jresult = (int)result;
78011   return jresult;
78012 }
78013
78014
78015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
78016   int jresult ;
78017   int result;
78018
78019   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
78020   jresult = (int)result;
78021   return jresult;
78022 }
78023
78024
78025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
78026   int jresult ;
78027   int result;
78028
78029   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
78030   jresult = (int)result;
78031   return jresult;
78032 }
78033
78034
78035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
78036   int jresult ;
78037   int result;
78038
78039   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
78040   jresult = (int)result;
78041   return jresult;
78042 }
78043
78044
78045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
78046   int jresult ;
78047   int result;
78048
78049   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
78050   jresult = (int)result;
78051   return jresult;
78052 }
78053
78054
78055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
78056   int jresult ;
78057   int result;
78058
78059   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
78060   jresult = (int)result;
78061   return jresult;
78062 }
78063
78064
78065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
78066   int jresult ;
78067   int result;
78068
78069   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
78070   jresult = (int)result;
78071   return jresult;
78072 }
78073
78074
78075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
78076   int jresult ;
78077   int result;
78078
78079   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
78080   jresult = (int)result;
78081   return jresult;
78082 }
78083
78084
78085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
78086   int jresult ;
78087   int result;
78088
78089   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
78090   jresult = (int)result;
78091   return jresult;
78092 }
78093
78094
78095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
78096   int jresult ;
78097   int result;
78098
78099   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
78100   jresult = (int)result;
78101   return jresult;
78102 }
78103
78104
78105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
78106   int jresult ;
78107   int result;
78108
78109   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
78110   jresult = (int)result;
78111   return jresult;
78112 }
78113
78114
78115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
78116   int jresult ;
78117   int result;
78118
78119   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
78120   jresult = (int)result;
78121   return jresult;
78122 }
78123
78124
78125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
78126   int jresult ;
78127   int result;
78128
78129   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
78130   jresult = (int)result;
78131   return jresult;
78132 }
78133
78134
78135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
78136   int jresult ;
78137   int result;
78138
78139   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
78140   jresult = (int)result;
78141   return jresult;
78142 }
78143
78144
78145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
78146   int jresult ;
78147   int result;
78148
78149   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
78150   jresult = (int)result;
78151   return jresult;
78152 }
78153
78154
78155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
78156   int jresult ;
78157   int result;
78158
78159   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
78160   jresult = (int)result;
78161   return jresult;
78162 }
78163
78164
78165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
78166   int jresult ;
78167   int result;
78168
78169   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
78170   jresult = (int)result;
78171   return jresult;
78172 }
78173
78174
78175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
78176   void * jresult ;
78177   Dali::Toolkit::TextEditor::Property *result = 0 ;
78178
78179   {
78180     try {
78181       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
78182     } catch (std::out_of_range& e) {
78183       {
78184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78185       };
78186     } catch (std::exception& e) {
78187       {
78188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78189       };
78190     } catch (...) {
78191       {
78192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78193       };
78194     }
78195   }
78196   jresult = (void *)result;
78197   return jresult;
78198 }
78199
78200
78201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
78202   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
78203
78204   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
78205   {
78206     try {
78207       delete arg1;
78208     } catch (std::out_of_range& e) {
78209       {
78210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78211       };
78212     } catch (std::exception& e) {
78213       {
78214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78215       };
78216     } catch (...) {
78217       {
78218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78219       };
78220     }
78221   }
78222 }
78223
78224
78225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
78226   void * jresult ;
78227   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
78228
78229   {
78230     try {
78231       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
78232     } catch (std::out_of_range& e) {
78233       {
78234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78235       };
78236     } catch (std::exception& e) {
78237       {
78238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78239       };
78240     } catch (...) {
78241       {
78242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78243       };
78244     }
78245   }
78246   jresult = (void *)result;
78247   return jresult;
78248 }
78249
78250
78251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
78252   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
78253
78254   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
78255   {
78256     try {
78257       delete arg1;
78258     } catch (std::out_of_range& e) {
78259       {
78260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78261       };
78262     } catch (std::exception& e) {
78263       {
78264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78265       };
78266     } catch (...) {
78267       {
78268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78269       };
78270     }
78271   }
78272 }
78273
78274
78275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
78276   void * jresult ;
78277   Dali::Toolkit::TextEditor result;
78278
78279   {
78280     try {
78281       result = Dali::Toolkit::TextEditor::New();
78282     } catch (std::out_of_range& e) {
78283       {
78284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78285       };
78286     } catch (std::exception& e) {
78287       {
78288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78289       };
78290     } catch (...) {
78291       {
78292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78293       };
78294     }
78295   }
78296   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78297   return jresult;
78298 }
78299
78300
78301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
78302   void * jresult ;
78303   Dali::Toolkit::TextEditor *result = 0 ;
78304
78305   {
78306     try {
78307       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
78308     } catch (std::out_of_range& e) {
78309       {
78310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78311       };
78312     } catch (std::exception& e) {
78313       {
78314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78315       };
78316     } catch (...) {
78317       {
78318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78319       };
78320     }
78321   }
78322   jresult = (void *)result;
78323   return jresult;
78324 }
78325
78326
78327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
78328   void * jresult ;
78329   Dali::Toolkit::TextEditor *arg1 = 0 ;
78330   Dali::Toolkit::TextEditor *result = 0 ;
78331
78332   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78333   if (!arg1) {
78334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78335     return 0;
78336   }
78337   {
78338     try {
78339       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
78340     } catch (std::out_of_range& e) {
78341       {
78342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78343       };
78344     } catch (std::exception& e) {
78345       {
78346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78347       };
78348     } catch (...) {
78349       {
78350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78351       };
78352     }
78353   }
78354   jresult = (void *)result;
78355   return jresult;
78356 }
78357
78358
78359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
78360   void * jresult ;
78361   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78362   Dali::Toolkit::TextEditor *arg2 = 0 ;
78363   Dali::Toolkit::TextEditor *result = 0 ;
78364
78365   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78366   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
78367   if (!arg2) {
78368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
78369     return 0;
78370   }
78371   {
78372     try {
78373       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
78374     } catch (std::out_of_range& e) {
78375       {
78376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78377       };
78378     } catch (std::exception& e) {
78379       {
78380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78381       };
78382     } catch (...) {
78383       {
78384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78385       };
78386     }
78387   }
78388   jresult = (void *)result;
78389   return jresult;
78390 }
78391
78392
78393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
78394   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78395
78396   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78397   {
78398     try {
78399       delete arg1;
78400     } catch (std::out_of_range& e) {
78401       {
78402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78403       };
78404     } catch (std::exception& e) {
78405       {
78406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78407       };
78408     } catch (...) {
78409       {
78410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78411       };
78412     }
78413   }
78414 }
78415
78416
78417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
78418   void * jresult ;
78419   Dali::BaseHandle arg1 ;
78420   Dali::BaseHandle *argp1 ;
78421   Dali::Toolkit::TextEditor result;
78422
78423   argp1 = (Dali::BaseHandle *)jarg1;
78424   if (!argp1) {
78425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78426     return 0;
78427   }
78428   arg1 = *argp1;
78429   {
78430     try {
78431       result = Dali::Toolkit::TextEditor::DownCast(arg1);
78432     } catch (std::out_of_range& e) {
78433       {
78434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78435       };
78436     } catch (std::exception& e) {
78437       {
78438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78439       };
78440     } catch (...) {
78441       {
78442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78443       };
78444     }
78445   }
78446   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
78447   return jresult;
78448 }
78449
78450
78451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
78452   void * jresult ;
78453   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78454   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
78455
78456   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78457   {
78458     try {
78459       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78460     } catch (std::out_of_range& e) {
78461       {
78462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78463       };
78464     } catch (std::exception& e) {
78465       {
78466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78467       };
78468     } catch (...) {
78469       {
78470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78471       };
78472     }
78473   }
78474   jresult = (void *)result;
78475   return jresult;
78476 }
78477
78478
78479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
78480   void * jresult ;
78481   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
78482   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
78483
78484   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
78485   {
78486     try {
78487       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78488     } catch (std::out_of_range& e) {
78489       {
78490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78491       };
78492     } catch (std::exception& e) {
78493       {
78494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78495       };
78496     } catch (...) {
78497       {
78498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78499       };
78500     }
78501   }
78502   jresult = (void *)result;
78503   return jresult;
78504 }
78505
78506
78507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
78508   int jresult ;
78509   int result;
78510
78511   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
78512   jresult = (int)result;
78513   return jresult;
78514 }
78515
78516
78517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
78518   int jresult ;
78519   int result;
78520
78521   result = (int)Dali::Toolkit::TextField::Property::TEXT;
78522   jresult = (int)result;
78523   return jresult;
78524 }
78525
78526
78527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
78528   int jresult ;
78529   int result;
78530
78531   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
78532   jresult = (int)result;
78533   return jresult;
78534 }
78535
78536
78537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
78538   int jresult ;
78539   int result;
78540
78541   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
78542   jresult = (int)result;
78543   return jresult;
78544 }
78545
78546
78547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
78548   int jresult ;
78549   int result;
78550
78551   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
78552   jresult = (int)result;
78553   return jresult;
78554 }
78555
78556
78557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
78558   int jresult ;
78559   int result;
78560
78561   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
78562   jresult = (int)result;
78563   return jresult;
78564 }
78565
78566
78567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
78568   int jresult ;
78569   int result;
78570
78571   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
78572   jresult = (int)result;
78573   return jresult;
78574 }
78575
78576
78577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
78578   int jresult ;
78579   int result;
78580
78581   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
78582   jresult = (int)result;
78583   return jresult;
78584 }
78585
78586
78587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
78588   int jresult ;
78589   int result;
78590
78591   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
78592   jresult = (int)result;
78593   return jresult;
78594 }
78595
78596
78597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
78598   int jresult ;
78599   int result;
78600
78601   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
78602   jresult = (int)result;
78603   return jresult;
78604 }
78605
78606
78607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
78608   int jresult ;
78609   int result;
78610
78611   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
78612   jresult = (int)result;
78613   return jresult;
78614 }
78615
78616
78617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
78618   int jresult ;
78619   int result;
78620
78621   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
78622   jresult = (int)result;
78623   return jresult;
78624 }
78625
78626
78627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
78628   int jresult ;
78629   int result;
78630
78631   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
78632   jresult = (int)result;
78633   return jresult;
78634 }
78635
78636
78637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
78638   int jresult ;
78639   int result;
78640
78641   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
78642   jresult = (int)result;
78643   return jresult;
78644 }
78645
78646
78647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
78648   int jresult ;
78649   int result;
78650
78651   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
78652   jresult = (int)result;
78653   return jresult;
78654 }
78655
78656
78657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
78658   int jresult ;
78659   int result;
78660
78661   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
78662   jresult = (int)result;
78663   return jresult;
78664 }
78665
78666
78667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
78668   int jresult ;
78669   int result;
78670
78671   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
78672   jresult = (int)result;
78673   return jresult;
78674 }
78675
78676
78677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
78678   int jresult ;
78679   int result;
78680
78681   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
78682   jresult = (int)result;
78683   return jresult;
78684 }
78685
78686
78687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
78688   int jresult ;
78689   int result;
78690
78691   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
78692   jresult = (int)result;
78693   return jresult;
78694 }
78695
78696
78697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
78698   int jresult ;
78699   int result;
78700
78701   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
78702   jresult = (int)result;
78703   return jresult;
78704 }
78705
78706
78707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
78708   int jresult ;
78709   int result;
78710
78711   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
78712   jresult = (int)result;
78713   return jresult;
78714 }
78715
78716
78717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
78718   int jresult ;
78719   int result;
78720
78721   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
78722   jresult = (int)result;
78723   return jresult;
78724 }
78725
78726
78727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
78728   int jresult ;
78729   int result;
78730
78731   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
78732   jresult = (int)result;
78733   return jresult;
78734 }
78735
78736
78737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
78738   int jresult ;
78739   int result;
78740
78741   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
78742   jresult = (int)result;
78743   return jresult;
78744 }
78745
78746
78747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
78748   int jresult ;
78749   int result;
78750
78751   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
78752   jresult = (int)result;
78753   return jresult;
78754 }
78755
78756
78757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
78758   int jresult ;
78759   int result;
78760
78761   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
78762   jresult = (int)result;
78763   return jresult;
78764 }
78765
78766
78767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
78768   int jresult ;
78769   int result;
78770
78771   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
78772   jresult = (int)result;
78773   return jresult;
78774 }
78775
78776
78777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
78778   int jresult ;
78779   int result;
78780
78781   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
78782   jresult = (int)result;
78783   return jresult;
78784 }
78785
78786
78787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
78788   int jresult ;
78789   int result;
78790
78791   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
78792   jresult = (int)result;
78793   return jresult;
78794 }
78795
78796
78797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
78798   int jresult ;
78799   int result;
78800
78801   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
78802   jresult = (int)result;
78803   return jresult;
78804 }
78805
78806
78807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
78808   int jresult ;
78809   int result;
78810
78811   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
78812   jresult = (int)result;
78813   return jresult;
78814 }
78815
78816
78817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
78818   int jresult ;
78819   int result;
78820
78821   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
78822   jresult = (int)result;
78823   return jresult;
78824 }
78825
78826
78827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
78828   int jresult ;
78829   int result;
78830
78831   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
78832   jresult = (int)result;
78833   return jresult;
78834 }
78835
78836
78837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
78838   int jresult ;
78839   int result;
78840
78841   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
78842   jresult = (int)result;
78843   return jresult;
78844 }
78845
78846
78847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
78848   int jresult ;
78849   int result;
78850
78851   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
78852   jresult = (int)result;
78853   return jresult;
78854 }
78855
78856
78857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
78858   int jresult ;
78859   int result;
78860
78861   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
78862   jresult = (int)result;
78863   return jresult;
78864 }
78865
78866
78867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
78868   int jresult ;
78869   int result;
78870
78871   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
78872   jresult = (int)result;
78873   return jresult;
78874 }
78875
78876
78877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
78878   int jresult ;
78879   int result;
78880
78881   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
78882   jresult = (int)result;
78883   return jresult;
78884 }
78885
78886
78887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
78888   int jresult ;
78889   int result;
78890
78891   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
78892   jresult = (int)result;
78893   return jresult;
78894 }
78895
78896
78897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
78898   int jresult ;
78899   int result;
78900
78901   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
78902   jresult = (int)result;
78903   return jresult;
78904 }
78905
78906
78907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
78908   int jresult ;
78909   int result;
78910
78911   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
78912   jresult = (int)result;
78913   return jresult;
78914 }
78915
78916
78917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
78918   int jresult ;
78919   int result;
78920
78921   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
78922   jresult = (int)result;
78923   return jresult;
78924 }
78925
78926
78927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
78928   int jresult ;
78929   int result;
78930
78931   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
78932   jresult = (int)result;
78933   return jresult;
78934 }
78935
78936
78937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
78938   int jresult ;
78939   int result;
78940
78941   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
78942   jresult = (int)result;
78943   return jresult;
78944 }
78945
78946
78947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
78948   int jresult ;
78949   int result;
78950
78951   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
78952   jresult = (int)result;
78953   return jresult;
78954 }
78955
78956
78957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
78958   int jresult ;
78959   int result;
78960
78961   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
78962   jresult = (int)result;
78963   return jresult;
78964 }
78965
78966
78967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
78968   int jresult ;
78969   int result;
78970
78971   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
78972   jresult = (int)result;
78973   return jresult;
78974 }
78975
78976
78977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
78978   void * jresult ;
78979   Dali::Toolkit::TextField::Property *result = 0 ;
78980
78981   {
78982     try {
78983       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
78984     } catch (std::out_of_range& e) {
78985       {
78986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78987       };
78988     } catch (std::exception& e) {
78989       {
78990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78991       };
78992     } catch (...) {
78993       {
78994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78995       };
78996     }
78997   }
78998   jresult = (void *)result;
78999   return jresult;
79000 }
79001
79002
79003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
79004   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
79005
79006   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
79007   {
79008     try {
79009       delete arg1;
79010     } catch (std::out_of_range& e) {
79011       {
79012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79013       };
79014     } catch (std::exception& e) {
79015       {
79016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79017       };
79018     } catch (...) {
79019       {
79020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79021       };
79022     }
79023   }
79024 }
79025
79026
79027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
79028   void * jresult ;
79029   Dali::Toolkit::TextField::InputStyle *result = 0 ;
79030
79031   {
79032     try {
79033       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
79034     } catch (std::out_of_range& e) {
79035       {
79036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79037       };
79038     } catch (std::exception& e) {
79039       {
79040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79041       };
79042     } catch (...) {
79043       {
79044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79045       };
79046     }
79047   }
79048   jresult = (void *)result;
79049   return jresult;
79050 }
79051
79052
79053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
79054   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
79055
79056   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
79057   {
79058     try {
79059       delete arg1;
79060     } catch (std::out_of_range& e) {
79061       {
79062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79063       };
79064     } catch (std::exception& e) {
79065       {
79066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79067       };
79068     } catch (...) {
79069       {
79070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79071       };
79072     }
79073   }
79074 }
79075
79076
79077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
79078   void * jresult ;
79079   Dali::Toolkit::TextField result;
79080
79081   {
79082     try {
79083       result = Dali::Toolkit::TextField::New();
79084     } catch (std::out_of_range& e) {
79085       {
79086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79087       };
79088     } catch (std::exception& e) {
79089       {
79090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79091       };
79092     } catch (...) {
79093       {
79094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79095       };
79096     }
79097   }
79098   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
79099   return jresult;
79100 }
79101
79102
79103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
79104   void * jresult ;
79105   Dali::Toolkit::TextField *result = 0 ;
79106
79107   {
79108     try {
79109       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
79110     } catch (std::out_of_range& e) {
79111       {
79112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79113       };
79114     } catch (std::exception& e) {
79115       {
79116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79117       };
79118     } catch (...) {
79119       {
79120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79121       };
79122     }
79123   }
79124   jresult = (void *)result;
79125   return jresult;
79126 }
79127
79128
79129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
79130   void * jresult ;
79131   Dali::Toolkit::TextField *arg1 = 0 ;
79132   Dali::Toolkit::TextField *result = 0 ;
79133
79134   arg1 = (Dali::Toolkit::TextField *)jarg1;
79135   if (!arg1) {
79136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79137     return 0;
79138   }
79139   {
79140     try {
79141       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
79142     } catch (std::out_of_range& e) {
79143       {
79144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79145       };
79146     } catch (std::exception& e) {
79147       {
79148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79149       };
79150     } catch (...) {
79151       {
79152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79153       };
79154     }
79155   }
79156   jresult = (void *)result;
79157   return jresult;
79158 }
79159
79160
79161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
79162   void * jresult ;
79163   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79164   Dali::Toolkit::TextField *arg2 = 0 ;
79165   Dali::Toolkit::TextField *result = 0 ;
79166
79167   arg1 = (Dali::Toolkit::TextField *)jarg1;
79168   arg2 = (Dali::Toolkit::TextField *)jarg2;
79169   if (!arg2) {
79170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
79171     return 0;
79172   }
79173   {
79174     try {
79175       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
79176     } catch (std::out_of_range& e) {
79177       {
79178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79179       };
79180     } catch (std::exception& e) {
79181       {
79182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79183       };
79184     } catch (...) {
79185       {
79186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79187       };
79188     }
79189   }
79190   jresult = (void *)result;
79191   return jresult;
79192 }
79193
79194
79195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
79196   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79197
79198   arg1 = (Dali::Toolkit::TextField *)jarg1;
79199   {
79200     try {
79201       delete arg1;
79202     } catch (std::out_of_range& e) {
79203       {
79204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79205       };
79206     } catch (std::exception& e) {
79207       {
79208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79209       };
79210     } catch (...) {
79211       {
79212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79213       };
79214     }
79215   }
79216 }
79217
79218
79219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
79220   void * jresult ;
79221   Dali::BaseHandle arg1 ;
79222   Dali::BaseHandle *argp1 ;
79223   Dali::Toolkit::TextField result;
79224
79225   argp1 = (Dali::BaseHandle *)jarg1;
79226   if (!argp1) {
79227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79228     return 0;
79229   }
79230   arg1 = *argp1;
79231   {
79232     try {
79233       result = Dali::Toolkit::TextField::DownCast(arg1);
79234     } catch (std::out_of_range& e) {
79235       {
79236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79237       };
79238     } catch (std::exception& e) {
79239       {
79240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79241       };
79242     } catch (...) {
79243       {
79244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79245       };
79246     }
79247   }
79248   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
79249   return jresult;
79250 }
79251
79252
79253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
79254   void * jresult ;
79255   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79256   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
79257
79258   arg1 = (Dali::Toolkit::TextField *)jarg1;
79259   {
79260     try {
79261       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
79262     } catch (std::out_of_range& e) {
79263       {
79264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79265       };
79266     } catch (std::exception& e) {
79267       {
79268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79269       };
79270     } catch (...) {
79271       {
79272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79273       };
79274     }
79275   }
79276   jresult = (void *)result;
79277   return jresult;
79278 }
79279
79280
79281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
79282   void * jresult ;
79283   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79284   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
79285
79286   arg1 = (Dali::Toolkit::TextField *)jarg1;
79287   {
79288     try {
79289       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
79290     } catch (std::out_of_range& e) {
79291       {
79292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79293       };
79294     } catch (std::exception& e) {
79295       {
79296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79297       };
79298     } catch (...) {
79299       {
79300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79301       };
79302     }
79303   }
79304   jresult = (void *)result;
79305   return jresult;
79306 }
79307
79308
79309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
79310   void * jresult ;
79311   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
79312   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
79313
79314   arg1 = (Dali::Toolkit::TextField *)jarg1;
79315   {
79316     try {
79317       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
79318     } catch (std::out_of_range& e) {
79319       {
79320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79321       };
79322     } catch (std::exception& e) {
79323       {
79324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79325       };
79326     } catch (...) {
79327       {
79328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79329       };
79330     }
79331   }
79332   jresult = (void *)result;
79333   return jresult;
79334 }
79335
79336
79337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
79338   int jresult ;
79339   int result;
79340
79341   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
79342   jresult = (int)result;
79343   return jresult;
79344 }
79345
79346
79347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
79348   int jresult ;
79349   int result;
79350
79351   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
79352   jresult = (int)result;
79353   return jresult;
79354 }
79355
79356
79357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
79358   int jresult ;
79359   int result;
79360
79361   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
79362   jresult = (int)result;
79363   return jresult;
79364 }
79365
79366
79367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
79368   int jresult ;
79369   int result;
79370
79371   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
79372   jresult = (int)result;
79373   return jresult;
79374 }
79375
79376
79377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
79378   int jresult ;
79379   int result;
79380
79381   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
79382   jresult = (int)result;
79383   return jresult;
79384 }
79385
79386
79387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
79388   int jresult ;
79389   int result;
79390
79391   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
79392   jresult = (int)result;
79393   return jresult;
79394 }
79395
79396
79397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
79398   int jresult ;
79399   int result;
79400
79401   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
79402   jresult = (int)result;
79403   return jresult;
79404 }
79405
79406
79407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
79408   int jresult ;
79409   int result;
79410
79411   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
79412   jresult = (int)result;
79413   return jresult;
79414 }
79415
79416
79417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
79418   int jresult ;
79419   int result;
79420
79421   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
79422   jresult = (int)result;
79423   return jresult;
79424 }
79425
79426
79427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
79428   int jresult ;
79429   int result;
79430
79431   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
79432   jresult = (int)result;
79433   return jresult;
79434 }
79435
79436
79437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
79438   int jresult ;
79439   int result;
79440
79441   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
79442   jresult = (int)result;
79443   return jresult;
79444 }
79445
79446
79447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
79448   int jresult ;
79449   int result;
79450
79451   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
79452   jresult = (int)result;
79453   return jresult;
79454 }
79455
79456
79457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
79458   int jresult ;
79459   int result;
79460
79461   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
79462   jresult = (int)result;
79463   return jresult;
79464 }
79465
79466
79467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
79468   int jresult ;
79469   int result;
79470
79471   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
79472   jresult = (int)result;
79473   return jresult;
79474 }
79475
79476
79477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
79478   int jresult ;
79479   int result;
79480
79481   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
79482   jresult = (int)result;
79483   return jresult;
79484 }
79485
79486
79487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
79488   int jresult ;
79489   int result;
79490
79491   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
79492   jresult = (int)result;
79493   return jresult;
79494 }
79495
79496
79497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
79498   int jresult ;
79499   int result;
79500
79501   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
79502   jresult = (int)result;
79503   return jresult;
79504 }
79505
79506
79507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
79508   int jresult ;
79509   int result;
79510
79511   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
79512   jresult = (int)result;
79513   return jresult;
79514 }
79515
79516
79517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
79518   int jresult ;
79519   int result;
79520
79521   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
79522   jresult = (int)result;
79523   return jresult;
79524 }
79525
79526
79527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
79528   int jresult ;
79529   int result;
79530
79531   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
79532   jresult = (int)result;
79533   return jresult;
79534 }
79535
79536
79537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
79538   int jresult ;
79539   int result;
79540
79541   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
79542   jresult = (int)result;
79543   return jresult;
79544 }
79545
79546
79547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
79548   int jresult ;
79549   int result;
79550
79551   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
79552   jresult = (int)result;
79553   return jresult;
79554 }
79555
79556
79557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
79558   int jresult ;
79559   int result;
79560
79561   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
79562   jresult = (int)result;
79563   return jresult;
79564 }
79565
79566
79567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
79568   int jresult ;
79569   int result;
79570
79571   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
79572   jresult = (int)result;
79573   return jresult;
79574 }
79575
79576
79577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
79578   void * jresult ;
79579   Dali::Toolkit::TextLabel::Property *result = 0 ;
79580
79581   {
79582     try {
79583       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
79584     } catch (std::out_of_range& e) {
79585       {
79586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79587       };
79588     } catch (std::exception& e) {
79589       {
79590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79591       };
79592     } catch (...) {
79593       {
79594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79595       };
79596     }
79597   }
79598   jresult = (void *)result;
79599   return jresult;
79600 }
79601
79602
79603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
79604   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
79605
79606   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
79607   {
79608     try {
79609       delete arg1;
79610     } catch (std::out_of_range& e) {
79611       {
79612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79613       };
79614     } catch (std::exception& e) {
79615       {
79616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79617       };
79618     } catch (...) {
79619       {
79620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79621       };
79622     }
79623   }
79624 }
79625
79626
79627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
79628   void * jresult ;
79629   Dali::Toolkit::TextLabel result;
79630
79631   {
79632     try {
79633       result = Dali::Toolkit::TextLabel::New();
79634     } catch (std::out_of_range& e) {
79635       {
79636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79637       };
79638     } catch (std::exception& e) {
79639       {
79640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79641       };
79642     } catch (...) {
79643       {
79644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79645       };
79646     }
79647   }
79648   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79649   return jresult;
79650 }
79651
79652
79653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
79654   void * jresult ;
79655   std::string *arg1 = 0 ;
79656   Dali::Toolkit::TextLabel result;
79657
79658   if (!jarg1) {
79659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79660     return 0;
79661   }
79662   std::string arg1_str(jarg1);
79663   arg1 = &arg1_str;
79664   {
79665     try {
79666       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79667     } catch (std::out_of_range& e) {
79668       {
79669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79670       };
79671     } catch (std::exception& e) {
79672       {
79673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79674       };
79675     } catch (...) {
79676       {
79677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79678       };
79679     }
79680   }
79681   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79682
79683   //argout typemap for const std::string&
79684
79685   return jresult;
79686 }
79687
79688
79689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
79690   void * jresult ;
79691   Dali::Toolkit::TextLabel *result = 0 ;
79692
79693   {
79694     try {
79695       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79696     } catch (std::out_of_range& e) {
79697       {
79698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79699       };
79700     } catch (std::exception& e) {
79701       {
79702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79703       };
79704     } catch (...) {
79705       {
79706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79707       };
79708     }
79709   }
79710   jresult = (void *)result;
79711   return jresult;
79712 }
79713
79714
79715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
79716   void * jresult ;
79717   Dali::Toolkit::TextLabel *arg1 = 0 ;
79718   Dali::Toolkit::TextLabel *result = 0 ;
79719
79720   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79721   if (!arg1) {
79722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79723     return 0;
79724   }
79725   {
79726     try {
79727       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79728     } catch (std::out_of_range& e) {
79729       {
79730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79731       };
79732     } catch (std::exception& e) {
79733       {
79734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79735       };
79736     } catch (...) {
79737       {
79738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79739       };
79740     }
79741   }
79742   jresult = (void *)result;
79743   return jresult;
79744 }
79745
79746
79747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
79748   void * jresult ;
79749   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79750   Dali::Toolkit::TextLabel *arg2 = 0 ;
79751   Dali::Toolkit::TextLabel *result = 0 ;
79752
79753   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79754   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79755   if (!arg2) {
79756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79757     return 0;
79758   }
79759   {
79760     try {
79761       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79762     } catch (std::out_of_range& e) {
79763       {
79764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79765       };
79766     } catch (std::exception& e) {
79767       {
79768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79769       };
79770     } catch (...) {
79771       {
79772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79773       };
79774     }
79775   }
79776   jresult = (void *)result;
79777   return jresult;
79778 }
79779
79780
79781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
79782   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79783
79784   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79785   {
79786     try {
79787       delete arg1;
79788     } catch (std::out_of_range& e) {
79789       {
79790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79791       };
79792     } catch (std::exception& e) {
79793       {
79794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79795       };
79796     } catch (...) {
79797       {
79798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79799       };
79800     }
79801   }
79802 }
79803
79804
79805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79806   void * jresult ;
79807   Dali::BaseHandle arg1 ;
79808   Dali::BaseHandle *argp1 ;
79809   Dali::Toolkit::TextLabel result;
79810
79811   argp1 = (Dali::BaseHandle *)jarg1;
79812   if (!argp1) {
79813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79814     return 0;
79815   }
79816   arg1 = *argp1;
79817   {
79818     try {
79819       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79820     } catch (std::out_of_range& e) {
79821       {
79822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79823       };
79824     } catch (std::exception& e) {
79825       {
79826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79827       };
79828     } catch (...) {
79829       {
79830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79831       };
79832     }
79833   }
79834   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79835   return jresult;
79836 }
79837
79838
79839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79840   void * jresult ;
79841   Dali::Toolkit::AccessibilityManager *result = 0 ;
79842
79843   {
79844     try {
79845       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79846     } catch (std::out_of_range& e) {
79847       {
79848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79849       };
79850     } catch (std::exception& e) {
79851       {
79852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79853       };
79854     } catch (...) {
79855       {
79856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79857       };
79858     }
79859   }
79860   jresult = (void *)result;
79861   return jresult;
79862 }
79863
79864
79865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79866   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79867
79868   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79869   {
79870     try {
79871       delete arg1;
79872     } catch (std::out_of_range& e) {
79873       {
79874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79875       };
79876     } catch (std::exception& e) {
79877       {
79878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79879       };
79880     } catch (...) {
79881       {
79882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79883       };
79884     }
79885   }
79886 }
79887
79888
79889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79890   void * jresult ;
79891   Dali::Toolkit::AccessibilityManager result;
79892
79893   {
79894     try {
79895       result = Dali::Toolkit::AccessibilityManager::Get();
79896     } catch (std::out_of_range& e) {
79897       {
79898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79899       };
79900     } catch (std::exception& e) {
79901       {
79902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79903       };
79904     } catch (...) {
79905       {
79906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79907       };
79908     }
79909   }
79910   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79911   return jresult;
79912 }
79913
79914
79915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79916   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79917   Dali::Actor arg2 ;
79918   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79919   std::string *arg4 = 0 ;
79920   Dali::Actor *argp2 ;
79921
79922   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79923   argp2 = (Dali::Actor *)jarg2;
79924   if (!argp2) {
79925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79926     return ;
79927   }
79928   arg2 = *argp2;
79929   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79930   if (!jarg4) {
79931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79932     return ;
79933   }
79934   std::string arg4_str(jarg4);
79935   arg4 = &arg4_str;
79936   {
79937     try {
79938       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79939     } catch (std::out_of_range& e) {
79940       {
79941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79942       };
79943     } catch (std::exception& e) {
79944       {
79945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79946       };
79947     } catch (...) {
79948       {
79949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79950       };
79951     }
79952   }
79953
79954   //argout typemap for const std::string&
79955
79956 }
79957
79958
79959 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79960   char * jresult ;
79961   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79962   Dali::Actor arg2 ;
79963   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79964   Dali::Actor *argp2 ;
79965   std::string result;
79966
79967   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79968   argp2 = (Dali::Actor *)jarg2;
79969   if (!argp2) {
79970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79971     return 0;
79972   }
79973   arg2 = *argp2;
79974   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79975   {
79976     try {
79977       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79978     } catch (std::out_of_range& e) {
79979       {
79980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79981       };
79982     } catch (std::exception& e) {
79983       {
79984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79985       };
79986     } catch (...) {
79987       {
79988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79989       };
79990     }
79991   }
79992   jresult = SWIG_csharp_string_callback((&result)->c_str());
79993   return jresult;
79994 }
79995
79996
79997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79998   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79999   Dali::Actor arg2 ;
80000   unsigned int arg3 ;
80001   Dali::Actor *argp2 ;
80002
80003   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80004   argp2 = (Dali::Actor *)jarg2;
80005   if (!argp2) {
80006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80007     return ;
80008   }
80009   arg2 = *argp2;
80010   arg3 = (unsigned int)jarg3;
80011   {
80012     try {
80013       (arg1)->SetFocusOrder(arg2,arg3);
80014     } catch (std::out_of_range& e) {
80015       {
80016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80017       };
80018     } catch (std::exception& e) {
80019       {
80020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80021       };
80022     } catch (...) {
80023       {
80024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80025       };
80026     }
80027   }
80028 }
80029
80030
80031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
80032   unsigned int jresult ;
80033   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80034   Dali::Actor arg2 ;
80035   Dali::Actor *argp2 ;
80036   unsigned int result;
80037
80038   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80039   argp2 = (Dali::Actor *)jarg2;
80040   if (!argp2) {
80041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80042     return 0;
80043   }
80044   arg2 = *argp2;
80045   {
80046     try {
80047       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
80048     } catch (std::out_of_range& e) {
80049       {
80050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80051       };
80052     } catch (std::exception& e) {
80053       {
80054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80055       };
80056     } catch (...) {
80057       {
80058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80059       };
80060     }
80061   }
80062   jresult = result;
80063   return jresult;
80064 }
80065
80066
80067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
80068   unsigned int jresult ;
80069   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80070   unsigned int result;
80071
80072   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80073   {
80074     try {
80075       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
80076     } catch (std::out_of_range& e) {
80077       {
80078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80079       };
80080     } catch (std::exception& e) {
80081       {
80082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80083       };
80084     } catch (...) {
80085       {
80086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80087       };
80088     }
80089   }
80090   jresult = result;
80091   return jresult;
80092 }
80093
80094
80095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
80096   void * jresult ;
80097   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80098   unsigned int arg2 ;
80099   Dali::Actor result;
80100
80101   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80102   arg2 = (unsigned int)jarg2;
80103   {
80104     try {
80105       result = (arg1)->GetActorByFocusOrder(arg2);
80106     } catch (std::out_of_range& e) {
80107       {
80108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80109       };
80110     } catch (std::exception& e) {
80111       {
80112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80113       };
80114     } catch (...) {
80115       {
80116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80117       };
80118     }
80119   }
80120   jresult = new Dali::Actor((const Dali::Actor &)result);
80121   return jresult;
80122 }
80123
80124
80125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
80126   unsigned int jresult ;
80127   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80128   Dali::Actor arg2 ;
80129   Dali::Actor *argp2 ;
80130   bool result;
80131
80132   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80133   argp2 = (Dali::Actor *)jarg2;
80134   if (!argp2) {
80135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80136     return 0;
80137   }
80138   arg2 = *argp2;
80139   {
80140     try {
80141       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
80142     } catch (std::out_of_range& e) {
80143       {
80144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80145       };
80146     } catch (std::exception& e) {
80147       {
80148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80149       };
80150     } catch (...) {
80151       {
80152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80153       };
80154     }
80155   }
80156   jresult = result;
80157   return jresult;
80158 }
80159
80160
80161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
80162   void * jresult ;
80163   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80164   Dali::Actor result;
80165
80166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80167   {
80168     try {
80169       result = (arg1)->GetCurrentFocusActor();
80170     } catch (std::out_of_range& e) {
80171       {
80172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80173       };
80174     } catch (std::exception& e) {
80175       {
80176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80177       };
80178     } catch (...) {
80179       {
80180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80181       };
80182     }
80183   }
80184   jresult = new Dali::Actor((const Dali::Actor &)result);
80185   return jresult;
80186 }
80187
80188
80189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
80190   void * jresult ;
80191   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80192   Dali::Actor result;
80193
80194   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80195   {
80196     try {
80197       result = (arg1)->GetCurrentFocusGroup();
80198     } catch (std::out_of_range& e) {
80199       {
80200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80201       };
80202     } catch (std::exception& e) {
80203       {
80204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80205       };
80206     } catch (...) {
80207       {
80208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80209       };
80210     }
80211   }
80212   jresult = new Dali::Actor((const Dali::Actor &)result);
80213   return jresult;
80214 }
80215
80216
80217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
80218   unsigned int jresult ;
80219   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80220   unsigned int result;
80221
80222   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80223   {
80224     try {
80225       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
80226     } catch (std::out_of_range& e) {
80227       {
80228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80229       };
80230     } catch (std::exception& e) {
80231       {
80232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80233       };
80234     } catch (...) {
80235       {
80236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80237       };
80238     }
80239   }
80240   jresult = result;
80241   return jresult;
80242 }
80243
80244
80245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
80246   unsigned int jresult ;
80247   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80248   bool result;
80249
80250   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80251   {
80252     try {
80253       result = (bool)(arg1)->MoveFocusForward();
80254     } catch (std::out_of_range& e) {
80255       {
80256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80257       };
80258     } catch (std::exception& e) {
80259       {
80260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80261       };
80262     } catch (...) {
80263       {
80264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80265       };
80266     }
80267   }
80268   jresult = result;
80269   return jresult;
80270 }
80271
80272
80273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
80274   unsigned int jresult ;
80275   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80276   bool result;
80277
80278   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80279   {
80280     try {
80281       result = (bool)(arg1)->MoveFocusBackward();
80282     } catch (std::out_of_range& e) {
80283       {
80284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80285       };
80286     } catch (std::exception& e) {
80287       {
80288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80289       };
80290     } catch (...) {
80291       {
80292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80293       };
80294     }
80295   }
80296   jresult = result;
80297   return jresult;
80298 }
80299
80300
80301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
80302   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80303
80304   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80305   {
80306     try {
80307       (arg1)->ClearFocus();
80308     } catch (std::out_of_range& e) {
80309       {
80310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80311       };
80312     } catch (std::exception& e) {
80313       {
80314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80315       };
80316     } catch (...) {
80317       {
80318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80319       };
80320     }
80321   }
80322 }
80323
80324
80325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
80326   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80327
80328   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80329   {
80330     try {
80331       (arg1)->Reset();
80332     } catch (std::out_of_range& e) {
80333       {
80334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80335       };
80336     } catch (std::exception& e) {
80337       {
80338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80339       };
80340     } catch (...) {
80341       {
80342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80343       };
80344     }
80345   }
80346 }
80347
80348
80349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
80350   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80351   Dali::Actor arg2 ;
80352   bool arg3 ;
80353   Dali::Actor *argp2 ;
80354
80355   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80356   argp2 = (Dali::Actor *)jarg2;
80357   if (!argp2) {
80358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80359     return ;
80360   }
80361   arg2 = *argp2;
80362   arg3 = jarg3 ? true : false;
80363   {
80364     try {
80365       (arg1)->SetFocusGroup(arg2,arg3);
80366     } catch (std::out_of_range& e) {
80367       {
80368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80369       };
80370     } catch (std::exception& e) {
80371       {
80372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80373       };
80374     } catch (...) {
80375       {
80376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80377       };
80378     }
80379   }
80380 }
80381
80382
80383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
80384   unsigned int jresult ;
80385   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80386   Dali::Actor arg2 ;
80387   Dali::Actor *argp2 ;
80388   bool result;
80389
80390   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80391   argp2 = (Dali::Actor *)jarg2;
80392   if (!argp2) {
80393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80394     return 0;
80395   }
80396   arg2 = *argp2;
80397   {
80398     try {
80399       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
80400     } catch (std::out_of_range& e) {
80401       {
80402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80403       };
80404     } catch (std::exception& e) {
80405       {
80406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80407       };
80408     } catch (...) {
80409       {
80410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80411       };
80412     }
80413   }
80414   jresult = result;
80415   return jresult;
80416 }
80417
80418
80419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
80420   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80421   bool arg2 ;
80422
80423   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80424   arg2 = jarg2 ? true : false;
80425   {
80426     try {
80427       (arg1)->SetGroupMode(arg2);
80428     } catch (std::out_of_range& e) {
80429       {
80430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80431       };
80432     } catch (std::exception& e) {
80433       {
80434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80435       };
80436     } catch (...) {
80437       {
80438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80439       };
80440     }
80441   }
80442 }
80443
80444
80445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
80446   unsigned int jresult ;
80447   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80448   bool result;
80449
80450   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80451   {
80452     try {
80453       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
80454     } catch (std::out_of_range& e) {
80455       {
80456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80457       };
80458     } catch (std::exception& e) {
80459       {
80460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80461       };
80462     } catch (...) {
80463       {
80464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80465       };
80466     }
80467   }
80468   jresult = result;
80469   return jresult;
80470 }
80471
80472
80473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
80474   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80475   bool arg2 ;
80476
80477   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80478   arg2 = jarg2 ? true : false;
80479   {
80480     try {
80481       (arg1)->SetWrapMode(arg2);
80482     } catch (std::out_of_range& e) {
80483       {
80484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80485       };
80486     } catch (std::exception& e) {
80487       {
80488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80489       };
80490     } catch (...) {
80491       {
80492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80493       };
80494     }
80495   }
80496 }
80497
80498
80499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
80500   unsigned int jresult ;
80501   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80502   bool result;
80503
80504   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80505   {
80506     try {
80507       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80508     } catch (std::out_of_range& e) {
80509       {
80510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80511       };
80512     } catch (std::exception& e) {
80513       {
80514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80515       };
80516     } catch (...) {
80517       {
80518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80519       };
80520     }
80521   }
80522   jresult = result;
80523   return jresult;
80524 }
80525
80526
80527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80528   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80529   Dali::Actor arg2 ;
80530   Dali::Actor *argp2 ;
80531
80532   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80533   argp2 = (Dali::Actor *)jarg2;
80534   if (!argp2) {
80535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80536     return ;
80537   }
80538   arg2 = *argp2;
80539   {
80540     try {
80541       (arg1)->SetFocusIndicatorActor(arg2);
80542     } catch (std::out_of_range& e) {
80543       {
80544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80545       };
80546     } catch (std::exception& e) {
80547       {
80548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80549       };
80550     } catch (...) {
80551       {
80552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80553       };
80554     }
80555   }
80556 }
80557
80558
80559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80560   void * jresult ;
80561   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80562   Dali::Actor result;
80563
80564   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80565   {
80566     try {
80567       result = (arg1)->GetFocusIndicatorActor();
80568     } catch (std::out_of_range& e) {
80569       {
80570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80571       };
80572     } catch (std::exception& e) {
80573       {
80574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80575       };
80576     } catch (...) {
80577       {
80578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80579       };
80580     }
80581   }
80582   jresult = new Dali::Actor((const Dali::Actor &)result);
80583   return jresult;
80584 }
80585
80586
80587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80588   void * jresult ;
80589   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80590   Dali::Actor arg2 ;
80591   Dali::Actor *argp2 ;
80592   Dali::Actor result;
80593
80594   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80595   argp2 = (Dali::Actor *)jarg2;
80596   if (!argp2) {
80597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80598     return 0;
80599   }
80600   arg2 = *argp2;
80601   {
80602     try {
80603       result = (arg1)->GetFocusGroup(arg2);
80604     } catch (std::out_of_range& e) {
80605       {
80606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80607       };
80608     } catch (std::exception& e) {
80609       {
80610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80611       };
80612     } catch (...) {
80613       {
80614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80615       };
80616     }
80617   }
80618   jresult = new Dali::Actor((const Dali::Actor &)result);
80619   return jresult;
80620 }
80621
80622
80623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
80624   void * jresult ;
80625   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80626   Dali::Vector2 result;
80627
80628   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80629   {
80630     try {
80631       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80632     } catch (std::out_of_range& e) {
80633       {
80634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80635       };
80636     } catch (std::exception& e) {
80637       {
80638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80639       };
80640     } catch (...) {
80641       {
80642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80643       };
80644     }
80645   }
80646   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80647   return jresult;
80648 }
80649
80650
80651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80652   void * jresult ;
80653   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80654   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80655
80656   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80657   {
80658     try {
80659       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80660     } catch (std::out_of_range& e) {
80661       {
80662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80663       };
80664     } catch (std::exception& e) {
80665       {
80666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80667       };
80668     } catch (...) {
80669       {
80670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80671       };
80672     }
80673   }
80674   jresult = (void *)result;
80675   return jresult;
80676 }
80677
80678
80679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80680   void * jresult ;
80681   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80682   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80683
80684   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80685   {
80686     try {
80687       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80688     } catch (std::out_of_range& e) {
80689       {
80690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80691       };
80692     } catch (std::exception& e) {
80693       {
80694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80695       };
80696     } catch (...) {
80697       {
80698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80699       };
80700     }
80701   }
80702   jresult = (void *)result;
80703   return jresult;
80704 }
80705
80706
80707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80708   void * jresult ;
80709   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80710   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80711
80712   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80713   {
80714     try {
80715       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80716     } catch (std::out_of_range& e) {
80717       {
80718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80719       };
80720     } catch (std::exception& e) {
80721       {
80722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80723       };
80724     } catch (...) {
80725       {
80726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80727       };
80728     }
80729   }
80730   jresult = (void *)result;
80731   return jresult;
80732 }
80733
80734
80735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80736   void * jresult ;
80737   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80738   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80739
80740   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80741   {
80742     try {
80743       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80744     } catch (std::out_of_range& e) {
80745       {
80746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80747       };
80748     } catch (std::exception& e) {
80749       {
80750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80751       };
80752     } catch (...) {
80753       {
80754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80755       };
80756     }
80757   }
80758   jresult = (void *)result;
80759   return jresult;
80760 }
80761
80762
80763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80764   void * jresult ;
80765   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80766   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80767
80768   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80769   {
80770     try {
80771       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80772     } catch (std::out_of_range& e) {
80773       {
80774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80775       };
80776     } catch (std::exception& e) {
80777       {
80778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80779       };
80780     } catch (...) {
80781       {
80782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80783       };
80784     }
80785   }
80786   jresult = (void *)result;
80787   return jresult;
80788 }
80789
80790
80791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80792   void * jresult ;
80793   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80794   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80795
80796   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80797   {
80798     try {
80799       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80800     } catch (std::out_of_range& e) {
80801       {
80802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80803       };
80804     } catch (std::exception& e) {
80805       {
80806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80807       };
80808     } catch (...) {
80809       {
80810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80811       };
80812     }
80813   }
80814   jresult = (void *)result;
80815   return jresult;
80816 }
80817
80818
80819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80820   void * jresult ;
80821   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80822   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80823
80824   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80825   {
80826     try {
80827       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80828     } catch (std::out_of_range& e) {
80829       {
80830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80831       };
80832     } catch (std::exception& e) {
80833       {
80834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80835       };
80836     } catch (...) {
80837       {
80838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80839       };
80840     }
80841   }
80842   jresult = (void *)result;
80843   return jresult;
80844 }
80845
80846
80847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80848   void * jresult ;
80849   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80850   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80851
80852   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80853   {
80854     try {
80855       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80856     } catch (std::out_of_range& e) {
80857       {
80858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80859       };
80860     } catch (std::exception& e) {
80861       {
80862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80863       };
80864     } catch (...) {
80865       {
80866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80867       };
80868     }
80869   }
80870   jresult = (void *)result;
80871   return jresult;
80872 }
80873
80874
80875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80876   void * jresult ;
80877   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80878   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80879
80880   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80881   {
80882     try {
80883       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80884     } catch (std::out_of_range& e) {
80885       {
80886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80887       };
80888     } catch (std::exception& e) {
80889       {
80890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80891       };
80892     } catch (...) {
80893       {
80894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80895       };
80896     }
80897   }
80898   jresult = (void *)result;
80899   return jresult;
80900 }
80901
80902
80903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80904   void * jresult ;
80905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80906   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80907
80908   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80909   {
80910     try {
80911       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80912     } catch (std::out_of_range& e) {
80913       {
80914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80915       };
80916     } catch (std::exception& e) {
80917       {
80918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80919       };
80920     } catch (...) {
80921       {
80922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80923       };
80924     }
80925   }
80926   jresult = (void *)result;
80927   return jresult;
80928 }
80929
80930
80931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80932   void * jresult ;
80933   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80934   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80935
80936   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80937   {
80938     try {
80939       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80940     } catch (std::out_of_range& e) {
80941       {
80942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80943       };
80944     } catch (std::exception& e) {
80945       {
80946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80947       };
80948     } catch (...) {
80949       {
80950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80951       };
80952     }
80953   }
80954   jresult = (void *)result;
80955   return jresult;
80956 }
80957
80958
80959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80960   void * jresult ;
80961   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80962   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80963
80964   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80965   {
80966     try {
80967       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80968     } catch (std::out_of_range& e) {
80969       {
80970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80971       };
80972     } catch (std::exception& e) {
80973       {
80974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80975       };
80976     } catch (...) {
80977       {
80978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80979       };
80980     }
80981   }
80982   jresult = (void *)result;
80983   return jresult;
80984 }
80985
80986
80987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80988   void * jresult ;
80989   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80990   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80991
80992   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80993   {
80994     try {
80995       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80996     } catch (std::out_of_range& e) {
80997       {
80998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80999       };
81000     } catch (std::exception& e) {
81001       {
81002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81003       };
81004     } catch (...) {
81005       {
81006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81007       };
81008     }
81009   }
81010   jresult = (void *)result;
81011   return jresult;
81012 }
81013
81014
81015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
81016   void * jresult ;
81017   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81018   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81019
81020   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81021   {
81022     try {
81023       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
81024     } catch (std::out_of_range& e) {
81025       {
81026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81027       };
81028     } catch (std::exception& e) {
81029       {
81030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81031       };
81032     } catch (...) {
81033       {
81034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81035       };
81036     }
81037   }
81038   jresult = (void *)result;
81039   return jresult;
81040 }
81041
81042
81043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
81044   void * jresult ;
81045   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81046   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81047
81048   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81049   {
81050     try {
81051       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
81052     } catch (std::out_of_range& e) {
81053       {
81054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81055       };
81056     } catch (std::exception& e) {
81057       {
81058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81059       };
81060     } catch (...) {
81061       {
81062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81063       };
81064     }
81065   }
81066   jresult = (void *)result;
81067   return jresult;
81068 }
81069
81070
81071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
81072   void * jresult ;
81073   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81074   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81075
81076   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81077   {
81078     try {
81079       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
81080     } catch (std::out_of_range& e) {
81081       {
81082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81083       };
81084     } catch (std::exception& e) {
81085       {
81086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81087       };
81088     } catch (...) {
81089       {
81090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81091       };
81092     }
81093   }
81094   jresult = (void *)result;
81095   return jresult;
81096 }
81097
81098
81099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
81100   void * jresult ;
81101   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81102   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81103
81104   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81105   {
81106     try {
81107       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
81108     } catch (std::out_of_range& e) {
81109       {
81110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81111       };
81112     } catch (std::exception& e) {
81113       {
81114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81115       };
81116     } catch (...) {
81117       {
81118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81119       };
81120     }
81121   }
81122   jresult = (void *)result;
81123   return jresult;
81124 }
81125
81126
81127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
81128   void * jresult ;
81129   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81130   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81131
81132   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81133   {
81134     try {
81135       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
81136     } catch (std::out_of_range& e) {
81137       {
81138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81139       };
81140     } catch (std::exception& e) {
81141       {
81142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81143       };
81144     } catch (...) {
81145       {
81146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81147       };
81148     }
81149   }
81150   jresult = (void *)result;
81151   return jresult;
81152 }
81153
81154
81155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
81156   void * jresult ;
81157   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81158   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81159
81160   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81161   {
81162     try {
81163       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
81164     } catch (std::out_of_range& e) {
81165       {
81166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81167       };
81168     } catch (std::exception& e) {
81169       {
81170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81171       };
81172     } catch (...) {
81173       {
81174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81175       };
81176     }
81177   }
81178   jresult = (void *)result;
81179   return jresult;
81180 }
81181
81182
81183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
81184   void * jresult ;
81185   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81186   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81187
81188   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81189   {
81190     try {
81191       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
81192     } catch (std::out_of_range& e) {
81193       {
81194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81195       };
81196     } catch (std::exception& e) {
81197       {
81198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81199       };
81200     } catch (...) {
81201       {
81202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81203       };
81204     }
81205   }
81206   jresult = (void *)result;
81207   return jresult;
81208 }
81209
81210
81211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
81212   void * jresult ;
81213   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81214   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81215
81216   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81217   {
81218     try {
81219       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
81220     } catch (std::out_of_range& e) {
81221       {
81222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81223       };
81224     } catch (std::exception& e) {
81225       {
81226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81227       };
81228     } catch (...) {
81229       {
81230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81231       };
81232     }
81233   }
81234   jresult = (void *)result;
81235   return jresult;
81236 }
81237
81238
81239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
81240   void * jresult ;
81241   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81242   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81243
81244   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81245   {
81246     try {
81247       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
81248     } catch (std::out_of_range& e) {
81249       {
81250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81251       };
81252     } catch (std::exception& e) {
81253       {
81254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81255       };
81256     } catch (...) {
81257       {
81258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81259       };
81260     }
81261   }
81262   jresult = (void *)result;
81263   return jresult;
81264 }
81265
81266
81267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
81268   void * jresult ;
81269   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81270   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81271
81272   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81273   {
81274     try {
81275       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
81276     } catch (std::out_of_range& e) {
81277       {
81278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81279       };
81280     } catch (std::exception& e) {
81281       {
81282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81283       };
81284     } catch (...) {
81285       {
81286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81287       };
81288     }
81289   }
81290   jresult = (void *)result;
81291   return jresult;
81292 }
81293
81294
81295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
81296   void * jresult ;
81297   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81298   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81299
81300   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81301   {
81302     try {
81303       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
81304     } catch (std::out_of_range& e) {
81305       {
81306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81307       };
81308     } catch (std::exception& e) {
81309       {
81310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81311       };
81312     } catch (...) {
81313       {
81314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81315       };
81316     }
81317   }
81318   jresult = (void *)result;
81319   return jresult;
81320 }
81321
81322
81323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
81324   void * jresult ;
81325   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81326   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81327
81328   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81329   {
81330     try {
81331       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
81332     } catch (std::out_of_range& e) {
81333       {
81334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81335       };
81336     } catch (std::exception& e) {
81337       {
81338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81339       };
81340     } catch (...) {
81341       {
81342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81343       };
81344     }
81345   }
81346   jresult = (void *)result;
81347   return jresult;
81348 }
81349
81350
81351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
81352   void * jresult ;
81353   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81354   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81355
81356   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81357   {
81358     try {
81359       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
81360     } catch (std::out_of_range& e) {
81361       {
81362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81363       };
81364     } catch (std::exception& e) {
81365       {
81366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81367       };
81368     } catch (...) {
81369       {
81370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81371       };
81372     }
81373   }
81374   jresult = (void *)result;
81375   return jresult;
81376 }
81377
81378
81379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
81380   void * jresult ;
81381   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81382   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81383
81384   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81385   {
81386     try {
81387       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
81388     } catch (std::out_of_range& e) {
81389       {
81390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81391       };
81392     } catch (std::exception& e) {
81393       {
81394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81395       };
81396     } catch (...) {
81397       {
81398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81399       };
81400     }
81401   }
81402   jresult = (void *)result;
81403   return jresult;
81404 }
81405
81406
81407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81408   void * jresult ;
81409   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81410   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81411
81412   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81413   {
81414     try {
81415       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81416     } catch (std::out_of_range& e) {
81417       {
81418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81419       };
81420     } catch (std::exception& e) {
81421       {
81422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81423       };
81424     } catch (...) {
81425       {
81426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81427       };
81428     }
81429   }
81430   jresult = (void *)result;
81431   return jresult;
81432 }
81433
81434
81435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81436   void * jresult ;
81437   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81438   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81439
81440   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81441   {
81442     try {
81443       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81444     } catch (std::out_of_range& e) {
81445       {
81446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81447       };
81448     } catch (std::exception& e) {
81449       {
81450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81451       };
81452     } catch (...) {
81453       {
81454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81455       };
81456     }
81457   }
81458   jresult = (void *)result;
81459   return jresult;
81460 }
81461
81462
81463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81464   void * jresult ;
81465   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81466   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81467
81468   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81469   {
81470     try {
81471       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81472     } catch (std::out_of_range& e) {
81473       {
81474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81475       };
81476     } catch (std::exception& e) {
81477       {
81478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81479       };
81480     } catch (...) {
81481       {
81482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81483       };
81484     }
81485   }
81486   jresult = (void *)result;
81487   return jresult;
81488 }
81489
81490
81491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
81492   void * jresult ;
81493   Dali::Toolkit::StyleManager *result = 0 ;
81494
81495   {
81496     try {
81497       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81498     } catch (std::out_of_range& e) {
81499       {
81500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81501       };
81502     } catch (std::exception& e) {
81503       {
81504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81505       };
81506     } catch (...) {
81507       {
81508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81509       };
81510     }
81511   }
81512   jresult = (void *)result;
81513   return jresult;
81514 }
81515
81516
81517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81518   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81519
81520   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81521   {
81522     try {
81523       delete arg1;
81524     } catch (std::out_of_range& e) {
81525       {
81526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81527       };
81528     } catch (std::exception& e) {
81529       {
81530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81531       };
81532     } catch (...) {
81533       {
81534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81535       };
81536     }
81537   }
81538 }
81539
81540
81541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81542   void * jresult ;
81543   Dali::Toolkit::StyleManager result;
81544
81545   {
81546     try {
81547       result = Dali::Toolkit::StyleManager::Get();
81548     } catch (std::out_of_range& e) {
81549       {
81550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81551       };
81552     } catch (std::exception& e) {
81553       {
81554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81555       };
81556     } catch (...) {
81557       {
81558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81559       };
81560     }
81561   }
81562   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81563   return jresult;
81564 }
81565
81566
81567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81568   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81569   std::string *arg2 = 0 ;
81570
81571   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81572   if (!jarg2) {
81573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81574     return ;
81575   }
81576   std::string arg2_str(jarg2);
81577   arg2 = &arg2_str;
81578   {
81579     try {
81580       (arg1)->ApplyTheme((std::string const &)*arg2);
81581     } catch (std::out_of_range& e) {
81582       {
81583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81584       };
81585     } catch (std::exception& e) {
81586       {
81587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81588       };
81589     } catch (...) {
81590       {
81591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81592       };
81593     }
81594   }
81595
81596   //argout typemap for const std::string&
81597
81598 }
81599
81600
81601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81602   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81603
81604   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81605   {
81606     try {
81607       (arg1)->ApplyDefaultTheme();
81608     } catch (std::out_of_range& e) {
81609       {
81610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81611       };
81612     } catch (std::exception& e) {
81613       {
81614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81615       };
81616     } catch (...) {
81617       {
81618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81619       };
81620     }
81621   }
81622 }
81623
81624
81625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81626   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81627   std::string *arg2 = 0 ;
81628   Dali::Property::Value *arg3 = 0 ;
81629
81630   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81631   if (!jarg2) {
81632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81633     return ;
81634   }
81635   std::string arg2_str(jarg2);
81636   arg2 = &arg2_str;
81637   arg3 = (Dali::Property::Value *)jarg3;
81638   if (!arg3) {
81639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81640     return ;
81641   }
81642   {
81643     try {
81644       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81645     } catch (std::out_of_range& e) {
81646       {
81647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81648       };
81649     } catch (std::exception& e) {
81650       {
81651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81652       };
81653     } catch (...) {
81654       {
81655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81656       };
81657     }
81658   }
81659
81660   //argout typemap for const std::string&
81661
81662 }
81663
81664
81665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81666   unsigned int jresult ;
81667   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81668   std::string *arg2 = 0 ;
81669   Dali::Property::Value *arg3 = 0 ;
81670   bool result;
81671
81672   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81673   if (!jarg2) {
81674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81675     return 0;
81676   }
81677   std::string arg2_str(jarg2);
81678   arg2 = &arg2_str;
81679   arg3 = (Dali::Property::Value *)jarg3;
81680   if (!arg3) {
81681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81682     return 0;
81683   }
81684   {
81685     try {
81686       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81687     } catch (std::out_of_range& e) {
81688       {
81689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81690       };
81691     } catch (std::exception& e) {
81692       {
81693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81694       };
81695     } catch (...) {
81696       {
81697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81698       };
81699     }
81700   }
81701   jresult = result;
81702
81703   //argout typemap for const std::string&
81704
81705   return jresult;
81706 }
81707
81708
81709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81710   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81711   Dali::Toolkit::Control arg2 ;
81712   std::string *arg3 = 0 ;
81713   std::string *arg4 = 0 ;
81714   Dali::Toolkit::Control *argp2 ;
81715
81716   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81717   argp2 = (Dali::Toolkit::Control *)jarg2;
81718   if (!argp2) {
81719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81720     return ;
81721   }
81722   arg2 = *argp2;
81723   if (!jarg3) {
81724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81725     return ;
81726   }
81727   std::string arg3_str(jarg3);
81728   arg3 = &arg3_str;
81729   if (!jarg4) {
81730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81731     return ;
81732   }
81733   std::string arg4_str(jarg4);
81734   arg4 = &arg4_str;
81735   {
81736     try {
81737       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81738     } catch (std::out_of_range& e) {
81739       {
81740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81741       };
81742     } catch (std::exception& e) {
81743       {
81744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81745       };
81746     } catch (...) {
81747       {
81748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81749       };
81750     }
81751   }
81752
81753   //argout typemap for const std::string&
81754
81755
81756   //argout typemap for const std::string&
81757
81758 }
81759
81760
81761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81762   void * jresult ;
81763   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81764   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81765
81766   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81767   {
81768     try {
81769       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81770     } catch (std::out_of_range& e) {
81771       {
81772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81773       };
81774     } catch (std::exception& e) {
81775       {
81776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81777       };
81778     } catch (...) {
81779       {
81780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81781       };
81782     }
81783   }
81784   jresult = (void *)result;
81785   return jresult;
81786 }
81787
81788
81789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81790   int jresult ;
81791   int result;
81792
81793   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81794   jresult = (int)result;
81795   return jresult;
81796 }
81797
81798
81799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81800   int jresult ;
81801   int result;
81802
81803   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81804   jresult = (int)result;
81805   return jresult;
81806 }
81807
81808
81809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81810   int jresult ;
81811   int result;
81812
81813   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81814   jresult = (int)result;
81815   return jresult;
81816 }
81817
81818
81819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81820   int jresult ;
81821   int result;
81822
81823   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81824   jresult = (int)result;
81825   return jresult;
81826 }
81827
81828
81829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81830   int jresult ;
81831   int result;
81832
81833   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81834   jresult = (int)result;
81835   return jresult;
81836 }
81837
81838
81839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81840   int jresult ;
81841   int result;
81842
81843   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81844   jresult = (int)result;
81845   return jresult;
81846 }
81847
81848
81849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81850   int jresult ;
81851   int result;
81852
81853   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81854   jresult = (int)result;
81855   return jresult;
81856 }
81857
81858
81859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81860   int jresult ;
81861   int result;
81862
81863   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81864   jresult = (int)result;
81865   return jresult;
81866 }
81867
81868
81869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81870   int jresult ;
81871   int result;
81872
81873   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81874   jresult = (int)result;
81875   return jresult;
81876 }
81877
81878
81879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81880   int jresult ;
81881   int result;
81882
81883   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81884   jresult = (int)result;
81885   return jresult;
81886 }
81887
81888
81889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81890   int jresult ;
81891   int result;
81892
81893   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81894   jresult = (int)result;
81895   return jresult;
81896 }
81897
81898
81899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81900   int jresult ;
81901   int result;
81902
81903   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81904   jresult = (int)result;
81905   return jresult;
81906 }
81907
81908
81909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81910   int jresult ;
81911   int result;
81912
81913   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81914   jresult = (int)result;
81915   return jresult;
81916 }
81917
81918
81919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81920   int jresult ;
81921   int result;
81922
81923   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81924   jresult = (int)result;
81925   return jresult;
81926 }
81927
81928
81929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81930   int jresult ;
81931   int result;
81932
81933   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81934   jresult = (int)result;
81935   return jresult;
81936 }
81937
81938
81939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81940   void * jresult ;
81941   Dali::Toolkit::Slider::Property *result = 0 ;
81942
81943   {
81944     try {
81945       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81946     } catch (std::out_of_range& e) {
81947       {
81948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81949       };
81950     } catch (std::exception& e) {
81951       {
81952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81953       };
81954     } catch (...) {
81955       {
81956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81957       };
81958     }
81959   }
81960   jresult = (void *)result;
81961   return jresult;
81962 }
81963
81964
81965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81966   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81967
81968   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81969   {
81970     try {
81971       delete arg1;
81972     } catch (std::out_of_range& e) {
81973       {
81974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81975       };
81976     } catch (std::exception& e) {
81977       {
81978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81979       };
81980     } catch (...) {
81981       {
81982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81983       };
81984     }
81985   }
81986 }
81987
81988
81989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81990   void * jresult ;
81991   Dali::Toolkit::Slider result;
81992
81993   {
81994     try {
81995       result = Dali::Toolkit::Slider::New();
81996     } catch (std::out_of_range& e) {
81997       {
81998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81999       };
82000     } catch (std::exception& e) {
82001       {
82002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82003       };
82004     } catch (...) {
82005       {
82006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82007       };
82008     }
82009   }
82010   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
82011   return jresult;
82012 }
82013
82014
82015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
82016   void * jresult ;
82017   Dali::Toolkit::Slider *result = 0 ;
82018
82019   {
82020     try {
82021       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
82022     } catch (std::out_of_range& e) {
82023       {
82024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82025       };
82026     } catch (std::exception& e) {
82027       {
82028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82029       };
82030     } catch (...) {
82031       {
82032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82033       };
82034     }
82035   }
82036   jresult = (void *)result;
82037   return jresult;
82038 }
82039
82040
82041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
82042   void * jresult ;
82043   Dali::Toolkit::Slider *arg1 = 0 ;
82044   Dali::Toolkit::Slider *result = 0 ;
82045
82046   arg1 = (Dali::Toolkit::Slider *)jarg1;
82047   if (!arg1) {
82048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
82049     return 0;
82050   }
82051   {
82052     try {
82053       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
82054     } catch (std::out_of_range& e) {
82055       {
82056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82057       };
82058     } catch (std::exception& e) {
82059       {
82060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82061       };
82062     } catch (...) {
82063       {
82064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82065       };
82066     }
82067   }
82068   jresult = (void *)result;
82069   return jresult;
82070 }
82071
82072
82073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
82074   void * jresult ;
82075   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82076   Dali::Toolkit::Slider *arg2 = 0 ;
82077   Dali::Toolkit::Slider *result = 0 ;
82078
82079   arg1 = (Dali::Toolkit::Slider *)jarg1;
82080   arg2 = (Dali::Toolkit::Slider *)jarg2;
82081   if (!arg2) {
82082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
82083     return 0;
82084   }
82085   {
82086     try {
82087       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
82088     } catch (std::out_of_range& e) {
82089       {
82090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82091       };
82092     } catch (std::exception& e) {
82093       {
82094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82095       };
82096     } catch (...) {
82097       {
82098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82099       };
82100     }
82101   }
82102   jresult = (void *)result;
82103   return jresult;
82104 }
82105
82106
82107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
82108   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82109
82110   arg1 = (Dali::Toolkit::Slider *)jarg1;
82111   {
82112     try {
82113       delete arg1;
82114     } catch (std::out_of_range& e) {
82115       {
82116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82117       };
82118     } catch (std::exception& e) {
82119       {
82120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82121       };
82122     } catch (...) {
82123       {
82124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82125       };
82126     }
82127   }
82128 }
82129
82130
82131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
82132   void * jresult ;
82133   Dali::BaseHandle arg1 ;
82134   Dali::BaseHandle *argp1 ;
82135   Dali::Toolkit::Slider result;
82136
82137   argp1 = (Dali::BaseHandle *)jarg1;
82138   if (!argp1) {
82139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82140     return 0;
82141   }
82142   arg1 = *argp1;
82143   {
82144     try {
82145       result = Dali::Toolkit::Slider::DownCast(arg1);
82146     } catch (std::out_of_range& e) {
82147       {
82148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82149       };
82150     } catch (std::exception& e) {
82151       {
82152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82153       };
82154     } catch (...) {
82155       {
82156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82157       };
82158     }
82159   }
82160   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
82161   return jresult;
82162 }
82163
82164
82165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
82166   void * jresult ;
82167   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82168   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82169
82170   arg1 = (Dali::Toolkit::Slider *)jarg1;
82171   {
82172     try {
82173       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82174     } catch (std::out_of_range& e) {
82175       {
82176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82177       };
82178     } catch (std::exception& e) {
82179       {
82180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82181       };
82182     } catch (...) {
82183       {
82184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82185       };
82186     }
82187   }
82188   jresult = (void *)result;
82189   return jresult;
82190 }
82191
82192
82193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
82194   void * jresult ;
82195   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82196   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82197
82198   arg1 = (Dali::Toolkit::Slider *)jarg1;
82199   {
82200     try {
82201       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
82202     } catch (std::out_of_range& e) {
82203       {
82204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82205       };
82206     } catch (std::exception& e) {
82207       {
82208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82209       };
82210     } catch (...) {
82211       {
82212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82213       };
82214     }
82215   }
82216   jresult = (void *)result;
82217   return jresult;
82218 }
82219
82220
82221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
82222   void * jresult ;
82223   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82224   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
82225
82226   arg1 = (Dali::Toolkit::Slider *)jarg1;
82227   {
82228     try {
82229       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
82230     } catch (std::out_of_range& e) {
82231       {
82232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82233       };
82234     } catch (std::exception& e) {
82235       {
82236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82237       };
82238     } catch (...) {
82239       {
82240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82241       };
82242     }
82243   }
82244   jresult = (void *)result;
82245   return jresult;
82246 }
82247
82248
82249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
82250   int jresult ;
82251   int result;
82252
82253   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
82254   jresult = (int)result;
82255   return jresult;
82256 }
82257
82258
82259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
82260   int jresult ;
82261   int result;
82262
82263   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
82264   jresult = (int)result;
82265   return jresult;
82266 }
82267
82268
82269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
82270   int jresult ;
82271   int result;
82272
82273   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
82274   jresult = (int)result;
82275   return jresult;
82276 }
82277
82278
82279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
82280   int jresult ;
82281   int result;
82282
82283   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
82284   jresult = (int)result;
82285   return jresult;
82286 }
82287
82288
82289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
82290   void * jresult ;
82291   Dali::Toolkit::VideoView::Property *result = 0 ;
82292
82293   {
82294     try {
82295       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
82296     } catch (std::out_of_range& e) {
82297       {
82298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82299       };
82300     } catch (std::exception& e) {
82301       {
82302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82303       };
82304     } catch (...) {
82305       {
82306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82307       };
82308     }
82309   }
82310   jresult = (void *)result;
82311   return jresult;
82312 }
82313
82314
82315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
82316   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
82317
82318   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
82319   {
82320     try {
82321       delete arg1;
82322     } catch (std::out_of_range& e) {
82323       {
82324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82325       };
82326     } catch (std::exception& e) {
82327       {
82328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82329       };
82330     } catch (...) {
82331       {
82332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82333       };
82334     }
82335   }
82336 }
82337
82338
82339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
82340   void * jresult ;
82341   Dali::Toolkit::VideoView result;
82342
82343   {
82344     try {
82345       result = Dali::Toolkit::VideoView::New();
82346     } catch (std::out_of_range& e) {
82347       {
82348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82349       };
82350     } catch (std::exception& e) {
82351       {
82352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82353       };
82354     } catch (...) {
82355       {
82356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82357       };
82358     }
82359   }
82360   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82361   return jresult;
82362 }
82363
82364
82365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
82366   void * jresult ;
82367   std::string *arg1 = 0 ;
82368   Dali::Toolkit::VideoView result;
82369
82370   if (!jarg1) {
82371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82372     return 0;
82373   }
82374   std::string arg1_str(jarg1);
82375   arg1 = &arg1_str;
82376   {
82377     try {
82378       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
82379     } catch (std::out_of_range& e) {
82380       {
82381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82382       };
82383     } catch (std::exception& e) {
82384       {
82385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82386       };
82387     } catch (...) {
82388       {
82389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82390       };
82391     }
82392   }
82393   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82394
82395   //argout typemap for const std::string&
82396
82397   return jresult;
82398 }
82399
82400
82401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82402   void * jresult ;
82403   Dali::Toolkit::VideoView *result = 0 ;
82404
82405   {
82406     try {
82407       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82408     } catch (std::out_of_range& e) {
82409       {
82410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82411       };
82412     } catch (std::exception& e) {
82413       {
82414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82415       };
82416     } catch (...) {
82417       {
82418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82419       };
82420     }
82421   }
82422   jresult = (void *)result;
82423   return jresult;
82424 }
82425
82426
82427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82428   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82429
82430   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82431   {
82432     try {
82433       delete arg1;
82434     } catch (std::out_of_range& e) {
82435       {
82436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82437       };
82438     } catch (std::exception& e) {
82439       {
82440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82441       };
82442     } catch (...) {
82443       {
82444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82445       };
82446     }
82447   }
82448 }
82449
82450
82451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82452   void * jresult ;
82453   Dali::Toolkit::VideoView *arg1 = 0 ;
82454   Dali::Toolkit::VideoView *result = 0 ;
82455
82456   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82457   if (!arg1) {
82458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82459     return 0;
82460   }
82461   {
82462     try {
82463       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82464     } catch (std::out_of_range& e) {
82465       {
82466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82467       };
82468     } catch (std::exception& e) {
82469       {
82470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82471       };
82472     } catch (...) {
82473       {
82474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82475       };
82476     }
82477   }
82478   jresult = (void *)result;
82479   return jresult;
82480 }
82481
82482
82483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82484   void * jresult ;
82485   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82486   Dali::Toolkit::VideoView *arg2 = 0 ;
82487   Dali::Toolkit::VideoView *result = 0 ;
82488
82489   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82490   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82491   if (!arg2) {
82492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82493     return 0;
82494   }
82495   {
82496     try {
82497       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82498     } catch (std::out_of_range& e) {
82499       {
82500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82501       };
82502     } catch (std::exception& e) {
82503       {
82504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82505       };
82506     } catch (...) {
82507       {
82508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82509       };
82510     }
82511   }
82512   jresult = (void *)result;
82513   return jresult;
82514 }
82515
82516
82517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82518   void * jresult ;
82519   Dali::BaseHandle arg1 ;
82520   Dali::BaseHandle *argp1 ;
82521   Dali::Toolkit::VideoView result;
82522
82523   argp1 = (Dali::BaseHandle *)jarg1;
82524   if (!argp1) {
82525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82526     return 0;
82527   }
82528   arg1 = *argp1;
82529   {
82530     try {
82531       result = Dali::Toolkit::VideoView::DownCast(arg1);
82532     } catch (std::out_of_range& e) {
82533       {
82534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82535       };
82536     } catch (std::exception& e) {
82537       {
82538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82539       };
82540     } catch (...) {
82541       {
82542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82543       };
82544     }
82545   }
82546   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82547   return jresult;
82548 }
82549
82550
82551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82552   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82553
82554   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82555   {
82556     try {
82557       (arg1)->Play();
82558     } catch (std::out_of_range& e) {
82559       {
82560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82561       };
82562     } catch (std::exception& e) {
82563       {
82564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82565       };
82566     } catch (...) {
82567       {
82568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82569       };
82570     }
82571   }
82572 }
82573
82574
82575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82576   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82577
82578   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82579   {
82580     try {
82581       (arg1)->Pause();
82582     } catch (std::out_of_range& e) {
82583       {
82584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82585       };
82586     } catch (std::exception& e) {
82587       {
82588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82589       };
82590     } catch (...) {
82591       {
82592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82593       };
82594     }
82595   }
82596 }
82597
82598
82599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82600   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82601
82602   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82603   {
82604     try {
82605       (arg1)->Stop();
82606     } catch (std::out_of_range& e) {
82607       {
82608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82609       };
82610     } catch (std::exception& e) {
82611       {
82612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82613       };
82614     } catch (...) {
82615       {
82616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82617       };
82618     }
82619   }
82620 }
82621
82622
82623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82624   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82625   int arg2 ;
82626
82627   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82628   arg2 = (int)jarg2;
82629   {
82630     try {
82631       (arg1)->Forward(arg2);
82632     } catch (std::out_of_range& e) {
82633       {
82634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82635       };
82636     } catch (std::exception& e) {
82637       {
82638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82639       };
82640     } catch (...) {
82641       {
82642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82643       };
82644     }
82645   }
82646 }
82647
82648
82649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82650   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82651   int arg2 ;
82652
82653   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82654   arg2 = (int)jarg2;
82655   {
82656     try {
82657       (arg1)->Backward(arg2);
82658     } catch (std::out_of_range& e) {
82659       {
82660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82661       };
82662     } catch (std::exception& e) {
82663       {
82664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82665       };
82666     } catch (...) {
82667       {
82668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82669       };
82670     }
82671   }
82672 }
82673
82674
82675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82676   void * jresult ;
82677   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82678   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82679
82680   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82681   {
82682     try {
82683       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82684     } catch (std::out_of_range& e) {
82685       {
82686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82687       };
82688     } catch (std::exception& e) {
82689       {
82690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82691       };
82692     } catch (...) {
82693       {
82694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82695       };
82696     }
82697   }
82698   jresult = (void *)result;
82699   return jresult;
82700 }
82701
82702
82703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82704   int jresult ;
82705   int result;
82706
82707   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82708   jresult = (int)result;
82709   return jresult;
82710 }
82711
82712
82713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82714   int jresult ;
82715   int result;
82716
82717   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82718   jresult = (int)result;
82719   return jresult;
82720 }
82721
82722
82723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82724   int jresult ;
82725   int result;
82726
82727   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82728   jresult = (int)result;
82729   return jresult;
82730 }
82731
82732
82733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82734   int jresult ;
82735   int result;
82736
82737   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82738   jresult = (int)result;
82739   return jresult;
82740 }
82741
82742
82743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82744   int jresult ;
82745   int result;
82746
82747   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82748   jresult = (int)result;
82749   return jresult;
82750 }
82751
82752
82753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82754   int jresult ;
82755   int result;
82756
82757   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82758   jresult = (int)result;
82759   return jresult;
82760 }
82761
82762
82763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82764   int jresult ;
82765   int result;
82766
82767   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82768   jresult = (int)result;
82769   return jresult;
82770 }
82771
82772
82773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82774   int jresult ;
82775   int result;
82776
82777   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82778   jresult = (int)result;
82779   return jresult;
82780 }
82781
82782
82783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82784   int jresult ;
82785   int result;
82786
82787   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82788   jresult = (int)result;
82789   return jresult;
82790 }
82791
82792
82793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82794   int jresult ;
82795   int result;
82796
82797   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82798   jresult = (int)result;
82799   return jresult;
82800 }
82801
82802
82803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82804   int jresult ;
82805   int result;
82806
82807   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82808   jresult = (int)result;
82809   return jresult;
82810 }
82811
82812
82813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82814   int jresult ;
82815   int result;
82816
82817   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82818   jresult = (int)result;
82819   return jresult;
82820 }
82821
82822
82823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82824   int jresult ;
82825   int result;
82826
82827   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82828   jresult = (int)result;
82829   return jresult;
82830 }
82831
82832
82833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82834   int jresult ;
82835   int result;
82836
82837   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82838   jresult = (int)result;
82839   return jresult;
82840 }
82841
82842
82843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82844   int jresult ;
82845   int result;
82846
82847   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82848   jresult = (int)result;
82849   return jresult;
82850 }
82851
82852
82853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82854   int jresult ;
82855   int result;
82856
82857   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82858   jresult = (int)result;
82859   return jresult;
82860 }
82861
82862
82863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82864   int jresult ;
82865   int result;
82866
82867   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82868   jresult = (int)result;
82869   return jresult;
82870 }
82871
82872
82873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82874   int jresult ;
82875   int result;
82876
82877   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82878   jresult = (int)result;
82879   return jresult;
82880 }
82881
82882
82883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82884   int jresult ;
82885   int result;
82886
82887   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82888   jresult = (int)result;
82889   return jresult;
82890 }
82891
82892
82893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82894   int jresult ;
82895   int result;
82896
82897   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82898   jresult = (int)result;
82899   return jresult;
82900 }
82901
82902
82903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82904   int jresult ;
82905   int result;
82906
82907   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82908   jresult = (int)result;
82909   return jresult;
82910 }
82911
82912
82913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82914   void * jresult ;
82915   Dali::Toolkit::Popup::Property *result = 0 ;
82916
82917   {
82918     try {
82919       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82920     } catch (std::out_of_range& e) {
82921       {
82922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82923       };
82924     } catch (std::exception& e) {
82925       {
82926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82927       };
82928     } catch (...) {
82929       {
82930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82931       };
82932     }
82933   }
82934   jresult = (void *)result;
82935   return jresult;
82936 }
82937
82938
82939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82940   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82941
82942   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82943   {
82944     try {
82945       delete arg1;
82946     } catch (std::out_of_range& e) {
82947       {
82948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82949       };
82950     } catch (std::exception& e) {
82951       {
82952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82953       };
82954     } catch (...) {
82955       {
82956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82957       };
82958     }
82959   }
82960 }
82961
82962
82963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82964   void * jresult ;
82965   Dali::Toolkit::Popup *result = 0 ;
82966
82967   {
82968     try {
82969       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82970     } catch (std::out_of_range& e) {
82971       {
82972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82973       };
82974     } catch (std::exception& e) {
82975       {
82976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82977       };
82978     } catch (...) {
82979       {
82980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82981       };
82982     }
82983   }
82984   jresult = (void *)result;
82985   return jresult;
82986 }
82987
82988
82989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82990   void * jresult ;
82991   Dali::Toolkit::Popup result;
82992
82993   {
82994     try {
82995       result = Dali::Toolkit::Popup::New();
82996     } catch (std::out_of_range& e) {
82997       {
82998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82999       };
83000     } catch (std::exception& e) {
83001       {
83002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83003       };
83004     } catch (...) {
83005       {
83006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83007       };
83008     }
83009   }
83010   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83011   return jresult;
83012 }
83013
83014
83015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
83016   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83017
83018   arg1 = (Dali::Toolkit::Popup *)jarg1;
83019   {
83020     try {
83021       delete arg1;
83022     } catch (std::out_of_range& e) {
83023       {
83024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83025       };
83026     } catch (std::exception& e) {
83027       {
83028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83029       };
83030     } catch (...) {
83031       {
83032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83033       };
83034     }
83035   }
83036 }
83037
83038
83039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
83040   void * jresult ;
83041   Dali::Toolkit::Popup *arg1 = 0 ;
83042   Dali::Toolkit::Popup *result = 0 ;
83043
83044   arg1 = (Dali::Toolkit::Popup *)jarg1;
83045   if (!arg1) {
83046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83047     return 0;
83048   }
83049   {
83050     try {
83051       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
83052     } catch (std::out_of_range& e) {
83053       {
83054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83055       };
83056     } catch (std::exception& e) {
83057       {
83058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83059       };
83060     } catch (...) {
83061       {
83062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83063       };
83064     }
83065   }
83066   jresult = (void *)result;
83067   return jresult;
83068 }
83069
83070
83071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
83072   void * jresult ;
83073   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83074   Dali::Toolkit::Popup *arg2 = 0 ;
83075   Dali::Toolkit::Popup *result = 0 ;
83076
83077   arg1 = (Dali::Toolkit::Popup *)jarg1;
83078   arg2 = (Dali::Toolkit::Popup *)jarg2;
83079   if (!arg2) {
83080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83081     return 0;
83082   }
83083   {
83084     try {
83085       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
83086     } catch (std::out_of_range& e) {
83087       {
83088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83089       };
83090     } catch (std::exception& e) {
83091       {
83092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83093       };
83094     } catch (...) {
83095       {
83096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83097       };
83098     }
83099   }
83100   jresult = (void *)result;
83101   return jresult;
83102 }
83103
83104
83105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
83106   void * jresult ;
83107   Dali::BaseHandle arg1 ;
83108   Dali::BaseHandle *argp1 ;
83109   Dali::Toolkit::Popup result;
83110
83111   argp1 = (Dali::BaseHandle *)jarg1;
83112   if (!argp1) {
83113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83114     return 0;
83115   }
83116   arg1 = *argp1;
83117   {
83118     try {
83119       result = Dali::Toolkit::Popup::DownCast(arg1);
83120     } catch (std::out_of_range& e) {
83121       {
83122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83123       };
83124     } catch (std::exception& e) {
83125       {
83126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83127       };
83128     } catch (...) {
83129       {
83130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83131       };
83132     }
83133   }
83134   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83135   return jresult;
83136 }
83137
83138
83139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
83140   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83141   Dali::Actor arg2 ;
83142   Dali::Actor *argp2 ;
83143
83144   arg1 = (Dali::Toolkit::Popup *)jarg1;
83145   argp2 = (Dali::Actor *)jarg2;
83146   if (!argp2) {
83147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83148     return ;
83149   }
83150   arg2 = *argp2;
83151   {
83152     try {
83153       (arg1)->SetTitle(arg2);
83154     } catch (std::out_of_range& e) {
83155       {
83156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83157       };
83158     } catch (std::exception& e) {
83159       {
83160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83161       };
83162     } catch (...) {
83163       {
83164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83165       };
83166     }
83167   }
83168 }
83169
83170
83171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
83172   void * jresult ;
83173   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83174   Dali::Actor result;
83175
83176   arg1 = (Dali::Toolkit::Popup *)jarg1;
83177   {
83178     try {
83179       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
83180     } catch (std::out_of_range& e) {
83181       {
83182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83183       };
83184     } catch (std::exception& e) {
83185       {
83186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83187       };
83188     } catch (...) {
83189       {
83190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83191       };
83192     }
83193   }
83194   jresult = new Dali::Actor((const Dali::Actor &)result);
83195   return jresult;
83196 }
83197
83198
83199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83200   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83201   Dali::Actor arg2 ;
83202   Dali::Actor *argp2 ;
83203
83204   arg1 = (Dali::Toolkit::Popup *)jarg1;
83205   argp2 = (Dali::Actor *)jarg2;
83206   if (!argp2) {
83207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83208     return ;
83209   }
83210   arg2 = *argp2;
83211   {
83212     try {
83213       (arg1)->SetContent(arg2);
83214     } catch (std::out_of_range& e) {
83215       {
83216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83217       };
83218     } catch (std::exception& e) {
83219       {
83220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83221       };
83222     } catch (...) {
83223       {
83224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83225       };
83226     }
83227   }
83228 }
83229
83230
83231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83232   void * jresult ;
83233   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83234   Dali::Actor result;
83235
83236   arg1 = (Dali::Toolkit::Popup *)jarg1;
83237   {
83238     try {
83239       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83240     } catch (std::out_of_range& e) {
83241       {
83242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83243       };
83244     } catch (std::exception& e) {
83245       {
83246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83247       };
83248     } catch (...) {
83249       {
83250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83251       };
83252     }
83253   }
83254   jresult = new Dali::Actor((const Dali::Actor &)result);
83255   return jresult;
83256 }
83257
83258
83259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83260   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83261   Dali::Actor arg2 ;
83262   Dali::Actor *argp2 ;
83263
83264   arg1 = (Dali::Toolkit::Popup *)jarg1;
83265   argp2 = (Dali::Actor *)jarg2;
83266   if (!argp2) {
83267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83268     return ;
83269   }
83270   arg2 = *argp2;
83271   {
83272     try {
83273       (arg1)->SetFooter(arg2);
83274     } catch (std::out_of_range& e) {
83275       {
83276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83277       };
83278     } catch (std::exception& e) {
83279       {
83280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83281       };
83282     } catch (...) {
83283       {
83284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83285       };
83286     }
83287   }
83288 }
83289
83290
83291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83292   void * jresult ;
83293   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83294   Dali::Actor result;
83295
83296   arg1 = (Dali::Toolkit::Popup *)jarg1;
83297   {
83298     try {
83299       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83300     } catch (std::out_of_range& e) {
83301       {
83302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83303       };
83304     } catch (std::exception& e) {
83305       {
83306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83307       };
83308     } catch (...) {
83309       {
83310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83311       };
83312     }
83313   }
83314   jresult = new Dali::Actor((const Dali::Actor &)result);
83315   return jresult;
83316 }
83317
83318
83319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83320   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83321   Dali::Toolkit::Popup::DisplayState arg2 ;
83322
83323   arg1 = (Dali::Toolkit::Popup *)jarg1;
83324   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83325   {
83326     try {
83327       (arg1)->SetDisplayState(arg2);
83328     } catch (std::out_of_range& e) {
83329       {
83330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83331       };
83332     } catch (std::exception& e) {
83333       {
83334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83335       };
83336     } catch (...) {
83337       {
83338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83339       };
83340     }
83341   }
83342 }
83343
83344
83345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83346   int jresult ;
83347   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83348   Dali::Toolkit::Popup::DisplayState result;
83349
83350   arg1 = (Dali::Toolkit::Popup *)jarg1;
83351   {
83352     try {
83353       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83354     } catch (std::out_of_range& e) {
83355       {
83356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83357       };
83358     } catch (std::exception& e) {
83359       {
83360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83361       };
83362     } catch (...) {
83363       {
83364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83365       };
83366     }
83367   }
83368   jresult = (int)result;
83369   return jresult;
83370 }
83371
83372
83373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83374   void * jresult ;
83375   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83376   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83377
83378   arg1 = (Dali::Toolkit::Popup *)jarg1;
83379   {
83380     try {
83381       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83382     } catch (std::out_of_range& e) {
83383       {
83384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83385       };
83386     } catch (std::exception& e) {
83387       {
83388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83389       };
83390     } catch (...) {
83391       {
83392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83393       };
83394     }
83395   }
83396   jresult = (void *)result;
83397   return jresult;
83398 }
83399
83400
83401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83402   void * jresult ;
83403   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83404   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83405
83406   arg1 = (Dali::Toolkit::Popup *)jarg1;
83407   {
83408     try {
83409       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83410     } catch (std::out_of_range& e) {
83411       {
83412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83413       };
83414     } catch (std::exception& e) {
83415       {
83416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83417       };
83418     } catch (...) {
83419       {
83420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83421       };
83422     }
83423   }
83424   jresult = (void *)result;
83425   return jresult;
83426 }
83427
83428
83429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83430   void * jresult ;
83431   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83432   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83433
83434   arg1 = (Dali::Toolkit::Popup *)jarg1;
83435   {
83436     try {
83437       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83438     } catch (std::out_of_range& e) {
83439       {
83440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83441       };
83442     } catch (std::exception& e) {
83443       {
83444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83445       };
83446     } catch (...) {
83447       {
83448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83449       };
83450     }
83451   }
83452   jresult = (void *)result;
83453   return jresult;
83454 }
83455
83456
83457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83458   void * jresult ;
83459   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83460   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83461
83462   arg1 = (Dali::Toolkit::Popup *)jarg1;
83463   {
83464     try {
83465       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83466     } catch (std::out_of_range& e) {
83467       {
83468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83469       };
83470     } catch (std::exception& e) {
83471       {
83472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83473       };
83474     } catch (...) {
83475       {
83476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83477       };
83478     }
83479   }
83480   jresult = (void *)result;
83481   return jresult;
83482 }
83483
83484
83485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83486   void * jresult ;
83487   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83488   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83489
83490   arg1 = (Dali::Toolkit::Popup *)jarg1;
83491   {
83492     try {
83493       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83494     } catch (std::out_of_range& e) {
83495       {
83496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83497       };
83498     } catch (std::exception& e) {
83499       {
83500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83501       };
83502     } catch (...) {
83503       {
83504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83505       };
83506     }
83507   }
83508   jresult = (void *)result;
83509   return jresult;
83510 }
83511
83512
83513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83514   int jresult ;
83515   int result;
83516
83517   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83518   jresult = (int)result;
83519   return jresult;
83520 }
83521
83522
83523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83524   int jresult ;
83525   int result;
83526
83527   //result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83528   //jresult = (int)result;
83529   return jresult;
83530 }
83531
83532
83533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83534   int jresult ;
83535   int result;
83536
83537   //result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83538   //jresult = (int)result;
83539   return jresult;
83540 }
83541
83542
83543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83544   int jresult ;
83545   int result;
83546
83547   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83548   jresult = (int)result;
83549   return jresult;
83550 }
83551
83552
83553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83554   int jresult ;
83555   int result;
83556
83557   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83558   jresult = (int)result;
83559   return jresult;
83560 }
83561
83562
83563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83564   int jresult ;
83565   int result;
83566
83567   //result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83568   //jresult = (int)result;
83569   return jresult;
83570 }
83571
83572
83573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83574   int jresult ;
83575   int result;
83576
83577   //result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83578   //jresult = (int)result;
83579   return jresult;
83580 }
83581
83582
83583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83584   int jresult ;
83585   int result;
83586
83587   //result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83588   //jresult = (int)result;
83589   return jresult;
83590 }
83591
83592
83593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83594   int jresult ;
83595   int result;
83596
83597   //result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83598   //jresult = (int)result;
83599   return jresult;
83600 }
83601
83602
83603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83604   void * jresult ;
83605   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83606
83607   {
83608     try {
83609       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83610     } catch (std::out_of_range& e) {
83611       {
83612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83613       };
83614     } catch (std::exception& e) {
83615       {
83616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83617       };
83618     } catch (...) {
83619       {
83620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83621       };
83622     }
83623   }
83624   jresult = (void *)result;
83625   return jresult;
83626 }
83627
83628
83629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83630   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83631
83632   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83633   {
83634     try {
83635       delete arg1;
83636     } catch (std::out_of_range& e) {
83637       {
83638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83639       };
83640     } catch (std::exception& e) {
83641       {
83642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83643       };
83644     } catch (...) {
83645       {
83646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83647       };
83648     }
83649   }
83650 }
83651
83652
83653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83654   void * jresult ;
83655   Dali::Toolkit::ProgressBar result;
83656
83657   {
83658     try {
83659       result = Dali::Toolkit::ProgressBar::New();
83660     } catch (std::out_of_range& e) {
83661       {
83662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83663       };
83664     } catch (std::exception& e) {
83665       {
83666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83667       };
83668     } catch (...) {
83669       {
83670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83671       };
83672     }
83673   }
83674   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83675   return jresult;
83676 }
83677
83678
83679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83680   void * jresult ;
83681   Dali::Toolkit::ProgressBar *result = 0 ;
83682
83683   {
83684     try {
83685       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83686     } catch (std::out_of_range& e) {
83687       {
83688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83689       };
83690     } catch (std::exception& e) {
83691       {
83692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83693       };
83694     } catch (...) {
83695       {
83696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83697       };
83698     }
83699   }
83700   jresult = (void *)result;
83701   return jresult;
83702 }
83703
83704
83705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83706   void * jresult ;
83707   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83708   Dali::Toolkit::ProgressBar *result = 0 ;
83709
83710   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83711   if (!arg1) {
83712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83713     return 0;
83714   }
83715   {
83716     try {
83717       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83718     } catch (std::out_of_range& e) {
83719       {
83720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83721       };
83722     } catch (std::exception& e) {
83723       {
83724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83725       };
83726     } catch (...) {
83727       {
83728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83729       };
83730     }
83731   }
83732   jresult = (void *)result;
83733   return jresult;
83734 }
83735
83736
83737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83738   void * jresult ;
83739   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83740   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83741   Dali::Toolkit::ProgressBar *result = 0 ;
83742
83743   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83744   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83745   if (!arg2) {
83746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83747     return 0;
83748   }
83749   {
83750     try {
83751       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83752     } catch (std::out_of_range& e) {
83753       {
83754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83755       };
83756     } catch (std::exception& e) {
83757       {
83758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83759       };
83760     } catch (...) {
83761       {
83762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83763       };
83764     }
83765   }
83766   jresult = (void *)result;
83767   return jresult;
83768 }
83769
83770
83771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83772   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83773
83774   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83775   {
83776     try {
83777       delete arg1;
83778     } catch (std::out_of_range& e) {
83779       {
83780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83781       };
83782     } catch (std::exception& e) {
83783       {
83784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83785       };
83786     } catch (...) {
83787       {
83788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83789       };
83790     }
83791   }
83792 }
83793
83794
83795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83796   void * jresult ;
83797   Dali::BaseHandle arg1 ;
83798   Dali::BaseHandle *argp1 ;
83799   Dali::Toolkit::ProgressBar result;
83800
83801   argp1 = (Dali::BaseHandle *)jarg1;
83802   if (!argp1) {
83803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83804     return 0;
83805   }
83806   arg1 = *argp1;
83807   {
83808     try {
83809       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83810     } catch (std::out_of_range& e) {
83811       {
83812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83813       };
83814     } catch (std::exception& e) {
83815       {
83816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83817       };
83818     } catch (...) {
83819       {
83820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83821       };
83822     }
83823   }
83824   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83825   return jresult;
83826 }
83827
83828
83829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83830   void * jresult ;
83831   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83832   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83833
83834   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83835   {
83836     try {
83837       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83838     } catch (std::out_of_range& e) {
83839       {
83840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83841       };
83842     } catch (std::exception& e) {
83843       {
83844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83845       };
83846     } catch (...) {
83847       {
83848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83849       };
83850     }
83851   }
83852   jresult = (void *)result;
83853   return jresult;
83854 }
83855
83856
83857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83858   void * jresult ;
83859   Dali::Toolkit::GaussianBlurView *result = 0 ;
83860
83861   {
83862     try {
83863       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83864     } catch (std::out_of_range& e) {
83865       {
83866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83867       };
83868     } catch (std::exception& e) {
83869       {
83870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83871       };
83872     } catch (...) {
83873       {
83874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83875       };
83876     }
83877   }
83878   jresult = (void *)result;
83879   return jresult;
83880 }
83881
83882
83883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83884   void * jresult ;
83885   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83886   Dali::Toolkit::GaussianBlurView *result = 0 ;
83887
83888   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83889   if (!arg1) {
83890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83891     return 0;
83892   }
83893   {
83894     try {
83895       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83896     } catch (std::out_of_range& e) {
83897       {
83898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83899       };
83900     } catch (std::exception& e) {
83901       {
83902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83903       };
83904     } catch (...) {
83905       {
83906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83907       };
83908     }
83909   }
83910   jresult = (void *)result;
83911   return jresult;
83912 }
83913
83914
83915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83916   void * jresult ;
83917   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83918   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83919   Dali::Toolkit::GaussianBlurView *result = 0 ;
83920
83921   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83922   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83923   if (!arg2) {
83924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83925     return 0;
83926   }
83927   {
83928     try {
83929       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83930     } catch (std::out_of_range& e) {
83931       {
83932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83933       };
83934     } catch (std::exception& e) {
83935       {
83936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83937       };
83938     } catch (...) {
83939       {
83940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83941       };
83942     }
83943   }
83944   jresult = (void *)result;
83945   return jresult;
83946 }
83947
83948
83949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83950   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83951
83952   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83953   {
83954     try {
83955       delete arg1;
83956     } catch (std::out_of_range& e) {
83957       {
83958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83959       };
83960     } catch (std::exception& e) {
83961       {
83962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83963       };
83964     } catch (...) {
83965       {
83966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83967       };
83968     }
83969   }
83970 }
83971
83972
83973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83974   void * jresult ;
83975   Dali::BaseHandle arg1 ;
83976   Dali::BaseHandle *argp1 ;
83977   Dali::Toolkit::GaussianBlurView result;
83978
83979   argp1 = (Dali::BaseHandle *)jarg1;
83980   if (!argp1) {
83981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83982     return 0;
83983   }
83984   arg1 = *argp1;
83985   {
83986     try {
83987       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83988     } catch (std::out_of_range& e) {
83989       {
83990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83991       };
83992     } catch (std::exception& e) {
83993       {
83994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83995       };
83996     } catch (...) {
83997       {
83998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83999       };
84000     }
84001   }
84002   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84003   return jresult;
84004 }
84005
84006
84007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
84008   void * jresult ;
84009   Dali::Toolkit::GaussianBlurView result;
84010
84011   {
84012     try {
84013       result = Dali::Toolkit::GaussianBlurView::New();
84014     } catch (std::out_of_range& e) {
84015       {
84016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84017       };
84018     } catch (std::exception& e) {
84019       {
84020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84021       };
84022     } catch (...) {
84023       {
84024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84025       };
84026     }
84027   }
84028   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84029   return jresult;
84030 }
84031
84032
84033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
84034   void * jresult ;
84035   unsigned int arg1 ;
84036   float arg2 ;
84037   Dali::Pixel::Format arg3 ;
84038   float arg4 ;
84039   float arg5 ;
84040   bool arg6 ;
84041   Dali::Toolkit::GaussianBlurView result;
84042
84043   arg1 = (unsigned int)jarg1;
84044   arg2 = (float)jarg2;
84045   arg3 = (Dali::Pixel::Format)jarg3;
84046   arg4 = (float)jarg4;
84047   arg5 = (float)jarg5;
84048   arg6 = jarg6 ? true : false;
84049   {
84050     try {
84051       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
84052     } catch (std::out_of_range& e) {
84053       {
84054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84055       };
84056     } catch (std::exception& e) {
84057       {
84058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84059       };
84060     } catch (...) {
84061       {
84062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84063       };
84064     }
84065   }
84066   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84067   return jresult;
84068 }
84069
84070
84071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
84072   void * jresult ;
84073   unsigned int arg1 ;
84074   float arg2 ;
84075   Dali::Pixel::Format arg3 ;
84076   float arg4 ;
84077   float arg5 ;
84078   Dali::Toolkit::GaussianBlurView result;
84079
84080   arg1 = (unsigned int)jarg1;
84081   arg2 = (float)jarg2;
84082   arg3 = (Dali::Pixel::Format)jarg3;
84083   arg4 = (float)jarg4;
84084   arg5 = (float)jarg5;
84085   {
84086     try {
84087       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
84088     } catch (std::out_of_range& e) {
84089       {
84090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84091       };
84092     } catch (std::exception& e) {
84093       {
84094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84095       };
84096     } catch (...) {
84097       {
84098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84099       };
84100     }
84101   }
84102   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84103   return jresult;
84104 }
84105
84106
84107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
84108   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84109   Dali::Actor arg2 ;
84110   Dali::Actor *argp2 ;
84111
84112   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84113   argp2 = (Dali::Actor *)jarg2;
84114   if (!argp2) {
84115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84116     return ;
84117   }
84118   arg2 = *argp2;
84119   {
84120     try {
84121       (arg1)->Add(arg2);
84122     } catch (std::out_of_range& e) {
84123       {
84124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84125       };
84126     } catch (std::exception& e) {
84127       {
84128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84129       };
84130     } catch (...) {
84131       {
84132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84133       };
84134     }
84135   }
84136 }
84137
84138
84139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84140   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84141   Dali::Actor arg2 ;
84142   Dali::Actor *argp2 ;
84143
84144   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84145   argp2 = (Dali::Actor *)jarg2;
84146   if (!argp2) {
84147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84148     return ;
84149   }
84150   arg2 = *argp2;
84151   {
84152     try {
84153       (arg1)->Remove(arg2);
84154     } catch (std::out_of_range& e) {
84155       {
84156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84157       };
84158     } catch (std::exception& e) {
84159       {
84160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84161       };
84162     } catch (...) {
84163       {
84164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84165       };
84166     }
84167   }
84168 }
84169
84170
84171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84172   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84173
84174   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84175   {
84176     try {
84177       (arg1)->Activate();
84178     } catch (std::out_of_range& e) {
84179       {
84180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84181       };
84182     } catch (std::exception& e) {
84183       {
84184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84185       };
84186     } catch (...) {
84187       {
84188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84189       };
84190     }
84191   }
84192 }
84193
84194
84195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84196   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84197
84198   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84199   {
84200     try {
84201       (arg1)->ActivateOnce();
84202     } catch (std::out_of_range& e) {
84203       {
84204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84205       };
84206     } catch (std::exception& e) {
84207       {
84208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84209       };
84210     } catch (...) {
84211       {
84212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84213       };
84214     }
84215   }
84216 }
84217
84218
84219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84220   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84221
84222   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84223   {
84224     try {
84225       (arg1)->Deactivate();
84226     } catch (std::out_of_range& e) {
84227       {
84228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84229       };
84230     } catch (std::exception& e) {
84231       {
84232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84233       };
84234     } catch (...) {
84235       {
84236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84237       };
84238     }
84239   }
84240 }
84241
84242
84243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84244   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84245   Dali::Image arg2 ;
84246   Dali::FrameBufferImage arg3 ;
84247   Dali::Image *argp2 ;
84248   Dali::FrameBufferImage *argp3 ;
84249
84250   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84251   argp2 = (Dali::Image *)jarg2;
84252   if (!argp2) {
84253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
84254     return ;
84255   }
84256   arg2 = *argp2;
84257   argp3 = (Dali::FrameBufferImage *)jarg3;
84258   if (!argp3) {
84259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
84260     return ;
84261   }
84262   arg3 = *argp3;
84263   {
84264     try {
84265       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84266     } catch (std::out_of_range& e) {
84267       {
84268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84269       };
84270     } catch (std::exception& e) {
84271       {
84272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84273       };
84274     } catch (...) {
84275       {
84276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84277       };
84278     }
84279   }
84280 }
84281
84282
84283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84284   int jresult ;
84285   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84286   Dali::Property::Index result;
84287
84288   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84289   {
84290     try {
84291       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84292     } catch (std::out_of_range& e) {
84293       {
84294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84295       };
84296     } catch (std::exception& e) {
84297       {
84298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84299       };
84300     } catch (...) {
84301       {
84302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84303       };
84304     }
84305   }
84306   jresult = result;
84307   return jresult;
84308 }
84309
84310
84311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84312   void * jresult ;
84313   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84314   Dali::FrameBufferImage result;
84315
84316   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84317   {
84318     try {
84319       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84320     } catch (std::out_of_range& e) {
84321       {
84322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84323       };
84324     } catch (std::exception& e) {
84325       {
84326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84327       };
84328     } catch (...) {
84329       {
84330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84331       };
84332     }
84333   }
84334   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
84335   return jresult;
84336 }
84337
84338
84339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84340   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84341   Dali::Vector4 *arg2 = 0 ;
84342
84343   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84344   arg2 = (Dali::Vector4 *)jarg2;
84345   if (!arg2) {
84346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84347     return ;
84348   }
84349   {
84350     try {
84351       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84352     } catch (std::out_of_range& e) {
84353       {
84354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84355       };
84356     } catch (std::exception& e) {
84357       {
84358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84359       };
84360     } catch (...) {
84361       {
84362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84363       };
84364     }
84365   }
84366 }
84367
84368
84369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84370   void * jresult ;
84371   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84372   Dali::Vector4 result;
84373
84374   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84375   {
84376     try {
84377       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84378     } catch (std::out_of_range& e) {
84379       {
84380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84381       };
84382     } catch (std::exception& e) {
84383       {
84384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84385       };
84386     } catch (...) {
84387       {
84388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84389       };
84390     }
84391   }
84392   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84393   return jresult;
84394 }
84395
84396
84397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84398   void * jresult ;
84399   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84400   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84401
84402   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84403   {
84404     try {
84405       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84406     } catch (std::out_of_range& e) {
84407       {
84408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84409       };
84410     } catch (std::exception& e) {
84411       {
84412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84413       };
84414     } catch (...) {
84415       {
84416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84417       };
84418     }
84419   }
84420   jresult = (void *)result;
84421   return jresult;
84422 }
84423
84424
84425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84426   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84427
84428   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84429   {
84430     try {
84431       delete arg1;
84432     } catch (std::out_of_range& e) {
84433       {
84434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84435       };
84436     } catch (std::exception& e) {
84437       {
84438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84439       };
84440     } catch (...) {
84441       {
84442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84443       };
84444     }
84445   }
84446 }
84447
84448
84449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84450   unsigned int jresult ;
84451   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84452   unsigned int result;
84453
84454   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84455   {
84456     try {
84457       result = (unsigned int)(arg1)->GetNumberOfPages();
84458     } catch (std::out_of_range& e) {
84459       {
84460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84461       };
84462     } catch (std::exception& e) {
84463       {
84464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84465       };
84466     } catch (...) {
84467       {
84468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84469       };
84470     }
84471   }
84472   jresult = result;
84473   return jresult;
84474 }
84475
84476
84477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84478   void * jresult ;
84479   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84480   unsigned int arg2 ;
84481   Dali::Texture result;
84482
84483   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84484   arg2 = (unsigned int)jarg2;
84485   {
84486     try {
84487       result = (arg1)->NewPage(arg2);
84488     } catch (std::out_of_range& e) {
84489       {
84490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84491       };
84492     } catch (std::exception& e) {
84493       {
84494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84495       };
84496     } catch (...) {
84497       {
84498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84499       };
84500     }
84501   }
84502   jresult = new Dali::Texture((const Dali::Texture &)result);
84503   return jresult;
84504 }
84505
84506
84507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
84508   int jresult ;
84509   int result;
84510
84511   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
84512   jresult = (int)result;
84513   return jresult;
84514 }
84515
84516
84517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84518   int jresult ;
84519   int result;
84520
84521   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84522   jresult = (int)result;
84523   return jresult;
84524 }
84525
84526
84527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84528   int jresult ;
84529   int result;
84530
84531   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84532   jresult = (int)result;
84533   return jresult;
84534 }
84535
84536
84537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84538   void * jresult ;
84539   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84540
84541   {
84542     try {
84543       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84544     } catch (std::out_of_range& e) {
84545       {
84546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84547       };
84548     } catch (std::exception& e) {
84549       {
84550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84551       };
84552     } catch (...) {
84553       {
84554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84555       };
84556     }
84557   }
84558   jresult = (void *)result;
84559   return jresult;
84560 }
84561
84562
84563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84564   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84565
84566   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84567   {
84568     try {
84569       delete arg1;
84570     } catch (std::out_of_range& e) {
84571       {
84572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84573       };
84574     } catch (std::exception& e) {
84575       {
84576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84577       };
84578     } catch (...) {
84579       {
84580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84581       };
84582     }
84583   }
84584 }
84585
84586
84587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84588   void * jresult ;
84589   Dali::Toolkit::PageTurnView *result = 0 ;
84590
84591   {
84592     try {
84593       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84594     } catch (std::out_of_range& e) {
84595       {
84596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84597       };
84598     } catch (std::exception& e) {
84599       {
84600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84601       };
84602     } catch (...) {
84603       {
84604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84605       };
84606     }
84607   }
84608   jresult = (void *)result;
84609   return jresult;
84610 }
84611
84612
84613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84614   void * jresult ;
84615   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84616   Dali::Toolkit::PageTurnView *result = 0 ;
84617
84618   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84619   if (!arg1) {
84620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84621     return 0;
84622   }
84623   {
84624     try {
84625       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84626     } catch (std::out_of_range& e) {
84627       {
84628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84629       };
84630     } catch (std::exception& e) {
84631       {
84632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84633       };
84634     } catch (...) {
84635       {
84636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84637       };
84638     }
84639   }
84640   jresult = (void *)result;
84641   return jresult;
84642 }
84643
84644
84645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84646   void * jresult ;
84647   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84648   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84649   Dali::Toolkit::PageTurnView *result = 0 ;
84650
84651   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84652   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84653   if (!arg2) {
84654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84655     return 0;
84656   }
84657   {
84658     try {
84659       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84660     } catch (std::out_of_range& e) {
84661       {
84662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84663       };
84664     } catch (std::exception& e) {
84665       {
84666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84667       };
84668     } catch (...) {
84669       {
84670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84671       };
84672     }
84673   }
84674   jresult = (void *)result;
84675   return jresult;
84676 }
84677
84678
84679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84680   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84681
84682   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84683   {
84684     try {
84685       delete arg1;
84686     } catch (std::out_of_range& e) {
84687       {
84688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84689       };
84690     } catch (std::exception& e) {
84691       {
84692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84693       };
84694     } catch (...) {
84695       {
84696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84697       };
84698     }
84699   }
84700 }
84701
84702
84703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84704   void * jresult ;
84705   Dali::BaseHandle arg1 ;
84706   Dali::BaseHandle *argp1 ;
84707   Dali::Toolkit::PageTurnView result;
84708
84709   argp1 = (Dali::BaseHandle *)jarg1;
84710   if (!argp1) {
84711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84712     return 0;
84713   }
84714   arg1 = *argp1;
84715   {
84716     try {
84717       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84718     } catch (std::out_of_range& e) {
84719       {
84720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84721       };
84722     } catch (std::exception& e) {
84723       {
84724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84725       };
84726     } catch (...) {
84727       {
84728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84729       };
84730     }
84731   }
84732   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84733   return jresult;
84734 }
84735
84736
84737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84738   void * jresult ;
84739   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84740   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84741
84742   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84743   {
84744     try {
84745       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84746     } catch (std::out_of_range& e) {
84747       {
84748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84749       };
84750     } catch (std::exception& e) {
84751       {
84752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84753       };
84754     } catch (...) {
84755       {
84756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84757       };
84758     }
84759   }
84760   jresult = (void *)result;
84761   return jresult;
84762 }
84763
84764
84765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84766   void * jresult ;
84767   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84768   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84769
84770   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84771   {
84772     try {
84773       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84774     } catch (std::out_of_range& e) {
84775       {
84776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84777       };
84778     } catch (std::exception& e) {
84779       {
84780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84781       };
84782     } catch (...) {
84783       {
84784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84785       };
84786     }
84787   }
84788   jresult = (void *)result;
84789   return jresult;
84790 }
84791
84792
84793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84794   void * jresult ;
84795   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84796   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84797
84798   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84799   {
84800     try {
84801       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84802     } catch (std::out_of_range& e) {
84803       {
84804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84805       };
84806     } catch (std::exception& e) {
84807       {
84808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84809       };
84810     } catch (...) {
84811       {
84812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84813       };
84814     }
84815   }
84816   jresult = (void *)result;
84817   return jresult;
84818 }
84819
84820
84821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84822   void * jresult ;
84823   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84824   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84825
84826   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84827   {
84828     try {
84829       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84830     } catch (std::out_of_range& e) {
84831       {
84832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84833       };
84834     } catch (std::exception& e) {
84835       {
84836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84837       };
84838     } catch (...) {
84839       {
84840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84841       };
84842     }
84843   }
84844   jresult = (void *)result;
84845   return jresult;
84846 }
84847
84848
84849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84850   void * jresult ;
84851   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84852
84853   {
84854     try {
84855       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84856     } catch (std::out_of_range& e) {
84857       {
84858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84859       };
84860     } catch (std::exception& e) {
84861       {
84862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84863       };
84864     } catch (...) {
84865       {
84866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84867       };
84868     }
84869   }
84870   jresult = (void *)result;
84871   return jresult;
84872 }
84873
84874
84875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84876   void * jresult ;
84877   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84878   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84879
84880   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84881   if (!arg1) {
84882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84883     return 0;
84884   }
84885   {
84886     try {
84887       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84888     } catch (std::out_of_range& e) {
84889       {
84890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84891       };
84892     } catch (std::exception& e) {
84893       {
84894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84895       };
84896     } catch (...) {
84897       {
84898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84899       };
84900     }
84901   }
84902   jresult = (void *)result;
84903   return jresult;
84904 }
84905
84906
84907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84908   void * jresult ;
84909   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84910   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84911   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84912
84913   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84914   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84915   if (!arg2) {
84916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84917     return 0;
84918   }
84919   {
84920     try {
84921       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84922     } catch (std::out_of_range& e) {
84923       {
84924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84925       };
84926     } catch (std::exception& e) {
84927       {
84928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84929       };
84930     } catch (...) {
84931       {
84932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84933       };
84934     }
84935   }
84936   jresult = (void *)result;
84937   return jresult;
84938 }
84939
84940
84941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84942   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84943
84944   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84945   {
84946     try {
84947       delete arg1;
84948     } catch (std::out_of_range& e) {
84949       {
84950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84951       };
84952     } catch (std::exception& e) {
84953       {
84954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84955       };
84956     } catch (...) {
84957       {
84958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84959       };
84960     }
84961   }
84962 }
84963
84964
84965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84966   void * jresult ;
84967   Dali::Toolkit::PageFactory *arg1 = 0 ;
84968   Dali::Vector2 *arg2 = 0 ;
84969   Dali::Toolkit::PageTurnLandscapeView result;
84970
84971   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84972   if (!arg1) {
84973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84974     return 0;
84975   }
84976   arg2 = (Dali::Vector2 *)jarg2;
84977   if (!arg2) {
84978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84979     return 0;
84980   }
84981   {
84982     try {
84983       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84984     } catch (std::out_of_range& e) {
84985       {
84986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84987       };
84988     } catch (std::exception& e) {
84989       {
84990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84991       };
84992     } catch (...) {
84993       {
84994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84995       };
84996     }
84997   }
84998   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84999   return jresult;
85000 }
85001
85002
85003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
85004   void * jresult ;
85005   Dali::BaseHandle arg1 ;
85006   Dali::BaseHandle *argp1 ;
85007   Dali::Toolkit::PageTurnLandscapeView result;
85008
85009   argp1 = (Dali::BaseHandle *)jarg1;
85010   if (!argp1) {
85011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85012     return 0;
85013   }
85014   arg1 = *argp1;
85015   {
85016     try {
85017       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
85018     } catch (std::out_of_range& e) {
85019       {
85020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85021       };
85022     } catch (std::exception& e) {
85023       {
85024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85025       };
85026     } catch (...) {
85027       {
85028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85029       };
85030     }
85031   }
85032   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85033   return jresult;
85034 }
85035
85036
85037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85038   void * jresult ;
85039   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85040
85041   {
85042     try {
85043       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85044     } catch (std::out_of_range& e) {
85045       {
85046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85047       };
85048     } catch (std::exception& e) {
85049       {
85050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85051       };
85052     } catch (...) {
85053       {
85054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85055       };
85056     }
85057   }
85058   jresult = (void *)result;
85059   return jresult;
85060 }
85061
85062
85063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85064   void * jresult ;
85065   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85066   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85067
85068   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85069   if (!arg1) {
85070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85071     return 0;
85072   }
85073   {
85074     try {
85075       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85076     } catch (std::out_of_range& e) {
85077       {
85078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85079       };
85080     } catch (std::exception& e) {
85081       {
85082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85083       };
85084     } catch (...) {
85085       {
85086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85087       };
85088     }
85089   }
85090   jresult = (void *)result;
85091   return jresult;
85092 }
85093
85094
85095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85096   void * jresult ;
85097   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85098   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85099   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85100
85101   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85102   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85103   if (!arg2) {
85104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85105     return 0;
85106   }
85107   {
85108     try {
85109       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85110     } catch (std::out_of_range& e) {
85111       {
85112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85113       };
85114     } catch (std::exception& e) {
85115       {
85116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85117       };
85118     } catch (...) {
85119       {
85120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85121       };
85122     }
85123   }
85124   jresult = (void *)result;
85125   return jresult;
85126 }
85127
85128
85129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85130   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85131
85132   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85133   {
85134     try {
85135       delete arg1;
85136     } catch (std::out_of_range& e) {
85137       {
85138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85139       };
85140     } catch (std::exception& e) {
85141       {
85142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85143       };
85144     } catch (...) {
85145       {
85146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85147       };
85148     }
85149   }
85150 }
85151
85152
85153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85154   void * jresult ;
85155   Dali::Toolkit::PageFactory *arg1 = 0 ;
85156   Dali::Vector2 *arg2 = 0 ;
85157   Dali::Toolkit::PageTurnPortraitView result;
85158
85159   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85160   if (!arg1) {
85161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85162     return 0;
85163   }
85164   arg2 = (Dali::Vector2 *)jarg2;
85165   if (!arg2) {
85166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85167     return 0;
85168   }
85169   {
85170     try {
85171       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85172     } catch (std::out_of_range& e) {
85173       {
85174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85175       };
85176     } catch (std::exception& e) {
85177       {
85178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85179       };
85180     } catch (...) {
85181       {
85182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85183       };
85184     }
85185   }
85186   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85187   return jresult;
85188 }
85189
85190
85191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85192   void * jresult ;
85193   Dali::BaseHandle arg1 ;
85194   Dali::BaseHandle *argp1 ;
85195   Dali::Toolkit::PageTurnPortraitView result;
85196
85197   argp1 = (Dali::BaseHandle *)jarg1;
85198   if (!argp1) {
85199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85200     return 0;
85201   }
85202   arg1 = *argp1;
85203   {
85204     try {
85205       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85206     } catch (std::out_of_range& e) {
85207       {
85208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85209       };
85210     } catch (std::exception& e) {
85211       {
85212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85213       };
85214     } catch (...) {
85215       {
85216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85217       };
85218     }
85219   }
85220   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85221   return jresult;
85222 }
85223
85224
85225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85226   int jresult ;
85227   int result;
85228
85229   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85230   jresult = (int)result;
85231   return jresult;
85232 }
85233
85234
85235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85236   int jresult ;
85237   int result;
85238
85239   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85240   jresult = (int)result;
85241   return jresult;
85242 }
85243
85244
85245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85246   int jresult ;
85247   int result;
85248
85249   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85250   jresult = (int)result;
85251   return jresult;
85252 }
85253
85254
85255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85256   void * jresult ;
85257   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85258
85259   {
85260     try {
85261       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85262     } catch (std::out_of_range& e) {
85263       {
85264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85265       };
85266     } catch (std::exception& e) {
85267       {
85268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85269       };
85270     } catch (...) {
85271       {
85272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85273       };
85274     }
85275   }
85276   jresult = (void *)result;
85277   return jresult;
85278 }
85279
85280
85281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85282   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85283
85284   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85285   {
85286     try {
85287       delete arg1;
85288     } catch (std::out_of_range& e) {
85289       {
85290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85291       };
85292     } catch (std::exception& e) {
85293       {
85294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85295       };
85296     } catch (...) {
85297       {
85298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85299       };
85300     }
85301   }
85302 }
85303
85304
85305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85306   void * jresult ;
85307   Dali::Toolkit::ToggleButton *result = 0 ;
85308
85309   {
85310     try {
85311       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85312     } catch (std::out_of_range& e) {
85313       {
85314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85315       };
85316     } catch (std::exception& e) {
85317       {
85318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85319       };
85320     } catch (...) {
85321       {
85322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85323       };
85324     }
85325   }
85326   jresult = (void *)result;
85327   return jresult;
85328 }
85329
85330
85331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85332   void * jresult ;
85333   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85334   Dali::Toolkit::ToggleButton *result = 0 ;
85335
85336   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85337   if (!arg1) {
85338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85339     return 0;
85340   }
85341   {
85342     try {
85343       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85344     } catch (std::out_of_range& e) {
85345       {
85346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85347       };
85348     } catch (std::exception& e) {
85349       {
85350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85351       };
85352     } catch (...) {
85353       {
85354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85355       };
85356     }
85357   }
85358   jresult = (void *)result;
85359   return jresult;
85360 }
85361
85362
85363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85364   void * jresult ;
85365   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85366   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85367   Dali::Toolkit::ToggleButton *result = 0 ;
85368
85369   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85370   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85371   if (!arg2) {
85372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85373     return 0;
85374   }
85375   {
85376     try {
85377       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85378     } catch (std::out_of_range& e) {
85379       {
85380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85381       };
85382     } catch (std::exception& e) {
85383       {
85384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85385       };
85386     } catch (...) {
85387       {
85388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85389       };
85390     }
85391   }
85392   jresult = (void *)result;
85393   return jresult;
85394 }
85395
85396
85397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85398   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85399
85400   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85401   {
85402     try {
85403       delete arg1;
85404     } catch (std::out_of_range& e) {
85405       {
85406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85407       };
85408     } catch (std::exception& e) {
85409       {
85410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85411       };
85412     } catch (...) {
85413       {
85414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85415       };
85416     }
85417   }
85418 }
85419
85420
85421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85422   void * jresult ;
85423   Dali::Toolkit::ToggleButton result;
85424
85425   {
85426     try {
85427       result = Dali::Toolkit::ToggleButton::New();
85428     } catch (std::out_of_range& e) {
85429       {
85430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85431       };
85432     } catch (std::exception& e) {
85433       {
85434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85435       };
85436     } catch (...) {
85437       {
85438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85439       };
85440     }
85441   }
85442   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85443   return jresult;
85444 }
85445
85446
85447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85448   void * jresult ;
85449   Dali::BaseHandle arg1 ;
85450   Dali::BaseHandle *argp1 ;
85451   Dali::Toolkit::ToggleButton result;
85452
85453   argp1 = (Dali::BaseHandle *)jarg1;
85454   if (!argp1) {
85455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85456     return 0;
85457   }
85458   arg1 = *argp1;
85459   {
85460     try {
85461       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85462     } catch (std::out_of_range& e) {
85463       {
85464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85465       };
85466     } catch (std::exception& e) {
85467       {
85468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85469       };
85470     } catch (...) {
85471       {
85472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85473       };
85474     }
85475   }
85476   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85477   return jresult;
85478 }
85479
85480
85481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85482   void * jresult ;
85483   Dali::Toolkit::Visual::Base *result = 0 ;
85484
85485   {
85486     try {
85487       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85488     } catch (std::out_of_range& e) {
85489       {
85490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85491       };
85492     } catch (std::exception& e) {
85493       {
85494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85495       };
85496     } catch (...) {
85497       {
85498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85499       };
85500     }
85501   }
85502   jresult = (void *)result;
85503   return jresult;
85504 }
85505
85506
85507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85508   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85509
85510   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85511   {
85512     try {
85513       delete arg1;
85514     } catch (std::out_of_range& e) {
85515       {
85516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85517       };
85518     } catch (std::exception& e) {
85519       {
85520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85521       };
85522     } catch (...) {
85523       {
85524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85525       };
85526     }
85527   }
85528 }
85529
85530
85531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85532   void * jresult ;
85533   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85534   Dali::Toolkit::Visual::Base *result = 0 ;
85535
85536   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85537   if (!arg1) {
85538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85539     return 0;
85540   }
85541   {
85542     try {
85543       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85544     } catch (std::out_of_range& e) {
85545       {
85546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85547       };
85548     } catch (std::exception& e) {
85549       {
85550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85551       };
85552     } catch (...) {
85553       {
85554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85555       };
85556     }
85557   }
85558   jresult = (void *)result;
85559   return jresult;
85560 }
85561
85562
85563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85564   void * jresult ;
85565   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85566   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85567   Dali::Toolkit::Visual::Base *result = 0 ;
85568
85569   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85570   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85571   if (!arg2) {
85572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85573     return 0;
85574   }
85575   {
85576     try {
85577       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85578     } catch (std::out_of_range& e) {
85579       {
85580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85581       };
85582     } catch (std::exception& e) {
85583       {
85584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85585       };
85586     } catch (...) {
85587       {
85588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85589       };
85590     }
85591   }
85592   jresult = (void *)result;
85593   return jresult;
85594 }
85595
85596
85597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85598   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85599   std::string *arg2 = 0 ;
85600
85601   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85602   if (!jarg2) {
85603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85604     return ;
85605   }
85606   std::string arg2_str(jarg2);
85607   arg2 = &arg2_str;
85608   {
85609     try {
85610       (arg1)->SetName((std::string const &)*arg2);
85611     } catch (std::out_of_range& e) {
85612       {
85613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85614       };
85615     } catch (std::exception& e) {
85616       {
85617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85618       };
85619     } catch (...) {
85620       {
85621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85622       };
85623     }
85624   }
85625
85626   //argout typemap for const std::string&
85627
85628 }
85629
85630
85631 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85632   char * jresult ;
85633   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85634   std::string *result = 0 ;
85635
85636   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85637   {
85638     try {
85639       result = (std::string *) &(arg1)->GetName();
85640     } catch (std::out_of_range& e) {
85641       {
85642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85643       };
85644     } catch (std::exception& e) {
85645       {
85646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85647       };
85648     } catch (...) {
85649       {
85650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85651       };
85652     }
85653   }
85654   jresult = SWIG_csharp_string_callback(result->c_str());
85655   return jresult;
85656 }
85657
85658
85659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85660   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85661   Dali::Property::Map *arg2 = 0 ;
85662   Dali::Size arg3 ;
85663   Dali::Size *argp3 ;
85664
85665   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85666   arg2 = (Dali::Property::Map *)jarg2;
85667   if (!arg2) {
85668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85669     return ;
85670   }
85671   argp3 = (Dali::Size *)jarg3;
85672   if (!argp3) {
85673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85674     return ;
85675   }
85676   arg3 = *argp3;
85677   {
85678     try {
85679       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85680     } catch (std::out_of_range& e) {
85681       {
85682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85683       };
85684     } catch (std::exception& e) {
85685       {
85686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85687       };
85688     } catch (...) {
85689       {
85690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85691       };
85692     }
85693   }
85694 }
85695
85696
85697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85698   float jresult ;
85699   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85700   float arg2 ;
85701   float result;
85702
85703   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85704   arg2 = (float)jarg2;
85705   {
85706     try {
85707       result = (float)(arg1)->GetHeightForWidth(arg2);
85708     } catch (std::out_of_range& e) {
85709       {
85710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85711       };
85712     } catch (std::exception& e) {
85713       {
85714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85715       };
85716     } catch (...) {
85717       {
85718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85719       };
85720     }
85721   }
85722   jresult = result;
85723   return jresult;
85724 }
85725
85726
85727 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85728   float jresult ;
85729   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85730   float arg2 ;
85731   float result;
85732
85733   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85734   arg2 = (float)jarg2;
85735   {
85736     try {
85737       result = (float)(arg1)->GetWidthForHeight(arg2);
85738     } catch (std::out_of_range& e) {
85739       {
85740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85741       };
85742     } catch (std::exception& e) {
85743       {
85744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85745       };
85746     } catch (...) {
85747       {
85748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85749       };
85750     }
85751   }
85752   jresult = result;
85753   return jresult;
85754 }
85755
85756
85757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85758   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85759   Dali::Vector2 *arg2 = 0 ;
85760
85761   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85762   arg2 = (Dali::Vector2 *)jarg2;
85763   if (!arg2) {
85764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85765     return ;
85766   }
85767   {
85768     try {
85769       (arg1)->GetNaturalSize(*arg2);
85770     } catch (std::out_of_range& e) {
85771       {
85772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85773       };
85774     } catch (std::exception& e) {
85775       {
85776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85777       };
85778     } catch (...) {
85779       {
85780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85781       };
85782     }
85783   }
85784 }
85785
85786
85787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
85788   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85789   float arg2 ;
85790
85791   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85792   arg2 = (float)jarg2;
85793   {
85794     try {
85795       (arg1)->SetDepthIndex(arg2);
85796     } catch (std::out_of_range& e) {
85797       {
85798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85799       };
85800     } catch (std::exception& e) {
85801       {
85802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85803       };
85804     } catch (...) {
85805       {
85806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85807       };
85808     }
85809   }
85810 }
85811
85812
85813 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85814   float jresult ;
85815   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85816   float result;
85817
85818   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85819   {
85820     try {
85821       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85822     } catch (std::out_of_range& e) {
85823       {
85824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85825       };
85826     } catch (std::exception& e) {
85827       {
85828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85829       };
85830     } catch (...) {
85831       {
85832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85833       };
85834     }
85835   }
85836   jresult = result;
85837   return jresult;
85838 }
85839
85840
85841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85842   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85843   Dali::Property::Map *arg2 = 0 ;
85844
85845   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85846   arg2 = (Dali::Property::Map *)jarg2;
85847   if (!arg2) {
85848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85849     return ;
85850   }
85851   {
85852     try {
85853       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85854     } catch (std::out_of_range& e) {
85855       {
85856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85857       };
85858     } catch (std::exception& e) {
85859       {
85860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85861       };
85862     } catch (...) {
85863       {
85864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85865       };
85866     }
85867   }
85868 }
85869
85870
85871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
85872   void * jresult ;
85873   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
85874   Dali::Toolkit::Visual::Base *result = 0 ;
85875
85876   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
85877   {
85878     try {
85879       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
85880     } catch (std::out_of_range& e) {
85881       {
85882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85883       };
85884     } catch (std::exception& e) {
85885       {
85886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85887       };
85888     } catch (...) {
85889       {
85890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85891       };
85892     }
85893   }
85894   jresult = (void *)result;
85895   return jresult;
85896 }
85897
85898
85899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85900   void * jresult ;
85901   Dali::Toolkit::VisualFactory result;
85902
85903   {
85904     try {
85905       result = Dali::Toolkit::VisualFactory::Get();
85906     } catch (std::out_of_range& e) {
85907       {
85908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85909       };
85910     } catch (std::exception& e) {
85911       {
85912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85913       };
85914     } catch (...) {
85915       {
85916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85917       };
85918     }
85919   }
85920   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85921   return jresult;
85922 }
85923
85924
85925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
85926   void * jresult ;
85927   Dali::Toolkit::VisualFactory *result = 0 ;
85928
85929   {
85930     try {
85931       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85932     } catch (std::out_of_range& e) {
85933       {
85934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85935       };
85936     } catch (std::exception& e) {
85937       {
85938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85939       };
85940     } catch (...) {
85941       {
85942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85943       };
85944     }
85945   }
85946   jresult = (void *)result;
85947   return jresult;
85948 }
85949
85950
85951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
85952   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85953
85954   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85955   {
85956     try {
85957       delete arg1;
85958     } catch (std::out_of_range& e) {
85959       {
85960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85961       };
85962     } catch (std::exception& e) {
85963       {
85964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85965       };
85966     } catch (...) {
85967       {
85968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85969       };
85970     }
85971   }
85972 }
85973
85974
85975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
85976   void * jresult ;
85977   Dali::Toolkit::VisualFactory *arg1 = 0 ;
85978   Dali::Toolkit::VisualFactory *result = 0 ;
85979
85980   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85981   if (!arg1) {
85982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85983     return 0;
85984   }
85985   {
85986     try {
85987       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
85988     } catch (std::out_of_range& e) {
85989       {
85990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85991       };
85992     } catch (std::exception& e) {
85993       {
85994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85995       };
85996     } catch (...) {
85997       {
85998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85999       };
86000     }
86001   }
86002   jresult = (void *)result;
86003   return jresult;
86004 }
86005
86006
86007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86008   void * jresult ;
86009   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86010   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86011   Dali::Toolkit::VisualFactory *result = 0 ;
86012
86013   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86014   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86015   if (!arg2) {
86016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86017     return 0;
86018   }
86019   {
86020     try {
86021       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86022     } catch (std::out_of_range& e) {
86023       {
86024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86025       };
86026     } catch (std::exception& e) {
86027       {
86028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86029       };
86030     } catch (...) {
86031       {
86032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86033       };
86034     }
86035   }
86036   jresult = (void *)result;
86037   return jresult;
86038 }
86039
86040
86041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86042   void * jresult ;
86043   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86044   Dali::Property::Map *arg2 = 0 ;
86045   Dali::Toolkit::Visual::Base result;
86046
86047   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86048   arg2 = (Dali::Property::Map *)jarg2;
86049   if (!arg2) {
86050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86051     return 0;
86052   }
86053   {
86054     try {
86055       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86056     } catch (std::out_of_range& e) {
86057       {
86058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86059       };
86060     } catch (std::exception& e) {
86061       {
86062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86063       };
86064     } catch (...) {
86065       {
86066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86067       };
86068     }
86069   }
86070   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86071   return jresult;
86072 }
86073
86074
86075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
86076   void * jresult ;
86077   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86078   Dali::Image *arg2 = 0 ;
86079   Dali::Toolkit::Visual::Base result;
86080
86081   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86082   arg2 = (Dali::Image *)jarg2;
86083   if (!arg2) {
86084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
86085     return 0;
86086   }
86087   {
86088     try {
86089       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
86090     } catch (std::out_of_range& e) {
86091       {
86092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86093       };
86094     } catch (std::exception& e) {
86095       {
86096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86097       };
86098     } catch (...) {
86099       {
86100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86101       };
86102     }
86103   }
86104   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86105   return jresult;
86106 }
86107
86108
86109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86110   void * jresult ;
86111   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86112   std::string *arg2 = 0 ;
86113   Dali::ImageDimensions arg3 ;
86114   Dali::ImageDimensions *argp3 ;
86115   Dali::Toolkit::Visual::Base result;
86116
86117   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86118   if (!jarg2) {
86119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86120     return 0;
86121   }
86122   std::string arg2_str(jarg2);
86123   arg2 = &arg2_str;
86124   argp3 = (Dali::ImageDimensions *)jarg3;
86125   if (!argp3) {
86126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86127     return 0;
86128   }
86129   arg3 = *argp3;
86130   {
86131     try {
86132       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86133     } catch (std::out_of_range& e) {
86134       {
86135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86136       };
86137     } catch (std::exception& e) {
86138       {
86139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86140       };
86141     } catch (...) {
86142       {
86143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86144       };
86145     }
86146   }
86147   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86148
86149   //argout typemap for const std::string&
86150
86151   return jresult;
86152 }
86153
86154
86155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86156   void * jresult ;
86157   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86158
86159   {
86160     try {
86161       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86162     } catch (std::out_of_range& e) {
86163       {
86164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86165       };
86166     } catch (std::exception& e) {
86167       {
86168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86169       };
86170     } catch (...) {
86171       {
86172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86173       };
86174     }
86175   }
86176   jresult = (void *)result;
86177   return jresult;
86178 }
86179
86180
86181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86182   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86183
86184   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86185   {
86186     try {
86187       delete arg1;
86188     } catch (std::out_of_range& e) {
86189       {
86190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86191       };
86192     } catch (std::exception& e) {
86193       {
86194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86195       };
86196     } catch (...) {
86197       {
86198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86199       };
86200     }
86201   }
86202 }
86203
86204
86205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86206   void * jresult ;
86207   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86208   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86209
86210   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86211   if (!arg1) {
86212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86213     return 0;
86214   }
86215   {
86216     try {
86217       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86218     } catch (std::out_of_range& e) {
86219       {
86220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86221       };
86222     } catch (std::exception& e) {
86223       {
86224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86225       };
86226     } catch (...) {
86227       {
86228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86229       };
86230     }
86231   }
86232   jresult = (void *)result;
86233   return jresult;
86234 }
86235
86236
86237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86238   void * jresult ;
86239   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86240   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86241   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86242
86243   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86244   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86245   if (!arg2) {
86246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86247     return 0;
86248   }
86249   {
86250     try {
86251       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86252     } catch (std::out_of_range& e) {
86253       {
86254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86255       };
86256     } catch (std::exception& e) {
86257       {
86258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86259       };
86260     } catch (...) {
86261       {
86262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86263       };
86264     }
86265   }
86266   jresult = (void *)result;
86267   return jresult;
86268 }
86269
86270
86271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86272   void * jresult ;
86273   Dali::Toolkit::AsyncImageLoader result;
86274
86275   {
86276     try {
86277       result = Dali::Toolkit::AsyncImageLoader::New();
86278     } catch (std::out_of_range& e) {
86279       {
86280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86281       };
86282     } catch (std::exception& e) {
86283       {
86284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86285       };
86286     } catch (...) {
86287       {
86288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86289       };
86290     }
86291   }
86292   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86293   return jresult;
86294 }
86295
86296
86297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86298   void * jresult ;
86299   Dali::BaseHandle arg1 ;
86300   Dali::BaseHandle *argp1 ;
86301   Dali::Toolkit::AsyncImageLoader result;
86302
86303   argp1 = (Dali::BaseHandle *)jarg1;
86304   if (!argp1) {
86305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86306     return 0;
86307   }
86308   arg1 = *argp1;
86309   {
86310     try {
86311       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86312     } catch (std::out_of_range& e) {
86313       {
86314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86315       };
86316     } catch (std::exception& e) {
86317       {
86318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86319       };
86320     } catch (...) {
86321       {
86322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86323       };
86324     }
86325   }
86326   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86327   return jresult;
86328 }
86329
86330
86331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86332   unsigned int jresult ;
86333   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86334   std::string *arg2 = 0 ;
86335   uint32_t result;
86336
86337   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86338   if (!jarg2) {
86339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86340     return 0;
86341   }
86342   std::string arg2_str(jarg2);
86343   arg2 = &arg2_str;
86344   {
86345     try {
86346       result = (arg1)->Load((std::string const &)*arg2);
86347     } catch (std::out_of_range& e) {
86348       {
86349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86350       };
86351     } catch (std::exception& e) {
86352       {
86353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86354       };
86355     } catch (...) {
86356       {
86357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86358       };
86359     }
86360   }
86361   jresult = result;
86362
86363   //argout typemap for const std::string&
86364
86365   return jresult;
86366 }
86367
86368
86369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86370   unsigned int jresult ;
86371   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86372   std::string *arg2 = 0 ;
86373   Dali::ImageDimensions arg3 ;
86374   Dali::ImageDimensions *argp3 ;
86375   uint32_t result;
86376
86377   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86378   if (!jarg2) {
86379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86380     return 0;
86381   }
86382   std::string arg2_str(jarg2);
86383   arg2 = &arg2_str;
86384   argp3 = (Dali::ImageDimensions *)jarg3;
86385   if (!argp3) {
86386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86387     return 0;
86388   }
86389   arg3 = *argp3;
86390   {
86391     try {
86392       result = (arg1)->Load((std::string const &)*arg2,arg3);
86393     } catch (std::out_of_range& e) {
86394       {
86395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86396       };
86397     } catch (std::exception& e) {
86398       {
86399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86400       };
86401     } catch (...) {
86402       {
86403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86404       };
86405     }
86406   }
86407   jresult = result;
86408
86409   //argout typemap for const std::string&
86410
86411   return jresult;
86412 }
86413
86414
86415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86416   unsigned int jresult ;
86417   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86418   std::string *arg2 = 0 ;
86419   Dali::ImageDimensions arg3 ;
86420   Dali::FittingMode::Type arg4 ;
86421   Dali::SamplingMode::Type arg5 ;
86422   bool arg6 ;
86423   Dali::ImageDimensions *argp3 ;
86424   uint32_t result;
86425
86426   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86427   if (!jarg2) {
86428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86429     return 0;
86430   }
86431   std::string arg2_str(jarg2);
86432   arg2 = &arg2_str;
86433   argp3 = (Dali::ImageDimensions *)jarg3;
86434   if (!argp3) {
86435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86436     return 0;
86437   }
86438   arg3 = *argp3;
86439   arg4 = (Dali::FittingMode::Type)jarg4;
86440   arg5 = (Dali::SamplingMode::Type)jarg5;
86441   arg6 = jarg6 ? true : false;
86442   {
86443     try {
86444       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86445     } catch (std::out_of_range& e) {
86446       {
86447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86448       };
86449     } catch (std::exception& e) {
86450       {
86451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86452       };
86453     } catch (...) {
86454       {
86455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86456       };
86457     }
86458   }
86459   jresult = result;
86460
86461   //argout typemap for const std::string&
86462
86463   return jresult;
86464 }
86465
86466
86467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86468   unsigned int jresult ;
86469   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86470   uint32_t arg2 ;
86471   bool result;
86472
86473   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86474   arg2 = (uint32_t)jarg2;
86475   {
86476     try {
86477       result = (bool)(arg1)->Cancel(arg2);
86478     } catch (std::out_of_range& e) {
86479       {
86480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86481       };
86482     } catch (std::exception& e) {
86483       {
86484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86485       };
86486     } catch (...) {
86487       {
86488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86489       };
86490     }
86491   }
86492   jresult = result;
86493   return jresult;
86494 }
86495
86496
86497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86498   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86499
86500   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86501   {
86502     try {
86503       (arg1)->CancelAll();
86504     } catch (std::out_of_range& e) {
86505       {
86506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86507       };
86508     } catch (std::exception& e) {
86509       {
86510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86511       };
86512     } catch (...) {
86513       {
86514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86515       };
86516     }
86517   }
86518 }
86519
86520
86521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86522   void * jresult ;
86523   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86524   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86525
86526   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86527   {
86528     try {
86529       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
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_new_AsyncImageLoader__SWIG_2(void * jarg1) {
86550   void * jresult ;
86551   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
86552   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86553
86554   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
86555   {
86556     try {
86557       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
86558     } catch (std::out_of_range& e) {
86559       {
86560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86561       };
86562     } catch (std::exception& e) {
86563       {
86564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86565       };
86566     } catch (...) {
86567       {
86568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86569       };
86570     }
86571   }
86572   jresult = (void *)result;
86573   return jresult;
86574 }
86575
86576
86577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86578   void * jresult ;
86579   std::string *arg1 = 0 ;
86580   Dali::PixelData result;
86581
86582   if (!jarg1) {
86583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86584     return 0;
86585   }
86586   std::string arg1_str(jarg1);
86587   arg1 = &arg1_str;
86588   {
86589     try {
86590       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86591     } catch (std::out_of_range& e) {
86592       {
86593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86594       };
86595     } catch (std::exception& e) {
86596       {
86597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86598       };
86599     } catch (...) {
86600       {
86601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86602       };
86603     }
86604   }
86605   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86606
86607   //argout typemap for const std::string&
86608
86609   return jresult;
86610 }
86611
86612
86613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86614   void * jresult ;
86615   std::string *arg1 = 0 ;
86616   Dali::ImageDimensions arg2 ;
86617   Dali::ImageDimensions *argp2 ;
86618   Dali::PixelData result;
86619
86620   if (!jarg1) {
86621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86622     return 0;
86623   }
86624   std::string arg1_str(jarg1);
86625   arg1 = &arg1_str;
86626   argp2 = (Dali::ImageDimensions *)jarg2;
86627   if (!argp2) {
86628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86629     return 0;
86630   }
86631   arg2 = *argp2;
86632   {
86633     try {
86634       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86635     } catch (std::out_of_range& e) {
86636       {
86637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86638       };
86639     } catch (std::exception& e) {
86640       {
86641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86642       };
86643     } catch (...) {
86644       {
86645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86646       };
86647     }
86648   }
86649   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86650
86651   //argout typemap for const std::string&
86652
86653   return jresult;
86654 }
86655
86656
86657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86658   void * jresult ;
86659   std::string *arg1 = 0 ;
86660   Dali::ImageDimensions arg2 ;
86661   Dali::FittingMode::Type arg3 ;
86662   Dali::SamplingMode::Type arg4 ;
86663   bool arg5 ;
86664   Dali::ImageDimensions *argp2 ;
86665   Dali::PixelData result;
86666
86667   if (!jarg1) {
86668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86669     return 0;
86670   }
86671   std::string arg1_str(jarg1);
86672   arg1 = &arg1_str;
86673   argp2 = (Dali::ImageDimensions *)jarg2;
86674   if (!argp2) {
86675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86676     return 0;
86677   }
86678   arg2 = *argp2;
86679   arg3 = (Dali::FittingMode::Type)jarg3;
86680   arg4 = (Dali::SamplingMode::Type)jarg4;
86681   arg5 = jarg5 ? true : false;
86682   {
86683     try {
86684       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86685     } catch (std::out_of_range& e) {
86686       {
86687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86688       };
86689     } catch (std::exception& e) {
86690       {
86691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86692       };
86693     } catch (...) {
86694       {
86695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86696       };
86697     }
86698   }
86699   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86700
86701   //argout typemap for const std::string&
86702
86703   return jresult;
86704 }
86705
86706
86707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
86708   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86709
86710   arg1 = (std::vector< unsigned int > *)jarg1;
86711   {
86712     try {
86713       (arg1)->clear();
86714     } catch (std::out_of_range& e) {
86715       {
86716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86717       };
86718     } catch (std::exception& e) {
86719       {
86720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86721       };
86722     } catch (...) {
86723       {
86724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86725       };
86726     }
86727   }
86728 }
86729
86730
86731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
86732   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86733   unsigned int *arg2 = 0 ;
86734   unsigned int temp2 ;
86735
86736   arg1 = (std::vector< unsigned int > *)jarg1;
86737   temp2 = (unsigned int)jarg2;
86738   arg2 = &temp2;
86739   {
86740     try {
86741       (arg1)->push_back((unsigned int const &)*arg2);
86742     } catch (std::out_of_range& e) {
86743       {
86744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86745       };
86746     } catch (std::exception& e) {
86747       {
86748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86749       };
86750     } catch (...) {
86751       {
86752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86753       };
86754     }
86755   }
86756 }
86757
86758
86759 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
86760   unsigned long jresult ;
86761   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86762   std::vector< unsigned int >::size_type result;
86763
86764   arg1 = (std::vector< unsigned int > *)jarg1;
86765   {
86766     try {
86767       result = ((std::vector< unsigned int > const *)arg1)->size();
86768     } catch (std::out_of_range& e) {
86769       {
86770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86771       };
86772     } catch (std::exception& e) {
86773       {
86774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86775       };
86776     } catch (...) {
86777       {
86778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86779       };
86780     }
86781   }
86782   jresult = (unsigned long)result;
86783   return jresult;
86784 }
86785
86786
86787 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
86788   unsigned long jresult ;
86789   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86790   std::vector< unsigned int >::size_type result;
86791
86792   arg1 = (std::vector< unsigned int > *)jarg1;
86793   {
86794     try {
86795       result = ((std::vector< unsigned int > const *)arg1)->capacity();
86796     } catch (std::out_of_range& e) {
86797       {
86798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86799       };
86800     } catch (std::exception& e) {
86801       {
86802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86803       };
86804     } catch (...) {
86805       {
86806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86807       };
86808     }
86809   }
86810   jresult = (unsigned long)result;
86811   return jresult;
86812 }
86813
86814
86815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
86816   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86817   std::vector< unsigned int >::size_type arg2 ;
86818
86819   arg1 = (std::vector< unsigned int > *)jarg1;
86820   arg2 = (std::vector< unsigned int >::size_type)jarg2;
86821   {
86822     try {
86823       (arg1)->reserve(arg2);
86824     } catch (std::out_of_range& e) {
86825       {
86826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86827       };
86828     } catch (std::exception& e) {
86829       {
86830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86831       };
86832     } catch (...) {
86833       {
86834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86835       };
86836     }
86837   }
86838 }
86839
86840
86841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
86842   void * jresult ;
86843   std::vector< unsigned int > *result = 0 ;
86844
86845   {
86846     try {
86847       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
86848     } catch (std::out_of_range& e) {
86849       {
86850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86851       };
86852     } catch (std::exception& e) {
86853       {
86854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86855       };
86856     } catch (...) {
86857       {
86858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86859       };
86860     }
86861   }
86862   jresult = (void *)result;
86863   return jresult;
86864 }
86865
86866
86867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
86868   void * jresult ;
86869   std::vector< unsigned int > *arg1 = 0 ;
86870   std::vector< unsigned int > *result = 0 ;
86871
86872   arg1 = (std::vector< unsigned int > *)jarg1;
86873   if (!arg1) {
86874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86875     return 0;
86876   }
86877   {
86878     try {
86879       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
86880     } catch (std::out_of_range& e) {
86881       {
86882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86883       };
86884     } catch (std::exception& e) {
86885       {
86886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86887       };
86888     } catch (...) {
86889       {
86890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86891       };
86892     }
86893   }
86894   jresult = (void *)result;
86895   return jresult;
86896 }
86897
86898
86899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
86900   void * jresult ;
86901   int arg1 ;
86902   std::vector< unsigned int > *result = 0 ;
86903
86904   arg1 = (int)jarg1;
86905   {
86906     try {
86907       try {
86908         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
86909       }
86910       catch(std::out_of_range &_e) {
86911         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86912         return 0;
86913       }
86914
86915     } catch (std::out_of_range& e) {
86916       {
86917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86918       };
86919     } catch (std::exception& e) {
86920       {
86921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86922       };
86923     } catch (...) {
86924       {
86925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86926       };
86927     }
86928   }
86929   jresult = (void *)result;
86930   return jresult;
86931 }
86932
86933
86934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
86935   unsigned int jresult ;
86936   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86937   int arg2 ;
86938   unsigned int result;
86939
86940   arg1 = (std::vector< unsigned int > *)jarg1;
86941   arg2 = (int)jarg2;
86942   {
86943     try {
86944       try {
86945         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
86946       }
86947       catch(std::out_of_range &_e) {
86948         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86949         return 0;
86950       }
86951
86952     } catch (std::out_of_range& e) {
86953       {
86954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86955       };
86956     } catch (std::exception& e) {
86957       {
86958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86959       };
86960     } catch (...) {
86961       {
86962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86963       };
86964     }
86965   }
86966   jresult = result;
86967   return jresult;
86968 }
86969
86970
86971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
86972   unsigned int jresult ;
86973   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86974   int arg2 ;
86975   unsigned int *result = 0 ;
86976
86977   arg1 = (std::vector< unsigned int > *)jarg1;
86978   arg2 = (int)jarg2;
86979   {
86980     try {
86981       try {
86982         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
86983       }
86984       catch(std::out_of_range &_e) {
86985         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86986         return 0;
86987       }
86988
86989     } catch (std::out_of_range& e) {
86990       {
86991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86992       };
86993     } catch (std::exception& e) {
86994       {
86995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86996       };
86997     } catch (...) {
86998       {
86999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87000       };
87001     }
87002   }
87003   jresult = *result;
87004   return jresult;
87005 }
87006
87007
87008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87009   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87010   int arg2 ;
87011   unsigned int *arg3 = 0 ;
87012   unsigned int temp3 ;
87013
87014   arg1 = (std::vector< unsigned int > *)jarg1;
87015   arg2 = (int)jarg2;
87016   temp3 = (unsigned int)jarg3;
87017   arg3 = &temp3;
87018   {
87019     try {
87020       try {
87021         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87022       }
87023       catch(std::out_of_range &_e) {
87024         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87025         return ;
87026       }
87027
87028     } catch (std::out_of_range& e) {
87029       {
87030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87031       };
87032     } catch (std::exception& e) {
87033       {
87034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87035       };
87036     } catch (...) {
87037       {
87038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87039       };
87040     }
87041   }
87042 }
87043
87044
87045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87046   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87047   std::vector< unsigned int > *arg2 = 0 ;
87048
87049   arg1 = (std::vector< unsigned int > *)jarg1;
87050   arg2 = (std::vector< unsigned int > *)jarg2;
87051   if (!arg2) {
87052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87053     return ;
87054   }
87055   {
87056     try {
87057       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87058     } catch (std::out_of_range& e) {
87059       {
87060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87061       };
87062     } catch (std::exception& e) {
87063       {
87064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87065       };
87066     } catch (...) {
87067       {
87068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87069       };
87070     }
87071   }
87072 }
87073
87074
87075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87076   void * jresult ;
87077   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87078   int arg2 ;
87079   int arg3 ;
87080   std::vector< unsigned int > *result = 0 ;
87081
87082   arg1 = (std::vector< unsigned int > *)jarg1;
87083   arg2 = (int)jarg2;
87084   arg3 = (int)jarg3;
87085   {
87086     try {
87087       try {
87088         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87089       }
87090       catch(std::out_of_range &_e) {
87091         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87092         return 0;
87093       }
87094       catch(std::invalid_argument &_e) {
87095         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87096         return 0;
87097       }
87098
87099     } catch (std::out_of_range& e) {
87100       {
87101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87102       };
87103     } catch (std::exception& e) {
87104       {
87105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87106       };
87107     } catch (...) {
87108       {
87109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87110       };
87111     }
87112   }
87113   jresult = (void *)result;
87114   return jresult;
87115 }
87116
87117
87118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87119   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87120   int arg2 ;
87121   unsigned int *arg3 = 0 ;
87122   unsigned int temp3 ;
87123
87124   arg1 = (std::vector< unsigned int > *)jarg1;
87125   arg2 = (int)jarg2;
87126   temp3 = (unsigned int)jarg3;
87127   arg3 = &temp3;
87128   {
87129     try {
87130       try {
87131         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87132       }
87133       catch(std::out_of_range &_e) {
87134         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87135         return ;
87136       }
87137
87138     } catch (std::out_of_range& e) {
87139       {
87140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87141       };
87142     } catch (std::exception& e) {
87143       {
87144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87145       };
87146     } catch (...) {
87147       {
87148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87149       };
87150     }
87151   }
87152 }
87153
87154
87155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87156   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87157   int arg2 ;
87158   std::vector< unsigned int > *arg3 = 0 ;
87159
87160   arg1 = (std::vector< unsigned int > *)jarg1;
87161   arg2 = (int)jarg2;
87162   arg3 = (std::vector< unsigned int > *)jarg3;
87163   if (!arg3) {
87164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87165     return ;
87166   }
87167   {
87168     try {
87169       try {
87170         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87171       }
87172       catch(std::out_of_range &_e) {
87173         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87174         return ;
87175       }
87176
87177     } catch (std::out_of_range& e) {
87178       {
87179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87180       };
87181     } catch (std::exception& e) {
87182       {
87183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87184       };
87185     } catch (...) {
87186       {
87187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87188       };
87189     }
87190   }
87191 }
87192
87193
87194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87195   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87196   int arg2 ;
87197
87198   arg1 = (std::vector< unsigned int > *)jarg1;
87199   arg2 = (int)jarg2;
87200   {
87201     try {
87202       try {
87203         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87204       }
87205       catch(std::out_of_range &_e) {
87206         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87207         return ;
87208       }
87209
87210     } catch (std::out_of_range& e) {
87211       {
87212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87213       };
87214     } catch (std::exception& e) {
87215       {
87216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87217       };
87218     } catch (...) {
87219       {
87220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87221       };
87222     }
87223   }
87224 }
87225
87226
87227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87228   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87229   int arg2 ;
87230   int arg3 ;
87231
87232   arg1 = (std::vector< unsigned int > *)jarg1;
87233   arg2 = (int)jarg2;
87234   arg3 = (int)jarg3;
87235   {
87236     try {
87237       try {
87238         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87239       }
87240       catch(std::out_of_range &_e) {
87241         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87242         return ;
87243       }
87244       catch(std::invalid_argument &_e) {
87245         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87246         return ;
87247       }
87248
87249     } catch (std::out_of_range& e) {
87250       {
87251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87252       };
87253     } catch (std::exception& e) {
87254       {
87255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87256       };
87257     } catch (...) {
87258       {
87259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87260       };
87261     }
87262   }
87263 }
87264
87265
87266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87267   void * jresult ;
87268   unsigned int *arg1 = 0 ;
87269   int arg2 ;
87270   unsigned int temp1 ;
87271   std::vector< unsigned int > *result = 0 ;
87272
87273   temp1 = (unsigned int)jarg1;
87274   arg1 = &temp1;
87275   arg2 = (int)jarg2;
87276   {
87277     try {
87278       try {
87279         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87280       }
87281       catch(std::out_of_range &_e) {
87282         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87283         return 0;
87284       }
87285
87286     } catch (std::out_of_range& e) {
87287       {
87288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87289       };
87290     } catch (std::exception& e) {
87291       {
87292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87293       };
87294     } catch (...) {
87295       {
87296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87297       };
87298     }
87299   }
87300   jresult = (void *)result;
87301   return jresult;
87302 }
87303
87304
87305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87306   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87307
87308   arg1 = (std::vector< unsigned int > *)jarg1;
87309   {
87310     try {
87311       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87312     } catch (std::out_of_range& e) {
87313       {
87314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87315       };
87316     } catch (std::exception& e) {
87317       {
87318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87319       };
87320     } catch (...) {
87321       {
87322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87323       };
87324     }
87325   }
87326 }
87327
87328
87329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87330   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87331   int arg2 ;
87332   int arg3 ;
87333
87334   arg1 = (std::vector< unsigned int > *)jarg1;
87335   arg2 = (int)jarg2;
87336   arg3 = (int)jarg3;
87337   {
87338     try {
87339       try {
87340         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87341       }
87342       catch(std::out_of_range &_e) {
87343         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87344         return ;
87345       }
87346       catch(std::invalid_argument &_e) {
87347         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87348         return ;
87349       }
87350
87351     } catch (std::out_of_range& e) {
87352       {
87353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87354       };
87355     } catch (std::exception& e) {
87356       {
87357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87358       };
87359     } catch (...) {
87360       {
87361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87362       };
87363     }
87364   }
87365 }
87366
87367
87368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87369   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87370   int arg2 ;
87371   std::vector< unsigned int > *arg3 = 0 ;
87372
87373   arg1 = (std::vector< unsigned int > *)jarg1;
87374   arg2 = (int)jarg2;
87375   arg3 = (std::vector< unsigned int > *)jarg3;
87376   if (!arg3) {
87377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87378     return ;
87379   }
87380   {
87381     try {
87382       try {
87383         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87384       }
87385       catch(std::out_of_range &_e) {
87386         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87387         return ;
87388       }
87389
87390     } catch (std::out_of_range& e) {
87391       {
87392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87393       };
87394     } catch (std::exception& e) {
87395       {
87396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87397       };
87398     } catch (...) {
87399       {
87400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87401       };
87402     }
87403   }
87404 }
87405
87406
87407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87408   unsigned int jresult ;
87409   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87410   unsigned int *arg2 = 0 ;
87411   unsigned int temp2 ;
87412   bool result;
87413
87414   arg1 = (std::vector< unsigned int > *)jarg1;
87415   temp2 = (unsigned int)jarg2;
87416   arg2 = &temp2;
87417   {
87418     try {
87419       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87420     } catch (std::out_of_range& e) {
87421       {
87422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87423       };
87424     } catch (std::exception& e) {
87425       {
87426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87427       };
87428     } catch (...) {
87429       {
87430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87431       };
87432     }
87433   }
87434   jresult = result;
87435   return jresult;
87436 }
87437
87438
87439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
87440   int jresult ;
87441   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87442   unsigned int *arg2 = 0 ;
87443   unsigned int temp2 ;
87444   int result;
87445
87446   arg1 = (std::vector< unsigned int > *)jarg1;
87447   temp2 = (unsigned int)jarg2;
87448   arg2 = &temp2;
87449   {
87450     try {
87451       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
87452     } catch (std::out_of_range& e) {
87453       {
87454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87455       };
87456     } catch (std::exception& e) {
87457       {
87458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87459       };
87460     } catch (...) {
87461       {
87462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87463       };
87464     }
87465   }
87466   jresult = result;
87467   return jresult;
87468 }
87469
87470
87471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
87472   int jresult ;
87473   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87474   unsigned int *arg2 = 0 ;
87475   unsigned int temp2 ;
87476   int result;
87477
87478   arg1 = (std::vector< unsigned int > *)jarg1;
87479   temp2 = (unsigned int)jarg2;
87480   arg2 = &temp2;
87481   {
87482     try {
87483       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
87484     } catch (std::out_of_range& e) {
87485       {
87486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87487       };
87488     } catch (std::exception& e) {
87489       {
87490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87491       };
87492     } catch (...) {
87493       {
87494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87495       };
87496     }
87497   }
87498   jresult = result;
87499   return jresult;
87500 }
87501
87502
87503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
87504   unsigned int jresult ;
87505   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87506   unsigned int *arg2 = 0 ;
87507   unsigned int temp2 ;
87508   bool result;
87509
87510   arg1 = (std::vector< unsigned int > *)jarg1;
87511   temp2 = (unsigned int)jarg2;
87512   arg2 = &temp2;
87513   {
87514     try {
87515       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
87516     } catch (std::out_of_range& e) {
87517       {
87518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87519       };
87520     } catch (std::exception& e) {
87521       {
87522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87523       };
87524     } catch (...) {
87525       {
87526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87527       };
87528     }
87529   }
87530   jresult = result;
87531   return jresult;
87532 }
87533
87534
87535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
87536   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87537
87538   arg1 = (std::vector< unsigned int > *)jarg1;
87539   {
87540     try {
87541       delete arg1;
87542     } catch (std::out_of_range& e) {
87543       {
87544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87545       };
87546     } catch (std::exception& e) {
87547       {
87548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87549       };
87550     } catch (...) {
87551       {
87552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87553       };
87554     }
87555   }
87556 }
87557
87558
87559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
87560   void * jresult ;
87561   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87562
87563   {
87564     try {
87565       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
87566     } catch (std::out_of_range& e) {
87567       {
87568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87569       };
87570     } catch (std::exception& e) {
87571       {
87572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87573       };
87574     } catch (...) {
87575       {
87576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87577       };
87578     }
87579   }
87580   jresult = (void *)result;
87581   return jresult;
87582 }
87583
87584
87585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
87586   void * jresult ;
87587   unsigned int arg1 ;
87588   Dali::Actor arg2 ;
87589   Dali::Actor *argp2 ;
87590   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87591
87592   arg1 = (unsigned int)jarg1;
87593   argp2 = (Dali::Actor *)jarg2;
87594   if (!argp2) {
87595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87596     return 0;
87597   }
87598   arg2 = *argp2;
87599   {
87600     try {
87601       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
87602     } catch (std::out_of_range& e) {
87603       {
87604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87605       };
87606     } catch (std::exception& e) {
87607       {
87608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87609       };
87610     } catch (...) {
87611       {
87612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87613       };
87614     }
87615   }
87616   jresult = (void *)result;
87617   return jresult;
87618 }
87619
87620
87621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
87622   void * jresult ;
87623   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87624   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87625
87626   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87627   if (!arg1) {
87628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87629     return 0;
87630   }
87631   {
87632     try {
87633       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
87634     } catch (std::out_of_range& e) {
87635       {
87636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87637       };
87638     } catch (std::exception& e) {
87639       {
87640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87641       };
87642     } catch (...) {
87643       {
87644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87645       };
87646     }
87647   }
87648   jresult = (void *)result;
87649   return jresult;
87650 }
87651
87652
87653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
87654   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87655   unsigned int arg2 ;
87656
87657   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87658   arg2 = (unsigned int)jarg2;
87659   if (arg1) (arg1)->first = arg2;
87660 }
87661
87662
87663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
87664   unsigned int jresult ;
87665   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87666   unsigned int result;
87667
87668   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87669   result = (unsigned int) ((arg1)->first);
87670   jresult = result;
87671   return jresult;
87672 }
87673
87674
87675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
87676   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87677   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
87678
87679   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87680   arg2 = (Dali::Actor *)jarg2;
87681   if (arg1) (arg1)->second = *arg2;
87682 }
87683
87684
87685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
87686   void * jresult ;
87687   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87688   Dali::Actor *result = 0 ;
87689
87690   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87691   result = (Dali::Actor *)& ((arg1)->second);
87692   jresult = (void *)result;
87693   return jresult;
87694 }
87695
87696
87697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
87698   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
87699
87700   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87701   {
87702     try {
87703       delete arg1;
87704     } catch (std::out_of_range& e) {
87705       {
87706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87707       };
87708     } catch (std::exception& e) {
87709       {
87710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87711       };
87712     } catch (...) {
87713       {
87714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87715       };
87716     }
87717   }
87718 }
87719
87720
87721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
87722   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87723
87724   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87725   {
87726     try {
87727       (arg1)->clear();
87728     } catch (std::out_of_range& e) {
87729       {
87730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87731       };
87732     } catch (std::exception& e) {
87733       {
87734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87735       };
87736     } catch (...) {
87737       {
87738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87739       };
87740     }
87741   }
87742 }
87743
87744
87745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
87746   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87747   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
87748
87749   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87750   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
87751   if (!arg2) {
87752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87753     return ;
87754   }
87755   {
87756     try {
87757       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
87758     } catch (std::out_of_range& e) {
87759       {
87760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87761       };
87762     } catch (std::exception& e) {
87763       {
87764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87765       };
87766     } catch (...) {
87767       {
87768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87769       };
87770     }
87771   }
87772 }
87773
87774
87775 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
87776   unsigned long jresult ;
87777   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87778   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87779
87780   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87781   {
87782     try {
87783       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
87784     } catch (std::out_of_range& e) {
87785       {
87786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87787       };
87788     } catch (std::exception& e) {
87789       {
87790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87791       };
87792     } catch (...) {
87793       {
87794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87795       };
87796     }
87797   }
87798   jresult = (unsigned long)result;
87799   return jresult;
87800 }
87801
87802
87803 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
87804   unsigned long jresult ;
87805   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87806   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
87807
87808   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87809   {
87810     try {
87811       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
87812     } catch (std::out_of_range& e) {
87813       {
87814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87815       };
87816     } catch (std::exception& e) {
87817       {
87818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87819       };
87820     } catch (...) {
87821       {
87822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87823       };
87824     }
87825   }
87826   jresult = (unsigned long)result;
87827   return jresult;
87828 }
87829
87830
87831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
87832   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87833   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
87834
87835   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87836   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
87837   {
87838     try {
87839       (arg1)->reserve(arg2);
87840     } catch (std::out_of_range& e) {
87841       {
87842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87843       };
87844     } catch (std::exception& e) {
87845       {
87846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87847       };
87848     } catch (...) {
87849       {
87850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87851       };
87852     }
87853   }
87854 }
87855
87856
87857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
87858   void * jresult ;
87859   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87860
87861   {
87862     try {
87863       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
87864     } catch (std::out_of_range& e) {
87865       {
87866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87867       };
87868     } catch (std::exception& e) {
87869       {
87870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87871       };
87872     } catch (...) {
87873       {
87874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87875       };
87876     }
87877   }
87878   jresult = (void *)result;
87879   return jresult;
87880 }
87881
87882
87883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
87884   void * jresult ;
87885   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
87886   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87887
87888   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87889   if (!arg1) {
87890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87891     return 0;
87892   }
87893   {
87894     try {
87895       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);
87896     } catch (std::out_of_range& e) {
87897       {
87898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87899       };
87900     } catch (std::exception& e) {
87901       {
87902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87903       };
87904     } catch (...) {
87905       {
87906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87907       };
87908     }
87909   }
87910   jresult = (void *)result;
87911   return jresult;
87912 }
87913
87914
87915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
87916   void * jresult ;
87917   int arg1 ;
87918   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87919
87920   arg1 = (int)jarg1;
87921   {
87922     try {
87923       try {
87924         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);
87925       }
87926       catch(std::out_of_range &_e) {
87927         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87928         return 0;
87929       }
87930
87931     } catch (std::out_of_range& e) {
87932       {
87933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87934       };
87935     } catch (std::exception& e) {
87936       {
87937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87938       };
87939     } catch (...) {
87940       {
87941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87942       };
87943     }
87944   }
87945   jresult = (void *)result;
87946   return jresult;
87947 }
87948
87949
87950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
87951   void * jresult ;
87952   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87953   int arg2 ;
87954   std::pair< unsigned int,Dali::Actor > result;
87955
87956   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87957   arg2 = (int)jarg2;
87958   {
87959     try {
87960       try {
87961         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
87962       }
87963       catch(std::out_of_range &_e) {
87964         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87965         return 0;
87966       }
87967
87968     } catch (std::out_of_range& e) {
87969       {
87970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87971       };
87972     } catch (std::exception& e) {
87973       {
87974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87975       };
87976     } catch (...) {
87977       {
87978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87979       };
87980     }
87981   }
87982   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
87983   return jresult;
87984 }
87985
87986
87987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
87988   void * jresult ;
87989   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87990   int arg2 ;
87991   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87992
87993   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87994   arg2 = (int)jarg2;
87995   {
87996     try {
87997       try {
87998         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
87999       }
88000       catch(std::out_of_range &_e) {
88001         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88002         return 0;
88003       }
88004
88005     } catch (std::out_of_range& e) {
88006       {
88007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88008       };
88009     } catch (std::exception& e) {
88010       {
88011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88012       };
88013     } catch (...) {
88014       {
88015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88016       };
88017     }
88018   }
88019   jresult = (void *)result;
88020   return jresult;
88021 }
88022
88023
88024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88025   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88026   int arg2 ;
88027   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88028
88029   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88030   arg2 = (int)jarg2;
88031   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88032   if (!arg3) {
88033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88034     return ;
88035   }
88036   {
88037     try {
88038       try {
88039         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);
88040       }
88041       catch(std::out_of_range &_e) {
88042         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88043         return ;
88044       }
88045
88046     } catch (std::out_of_range& e) {
88047       {
88048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88049       };
88050     } catch (std::exception& e) {
88051       {
88052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88053       };
88054     } catch (...) {
88055       {
88056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88057       };
88058     }
88059   }
88060 }
88061
88062
88063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88064   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88065   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88066
88067   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88068   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88069   if (!arg2) {
88070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88071     return ;
88072   }
88073   {
88074     try {
88075       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);
88076     } catch (std::out_of_range& e) {
88077       {
88078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88079       };
88080     } catch (std::exception& e) {
88081       {
88082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88083       };
88084     } catch (...) {
88085       {
88086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88087       };
88088     }
88089   }
88090 }
88091
88092
88093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88094   void * jresult ;
88095   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88096   int arg2 ;
88097   int arg3 ;
88098   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88099
88100   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88101   arg2 = (int)jarg2;
88102   arg3 = (int)jarg3;
88103   {
88104     try {
88105       try {
88106         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);
88107       }
88108       catch(std::out_of_range &_e) {
88109         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88110         return 0;
88111       }
88112       catch(std::invalid_argument &_e) {
88113         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88114         return 0;
88115       }
88116
88117     } catch (std::out_of_range& e) {
88118       {
88119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88120       };
88121     } catch (std::exception& e) {
88122       {
88123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88124       };
88125     } catch (...) {
88126       {
88127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88128       };
88129     }
88130   }
88131   jresult = (void *)result;
88132   return jresult;
88133 }
88134
88135
88136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88137   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88138   int arg2 ;
88139   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88140
88141   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88142   arg2 = (int)jarg2;
88143   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88144   if (!arg3) {
88145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88146     return ;
88147   }
88148   {
88149     try {
88150       try {
88151         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);
88152       }
88153       catch(std::out_of_range &_e) {
88154         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88155         return ;
88156       }
88157
88158     } catch (std::out_of_range& e) {
88159       {
88160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88161       };
88162     } catch (std::exception& e) {
88163       {
88164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88165       };
88166     } catch (...) {
88167       {
88168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88169       };
88170     }
88171   }
88172 }
88173
88174
88175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88176   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88177   int arg2 ;
88178   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88179
88180   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88181   arg2 = (int)jarg2;
88182   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88183   if (!arg3) {
88184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88185     return ;
88186   }
88187   {
88188     try {
88189       try {
88190         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);
88191       }
88192       catch(std::out_of_range &_e) {
88193         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88194         return ;
88195       }
88196
88197     } catch (std::out_of_range& e) {
88198       {
88199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88200       };
88201     } catch (std::exception& e) {
88202       {
88203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88204       };
88205     } catch (...) {
88206       {
88207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88208       };
88209     }
88210   }
88211 }
88212
88213
88214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88215   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88216   int arg2 ;
88217
88218   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88219   arg2 = (int)jarg2;
88220   {
88221     try {
88222       try {
88223         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88224       }
88225       catch(std::out_of_range &_e) {
88226         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88227         return ;
88228       }
88229
88230     } catch (std::out_of_range& e) {
88231       {
88232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88233       };
88234     } catch (std::exception& e) {
88235       {
88236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88237       };
88238     } catch (...) {
88239       {
88240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88241       };
88242     }
88243   }
88244 }
88245
88246
88247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88248   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88249   int arg2 ;
88250   int arg3 ;
88251
88252   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88253   arg2 = (int)jarg2;
88254   arg3 = (int)jarg3;
88255   {
88256     try {
88257       try {
88258         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88259       }
88260       catch(std::out_of_range &_e) {
88261         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88262         return ;
88263       }
88264       catch(std::invalid_argument &_e) {
88265         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88266         return ;
88267       }
88268
88269     } catch (std::out_of_range& e) {
88270       {
88271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88272       };
88273     } catch (std::exception& e) {
88274       {
88275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88276       };
88277     } catch (...) {
88278       {
88279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88280       };
88281     }
88282   }
88283 }
88284
88285
88286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88287   void * jresult ;
88288   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88289   int arg2 ;
88290   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88291
88292   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88293   if (!arg1) {
88294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88295     return 0;
88296   }
88297   arg2 = (int)jarg2;
88298   {
88299     try {
88300       try {
88301         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);
88302       }
88303       catch(std::out_of_range &_e) {
88304         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88305         return 0;
88306       }
88307
88308     } catch (std::out_of_range& e) {
88309       {
88310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88311       };
88312     } catch (std::exception& e) {
88313       {
88314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88315       };
88316     } catch (...) {
88317       {
88318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88319       };
88320     }
88321   }
88322   jresult = (void *)result;
88323   return jresult;
88324 }
88325
88326
88327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
88328   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88329
88330   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88331   {
88332     try {
88333       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
88334     } catch (std::out_of_range& e) {
88335       {
88336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88337       };
88338     } catch (std::exception& e) {
88339       {
88340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88341       };
88342     } catch (...) {
88343       {
88344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88345       };
88346     }
88347   }
88348 }
88349
88350
88351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88352   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88353   int arg2 ;
88354   int arg3 ;
88355
88356   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88357   arg2 = (int)jarg2;
88358   arg3 = (int)jarg3;
88359   {
88360     try {
88361       try {
88362         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88363       }
88364       catch(std::out_of_range &_e) {
88365         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88366         return ;
88367       }
88368       catch(std::invalid_argument &_e) {
88369         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88370         return ;
88371       }
88372
88373     } catch (std::out_of_range& e) {
88374       {
88375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88376       };
88377     } catch (std::exception& e) {
88378       {
88379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88380       };
88381     } catch (...) {
88382       {
88383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88384       };
88385     }
88386   }
88387 }
88388
88389
88390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88391   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88392   int arg2 ;
88393   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88394
88395   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88396   arg2 = (int)jarg2;
88397   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88398   if (!arg3) {
88399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88400     return ;
88401   }
88402   {
88403     try {
88404       try {
88405         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);
88406       }
88407       catch(std::out_of_range &_e) {
88408         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88409         return ;
88410       }
88411
88412     } catch (std::out_of_range& e) {
88413       {
88414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88415       };
88416     } catch (std::exception& e) {
88417       {
88418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88419       };
88420     } catch (...) {
88421       {
88422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88423       };
88424     }
88425   }
88426 }
88427
88428
88429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
88430   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88431
88432   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88433   {
88434     try {
88435       delete arg1;
88436     } catch (std::out_of_range& e) {
88437       {
88438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88439       };
88440     } catch (std::exception& e) {
88441       {
88442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88443       };
88444     } catch (...) {
88445       {
88446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88447       };
88448     }
88449   }
88450 }
88451
88452
88453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
88454   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88455
88456   arg1 = (std::vector< Dali::Actor > *)jarg1;
88457   {
88458     try {
88459       (arg1)->clear();
88460     } catch (std::out_of_range& e) {
88461       {
88462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88463       };
88464     } catch (std::exception& e) {
88465       {
88466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88467       };
88468     } catch (...) {
88469       {
88470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88471       };
88472     }
88473   }
88474 }
88475
88476
88477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
88478   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88479   Dali::Actor *arg2 = 0 ;
88480
88481   arg1 = (std::vector< Dali::Actor > *)jarg1;
88482   arg2 = (Dali::Actor *)jarg2;
88483   if (!arg2) {
88484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88485     return ;
88486   }
88487   {
88488     try {
88489       (arg1)->push_back((Dali::Actor const &)*arg2);
88490     } catch (std::out_of_range& e) {
88491       {
88492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88493       };
88494     } catch (std::exception& e) {
88495       {
88496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88497       };
88498     } catch (...) {
88499       {
88500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88501       };
88502     }
88503   }
88504 }
88505
88506
88507 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
88508   unsigned long jresult ;
88509   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88510   std::vector< Dali::Actor >::size_type result;
88511
88512   arg1 = (std::vector< Dali::Actor > *)jarg1;
88513   {
88514     try {
88515       result = ((std::vector< Dali::Actor > const *)arg1)->size();
88516     } catch (std::out_of_range& e) {
88517       {
88518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88519       };
88520     } catch (std::exception& e) {
88521       {
88522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88523       };
88524     } catch (...) {
88525       {
88526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88527       };
88528     }
88529   }
88530   jresult = (unsigned long)result;
88531   return jresult;
88532 }
88533
88534
88535 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
88536   unsigned long jresult ;
88537   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88538   std::vector< Dali::Actor >::size_type result;
88539
88540   arg1 = (std::vector< Dali::Actor > *)jarg1;
88541   {
88542     try {
88543       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
88544     } catch (std::out_of_range& e) {
88545       {
88546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88547       };
88548     } catch (std::exception& e) {
88549       {
88550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88551       };
88552     } catch (...) {
88553       {
88554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88555       };
88556     }
88557   }
88558   jresult = (unsigned long)result;
88559   return jresult;
88560 }
88561
88562
88563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
88564   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88565   std::vector< Dali::Actor >::size_type arg2 ;
88566
88567   arg1 = (std::vector< Dali::Actor > *)jarg1;
88568   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
88569   {
88570     try {
88571       (arg1)->reserve(arg2);
88572     } catch (std::out_of_range& e) {
88573       {
88574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88575       };
88576     } catch (std::exception& e) {
88577       {
88578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88579       };
88580     } catch (...) {
88581       {
88582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88583       };
88584     }
88585   }
88586 }
88587
88588
88589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
88590   void * jresult ;
88591   std::vector< Dali::Actor > *result = 0 ;
88592
88593   {
88594     try {
88595       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
88596     } catch (std::out_of_range& e) {
88597       {
88598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88599       };
88600     } catch (std::exception& e) {
88601       {
88602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88603       };
88604     } catch (...) {
88605       {
88606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88607       };
88608     }
88609   }
88610   jresult = (void *)result;
88611   return jresult;
88612 }
88613
88614
88615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
88616   void * jresult ;
88617   std::vector< Dali::Actor > *arg1 = 0 ;
88618   std::vector< Dali::Actor > *result = 0 ;
88619
88620   arg1 = (std::vector< Dali::Actor > *)jarg1;
88621   if (!arg1) {
88622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88623     return 0;
88624   }
88625   {
88626     try {
88627       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
88628     } catch (std::out_of_range& e) {
88629       {
88630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88631       };
88632     } catch (std::exception& e) {
88633       {
88634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88635       };
88636     } catch (...) {
88637       {
88638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88639       };
88640     }
88641   }
88642   jresult = (void *)result;
88643   return jresult;
88644 }
88645
88646
88647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
88648   void * jresult ;
88649   int arg1 ;
88650   std::vector< Dali::Actor > *result = 0 ;
88651
88652   arg1 = (int)jarg1;
88653   {
88654     try {
88655       try {
88656         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
88657       }
88658       catch(std::out_of_range &_e) {
88659         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88660         return 0;
88661       }
88662
88663     } catch (std::out_of_range& e) {
88664       {
88665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88666       };
88667     } catch (std::exception& e) {
88668       {
88669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88670       };
88671     } catch (...) {
88672       {
88673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88674       };
88675     }
88676   }
88677   jresult = (void *)result;
88678   return jresult;
88679 }
88680
88681
88682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
88683   void * jresult ;
88684   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88685   int arg2 ;
88686   Dali::Actor result;
88687
88688   arg1 = (std::vector< Dali::Actor > *)jarg1;
88689   arg2 = (int)jarg2;
88690   {
88691     try {
88692       try {
88693         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
88694       }
88695       catch(std::out_of_range &_e) {
88696         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88697         return 0;
88698       }
88699
88700     } catch (std::out_of_range& e) {
88701       {
88702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88703       };
88704     } catch (std::exception& e) {
88705       {
88706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88707       };
88708     } catch (...) {
88709       {
88710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88711       };
88712     }
88713   }
88714   jresult = new Dali::Actor((const Dali::Actor &)result);
88715   return jresult;
88716 }
88717
88718
88719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
88720   void * jresult ;
88721   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88722   int arg2 ;
88723   Dali::Actor *result = 0 ;
88724
88725   arg1 = (std::vector< Dali::Actor > *)jarg1;
88726   arg2 = (int)jarg2;
88727   {
88728     try {
88729       try {
88730         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
88731       }
88732       catch(std::out_of_range &_e) {
88733         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88734         return 0;
88735       }
88736
88737     } catch (std::out_of_range& e) {
88738       {
88739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88740       };
88741     } catch (std::exception& e) {
88742       {
88743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88744       };
88745     } catch (...) {
88746       {
88747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88748       };
88749     }
88750   }
88751   jresult = (void *)result;
88752   return jresult;
88753 }
88754
88755
88756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88757   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88758   int arg2 ;
88759   Dali::Actor *arg3 = 0 ;
88760
88761   arg1 = (std::vector< Dali::Actor > *)jarg1;
88762   arg2 = (int)jarg2;
88763   arg3 = (Dali::Actor *)jarg3;
88764   if (!arg3) {
88765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88766     return ;
88767   }
88768   {
88769     try {
88770       try {
88771         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
88772       }
88773       catch(std::out_of_range &_e) {
88774         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88775         return ;
88776       }
88777
88778     } catch (std::out_of_range& e) {
88779       {
88780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88781       };
88782     } catch (std::exception& e) {
88783       {
88784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88785       };
88786     } catch (...) {
88787       {
88788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88789       };
88790     }
88791   }
88792 }
88793
88794
88795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
88796   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88797   std::vector< Dali::Actor > *arg2 = 0 ;
88798
88799   arg1 = (std::vector< Dali::Actor > *)jarg1;
88800   arg2 = (std::vector< Dali::Actor > *)jarg2;
88801   if (!arg2) {
88802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88803     return ;
88804   }
88805   {
88806     try {
88807       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
88808     } catch (std::out_of_range& e) {
88809       {
88810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88811       };
88812     } catch (std::exception& e) {
88813       {
88814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88815       };
88816     } catch (...) {
88817       {
88818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88819       };
88820     }
88821   }
88822 }
88823
88824
88825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88826   void * jresult ;
88827   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88828   int arg2 ;
88829   int arg3 ;
88830   std::vector< Dali::Actor > *result = 0 ;
88831
88832   arg1 = (std::vector< Dali::Actor > *)jarg1;
88833   arg2 = (int)jarg2;
88834   arg3 = (int)jarg3;
88835   {
88836     try {
88837       try {
88838         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
88839       }
88840       catch(std::out_of_range &_e) {
88841         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88842         return 0;
88843       }
88844       catch(std::invalid_argument &_e) {
88845         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88846         return 0;
88847       }
88848
88849     } catch (std::out_of_range& e) {
88850       {
88851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88852       };
88853     } catch (std::exception& e) {
88854       {
88855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88856       };
88857     } catch (...) {
88858       {
88859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88860       };
88861     }
88862   }
88863   jresult = (void *)result;
88864   return jresult;
88865 }
88866
88867
88868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88869   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88870   int arg2 ;
88871   Dali::Actor *arg3 = 0 ;
88872
88873   arg1 = (std::vector< Dali::Actor > *)jarg1;
88874   arg2 = (int)jarg2;
88875   arg3 = (Dali::Actor *)jarg3;
88876   if (!arg3) {
88877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88878     return ;
88879   }
88880   {
88881     try {
88882       try {
88883         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
88884       }
88885       catch(std::out_of_range &_e) {
88886         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88887         return ;
88888       }
88889
88890     } catch (std::out_of_range& e) {
88891       {
88892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88893       };
88894     } catch (std::exception& e) {
88895       {
88896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88897       };
88898     } catch (...) {
88899       {
88900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88901       };
88902     }
88903   }
88904 }
88905
88906
88907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88908   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88909   int arg2 ;
88910   std::vector< Dali::Actor > *arg3 = 0 ;
88911
88912   arg1 = (std::vector< Dali::Actor > *)jarg1;
88913   arg2 = (int)jarg2;
88914   arg3 = (std::vector< Dali::Actor > *)jarg3;
88915   if (!arg3) {
88916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88917     return ;
88918   }
88919   {
88920     try {
88921       try {
88922         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88923       }
88924       catch(std::out_of_range &_e) {
88925         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88926         return ;
88927       }
88928
88929     } catch (std::out_of_range& e) {
88930       {
88931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88932       };
88933     } catch (std::exception& e) {
88934       {
88935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88936       };
88937     } catch (...) {
88938       {
88939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88940       };
88941     }
88942   }
88943 }
88944
88945
88946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
88947   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88948   int arg2 ;
88949
88950   arg1 = (std::vector< Dali::Actor > *)jarg1;
88951   arg2 = (int)jarg2;
88952   {
88953     try {
88954       try {
88955         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
88956       }
88957       catch(std::out_of_range &_e) {
88958         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88959         return ;
88960       }
88961
88962     } catch (std::out_of_range& e) {
88963       {
88964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88965       };
88966     } catch (std::exception& e) {
88967       {
88968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88969       };
88970     } catch (...) {
88971       {
88972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88973       };
88974     }
88975   }
88976 }
88977
88978
88979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88980   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88981   int arg2 ;
88982   int arg3 ;
88983
88984   arg1 = (std::vector< Dali::Actor > *)jarg1;
88985   arg2 = (int)jarg2;
88986   arg3 = (int)jarg3;
88987   {
88988     try {
88989       try {
88990         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
88991       }
88992       catch(std::out_of_range &_e) {
88993         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88994         return ;
88995       }
88996       catch(std::invalid_argument &_e) {
88997         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88998         return ;
88999       }
89000
89001     } catch (std::out_of_range& e) {
89002       {
89003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89004       };
89005     } catch (std::exception& e) {
89006       {
89007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89008       };
89009     } catch (...) {
89010       {
89011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89012       };
89013     }
89014   }
89015 }
89016
89017
89018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89019   void * jresult ;
89020   Dali::Actor *arg1 = 0 ;
89021   int arg2 ;
89022   std::vector< Dali::Actor > *result = 0 ;
89023
89024   arg1 = (Dali::Actor *)jarg1;
89025   if (!arg1) {
89026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89027     return 0;
89028   }
89029   arg2 = (int)jarg2;
89030   {
89031     try {
89032       try {
89033         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89034       }
89035       catch(std::out_of_range &_e) {
89036         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89037         return 0;
89038       }
89039
89040     } catch (std::out_of_range& e) {
89041       {
89042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89043       };
89044     } catch (std::exception& e) {
89045       {
89046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89047       };
89048     } catch (...) {
89049       {
89050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89051       };
89052     }
89053   }
89054   jresult = (void *)result;
89055   return jresult;
89056 }
89057
89058
89059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89060   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89061
89062   arg1 = (std::vector< Dali::Actor > *)jarg1;
89063   {
89064     try {
89065       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89066     } catch (std::out_of_range& e) {
89067       {
89068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89069       };
89070     } catch (std::exception& e) {
89071       {
89072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89073       };
89074     } catch (...) {
89075       {
89076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89077       };
89078     }
89079   }
89080 }
89081
89082
89083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89084   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89085   int arg2 ;
89086   int arg3 ;
89087
89088   arg1 = (std::vector< Dali::Actor > *)jarg1;
89089   arg2 = (int)jarg2;
89090   arg3 = (int)jarg3;
89091   {
89092     try {
89093       try {
89094         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89095       }
89096       catch(std::out_of_range &_e) {
89097         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89098         return ;
89099       }
89100       catch(std::invalid_argument &_e) {
89101         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89102         return ;
89103       }
89104
89105     } catch (std::out_of_range& e) {
89106       {
89107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89108       };
89109     } catch (std::exception& e) {
89110       {
89111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89112       };
89113     } catch (...) {
89114       {
89115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89116       };
89117     }
89118   }
89119 }
89120
89121
89122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89123   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89124   int arg2 ;
89125   std::vector< Dali::Actor > *arg3 = 0 ;
89126
89127   arg1 = (std::vector< Dali::Actor > *)jarg1;
89128   arg2 = (int)jarg2;
89129   arg3 = (std::vector< Dali::Actor > *)jarg3;
89130   if (!arg3) {
89131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89132     return ;
89133   }
89134   {
89135     try {
89136       try {
89137         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89138       }
89139       catch(std::out_of_range &_e) {
89140         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89141         return ;
89142       }
89143
89144     } catch (std::out_of_range& e) {
89145       {
89146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89147       };
89148     } catch (std::exception& e) {
89149       {
89150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89151       };
89152     } catch (...) {
89153       {
89154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89155       };
89156     }
89157   }
89158 }
89159
89160
89161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89162   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89163
89164   arg1 = (std::vector< Dali::Actor > *)jarg1;
89165   {
89166     try {
89167       delete arg1;
89168     } catch (std::out_of_range& e) {
89169       {
89170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89171       };
89172     } catch (std::exception& e) {
89173       {
89174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89175       };
89176     } catch (...) {
89177       {
89178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89179       };
89180     }
89181   }
89182 }
89183
89184
89185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
89186   unsigned int jresult ;
89187   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89188   bool result;
89189
89190   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89191   {
89192     try {
89193       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89194     } catch (std::out_of_range& e) {
89195       {
89196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89197       };
89198     } catch (std::exception& e) {
89199       {
89200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89201       };
89202     } catch (...) {
89203       {
89204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89205       };
89206     }
89207   }
89208   jresult = result;
89209   return jresult;
89210 }
89211
89212
89213 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
89214   unsigned long jresult ;
89215   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89216   std::size_t result;
89217
89218   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89219   {
89220     try {
89221       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89222     } catch (std::out_of_range& e) {
89223       {
89224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89225       };
89226     } catch (std::exception& e) {
89227       {
89228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89229       };
89230     } catch (...) {
89231       {
89232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89233       };
89234     }
89235   }
89236   jresult = (unsigned long)result;
89237   return jresult;
89238 }
89239
89240
89241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
89242   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89243   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89244
89245   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89246   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89247   {
89248     try {
89249       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
89250     } catch (std::out_of_range& e) {
89251       {
89252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89253       };
89254     } catch (std::exception& e) {
89255       {
89256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89257       };
89258     } catch (...) {
89259       {
89260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89261       };
89262     }
89263   }
89264 }
89265
89266
89267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
89268   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89269   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89270
89271   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89272   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89273   {
89274     try {
89275       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
89276     } catch (std::out_of_range& e) {
89277       {
89278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89279       };
89280     } catch (std::exception& e) {
89281       {
89282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89283       };
89284     } catch (...) {
89285       {
89286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89287       };
89288     }
89289   }
89290 }
89291
89292
89293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
89294   unsigned int jresult ;
89295   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89296   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
89297   bool result;
89298
89299   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89300   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
89301   if (!arg2) {
89302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
89303     return 0;
89304   }
89305   {
89306     try {
89307       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
89308     } catch (std::out_of_range& e) {
89309       {
89310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89311       };
89312     } catch (std::exception& e) {
89313       {
89314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89315       };
89316     } catch (...) {
89317       {
89318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89319       };
89320     }
89321   }
89322   jresult = result;
89323   return jresult;
89324 }
89325
89326
89327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
89328   void * jresult ;
89329   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
89330
89331   {
89332     try {
89333       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
89334     } catch (std::out_of_range& e) {
89335       {
89336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89337       };
89338     } catch (std::exception& e) {
89339       {
89340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89341       };
89342     } catch (...) {
89343       {
89344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89345       };
89346     }
89347   }
89348   jresult = (void *)result;
89349   return jresult;
89350 }
89351
89352
89353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
89354   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89355
89356   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89357   {
89358     try {
89359       delete arg1;
89360     } catch (std::out_of_range& e) {
89361       {
89362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89363       };
89364     } catch (std::exception& e) {
89365       {
89366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89367       };
89368     } catch (...) {
89369       {
89370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89371       };
89372     }
89373   }
89374 }
89375
89376
89377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
89378   unsigned int jresult ;
89379   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89380   bool result;
89381
89382   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89383   {
89384     try {
89385       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);
89386     } catch (std::out_of_range& e) {
89387       {
89388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89389       };
89390     } catch (std::exception& e) {
89391       {
89392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89393       };
89394     } catch (...) {
89395       {
89396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89397       };
89398     }
89399   }
89400   jresult = result;
89401   return jresult;
89402 }
89403
89404
89405 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
89406   unsigned long jresult ;
89407   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89408   std::size_t result;
89409
89410   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89411   {
89412     try {
89413       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);
89414     } catch (std::out_of_range& e) {
89415       {
89416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89417       };
89418     } catch (std::exception& e) {
89419       {
89420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89421       };
89422     } catch (...) {
89423       {
89424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89425       };
89426     }
89427   }
89428   jresult = (unsigned long)result;
89429   return jresult;
89430 }
89431
89432
89433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
89434   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89435   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89436
89437   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89438   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89439   {
89440     try {
89441       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
89442     } catch (std::out_of_range& e) {
89443       {
89444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89445       };
89446     } catch (std::exception& e) {
89447       {
89448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89449       };
89450     } catch (...) {
89451       {
89452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89453       };
89454     }
89455   }
89456 }
89457
89458
89459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
89460   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89461   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
89462
89463   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89464   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
89465   {
89466     try {
89467       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
89468     } catch (std::out_of_range& e) {
89469       {
89470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89471       };
89472     } catch (std::exception& e) {
89473       {
89474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89475       };
89476     } catch (...) {
89477       {
89478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89479       };
89480     }
89481   }
89482 }
89483
89484
89485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89486   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89487   Dali::Actor arg2 ;
89488   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
89489   Dali::Actor *argp2 ;
89490
89491   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89492   argp2 = (Dali::Actor *)jarg2;
89493   if (!argp2) {
89494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89495     return ;
89496   }
89497   arg2 = *argp2;
89498   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
89499   {
89500     try {
89501       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
89502     } catch (std::out_of_range& e) {
89503       {
89504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89505       };
89506     } catch (std::exception& e) {
89507       {
89508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89509       };
89510     } catch (...) {
89511       {
89512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89513       };
89514     }
89515   }
89516 }
89517
89518
89519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
89520   void * jresult ;
89521   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
89522
89523   {
89524     try {
89525       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
89526     } catch (std::out_of_range& e) {
89527       {
89528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89529       };
89530     } catch (std::exception& e) {
89531       {
89532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89533       };
89534     } catch (...) {
89535       {
89536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89537       };
89538     }
89539   }
89540   jresult = (void *)result;
89541   return jresult;
89542 }
89543
89544
89545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
89546   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
89547
89548   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
89549   {
89550     try {
89551       delete arg1;
89552     } catch (std::out_of_range& e) {
89553       {
89554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89555       };
89556     } catch (std::exception& e) {
89557       {
89558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89559       };
89560     } catch (...) {
89561       {
89562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89563       };
89564     }
89565   }
89566 }
89567
89568
89569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
89570   unsigned int jresult ;
89571   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89572   bool result;
89573
89574   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89575   {
89576     try {
89577       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89578     } catch (std::out_of_range& e) {
89579       {
89580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89581       };
89582     } catch (std::exception& e) {
89583       {
89584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89585       };
89586     } catch (...) {
89587       {
89588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89589       };
89590     }
89591   }
89592   jresult = result;
89593   return jresult;
89594 }
89595
89596
89597 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
89598   unsigned long jresult ;
89599   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89600   std::size_t result;
89601
89602   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89603   {
89604     try {
89605       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
89606     } catch (std::out_of_range& e) {
89607       {
89608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89609       };
89610     } catch (std::exception& e) {
89611       {
89612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89613       };
89614     } catch (...) {
89615       {
89616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89617       };
89618     }
89619   }
89620   jresult = (unsigned long)result;
89621   return jresult;
89622 }
89623
89624
89625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
89626   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89627   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89628
89629   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89630   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89631   {
89632     try {
89633       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
89634     } catch (std::out_of_range& e) {
89635       {
89636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89637       };
89638     } catch (std::exception& e) {
89639       {
89640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89641       };
89642     } catch (...) {
89643       {
89644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89645       };
89646     }
89647   }
89648 }
89649
89650
89651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89652   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89653   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
89654
89655   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89656   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
89657   {
89658     try {
89659       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
89660     } catch (std::out_of_range& e) {
89661       {
89662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89663       };
89664     } catch (std::exception& e) {
89665       {
89666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89667       };
89668     } catch (...) {
89669       {
89670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89671       };
89672     }
89673   }
89674 }
89675
89676
89677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
89678   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89679   Dali::Actor arg2 ;
89680   Dali::Actor arg3 ;
89681   Dali::Actor *argp2 ;
89682   Dali::Actor *argp3 ;
89683
89684   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89685   argp2 = (Dali::Actor *)jarg2;
89686   if (!argp2) {
89687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89688     return ;
89689   }
89690   arg2 = *argp2;
89691   argp3 = (Dali::Actor *)jarg3;
89692   if (!argp3) {
89693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89694     return ;
89695   }
89696   arg3 = *argp3;
89697   {
89698     try {
89699       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
89700     } catch (std::out_of_range& e) {
89701       {
89702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89703       };
89704     } catch (std::exception& e) {
89705       {
89706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89707       };
89708     } catch (...) {
89709       {
89710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89711       };
89712     }
89713   }
89714 }
89715
89716
89717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
89718   void * jresult ;
89719   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
89720
89721   {
89722     try {
89723       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
89724     } catch (std::out_of_range& e) {
89725       {
89726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89727       };
89728     } catch (std::exception& e) {
89729       {
89730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89731       };
89732     } catch (...) {
89733       {
89734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89735       };
89736     }
89737   }
89738   jresult = (void *)result;
89739   return jresult;
89740 }
89741
89742
89743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
89744   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
89745
89746   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
89747   {
89748     try {
89749       delete arg1;
89750     } catch (std::out_of_range& e) {
89751       {
89752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89753       };
89754     } catch (std::exception& e) {
89755       {
89756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89757       };
89758     } catch (...) {
89759       {
89760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89761       };
89762     }
89763   }
89764 }
89765
89766
89767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
89768   unsigned int jresult ;
89769   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89770   bool result;
89771
89772   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89773   {
89774     try {
89775       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89776     } catch (std::out_of_range& e) {
89777       {
89778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89779       };
89780     } catch (std::exception& e) {
89781       {
89782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89783       };
89784     } catch (...) {
89785       {
89786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89787       };
89788     }
89789   }
89790   jresult = result;
89791   return jresult;
89792 }
89793
89794
89795 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
89796   unsigned long jresult ;
89797   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89798   std::size_t result;
89799
89800   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89801   {
89802     try {
89803       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
89804     } catch (std::out_of_range& e) {
89805       {
89806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89807       };
89808     } catch (std::exception& e) {
89809       {
89810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89811       };
89812     } catch (...) {
89813       {
89814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89815       };
89816     }
89817   }
89818   jresult = (unsigned long)result;
89819   return jresult;
89820 }
89821
89822
89823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
89824   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89825   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89826
89827   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89828   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89829   {
89830     try {
89831       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
89832     } catch (std::out_of_range& e) {
89833       {
89834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89835       };
89836     } catch (std::exception& e) {
89837       {
89838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89839       };
89840     } catch (...) {
89841       {
89842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89843       };
89844     }
89845   }
89846 }
89847
89848
89849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89850   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89851   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
89852
89853   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89854   arg2 = (void (*)(Dali::Actor,bool))jarg2;
89855   {
89856     try {
89857       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89858     } catch (std::out_of_range& e) {
89859       {
89860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89861       };
89862     } catch (std::exception& e) {
89863       {
89864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89865       };
89866     } catch (...) {
89867       {
89868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89869       };
89870     }
89871   }
89872 }
89873
89874
89875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
89876   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89877   Dali::Actor arg2 ;
89878   bool arg3 ;
89879   Dali::Actor *argp2 ;
89880
89881   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89882   argp2 = (Dali::Actor *)jarg2;
89883   if (!argp2) {
89884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89885     return ;
89886   }
89887   arg2 = *argp2;
89888   arg3 = jarg3 ? true : false;
89889   {
89890     try {
89891       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
89892     } catch (std::out_of_range& e) {
89893       {
89894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89895       };
89896     } catch (std::exception& e) {
89897       {
89898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89899       };
89900     } catch (...) {
89901       {
89902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89903       };
89904     }
89905   }
89906 }
89907
89908
89909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
89910   void * jresult ;
89911   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
89912
89913   {
89914     try {
89915       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
89916     } catch (std::out_of_range& e) {
89917       {
89918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89919       };
89920     } catch (std::exception& e) {
89921       {
89922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89923       };
89924     } catch (...) {
89925       {
89926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89927       };
89928     }
89929   }
89930   jresult = (void *)result;
89931   return jresult;
89932 }
89933
89934
89935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
89936   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
89937
89938   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
89939   {
89940     try {
89941       delete arg1;
89942     } catch (std::out_of_range& e) {
89943       {
89944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89945       };
89946     } catch (std::exception& e) {
89947       {
89948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89949       };
89950     } catch (...) {
89951       {
89952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89953       };
89954     }
89955   }
89956 }
89957
89958
89959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
89960   unsigned int jresult ;
89961   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89962   bool result;
89963
89964   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89965   {
89966     try {
89967       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);
89968     } catch (std::out_of_range& e) {
89969       {
89970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89971       };
89972     } catch (std::exception& e) {
89973       {
89974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89975       };
89976     } catch (...) {
89977       {
89978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89979       };
89980     }
89981   }
89982   jresult = result;
89983   return jresult;
89984 }
89985
89986
89987 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
89988   unsigned long jresult ;
89989   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89990   std::size_t result;
89991
89992   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89993   {
89994     try {
89995       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);
89996     } catch (std::out_of_range& e) {
89997       {
89998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89999       };
90000     } catch (std::exception& e) {
90001       {
90002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90003       };
90004     } catch (...) {
90005       {
90006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90007       };
90008     }
90009   }
90010   jresult = (unsigned long)result;
90011   return jresult;
90012 }
90013
90014
90015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
90016   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90017   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90018
90019   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90020   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90021   {
90022     try {
90023       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
90024     } catch (std::out_of_range& e) {
90025       {
90026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90027       };
90028     } catch (std::exception& e) {
90029       {
90030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90031       };
90032     } catch (...) {
90033       {
90034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90035       };
90036     }
90037   }
90038 }
90039
90040
90041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90042   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90043   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90044
90045   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90046   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90047   {
90048     try {
90049       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
90050     } catch (std::out_of_range& e) {
90051       {
90052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90053       };
90054     } catch (std::exception& e) {
90055       {
90056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90057       };
90058     } catch (...) {
90059       {
90060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90061       };
90062     }
90063   }
90064 }
90065
90066
90067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90068   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90069   Dali::Toolkit::StyleManager arg2 ;
90070   Dali::StyleChange::Type arg3 ;
90071   Dali::Toolkit::StyleManager *argp2 ;
90072
90073   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90074   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
90075   if (!argp2) {
90076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
90077     return ;
90078   }
90079   arg2 = *argp2;
90080   arg3 = (Dali::StyleChange::Type)jarg3;
90081   {
90082     try {
90083       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
90084     } catch (std::out_of_range& e) {
90085       {
90086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90087       };
90088     } catch (std::exception& e) {
90089       {
90090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90091       };
90092     } catch (...) {
90093       {
90094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90095       };
90096     }
90097   }
90098 }
90099
90100
90101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
90102   void * jresult ;
90103   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
90104
90105   {
90106     try {
90107       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
90108     } catch (std::out_of_range& e) {
90109       {
90110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90111       };
90112     } catch (std::exception& e) {
90113       {
90114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90115       };
90116     } catch (...) {
90117       {
90118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90119       };
90120     }
90121   }
90122   jresult = (void *)result;
90123   return jresult;
90124 }
90125
90126
90127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
90128   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90129
90130   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90131   {
90132     try {
90133       delete arg1;
90134     } catch (std::out_of_range& e) {
90135       {
90136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90137       };
90138     } catch (std::exception& e) {
90139       {
90140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90141       };
90142     } catch (...) {
90143       {
90144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90145       };
90146     }
90147   }
90148 }
90149
90150
90151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
90152   unsigned int jresult ;
90153   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90154   bool result;
90155
90156   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90157   {
90158     try {
90159       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90160     } catch (std::out_of_range& e) {
90161       {
90162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90163       };
90164     } catch (std::exception& e) {
90165       {
90166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90167       };
90168     } catch (...) {
90169       {
90170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90171       };
90172     }
90173   }
90174   jresult = result;
90175   return jresult;
90176 }
90177
90178
90179 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
90180   unsigned long jresult ;
90181   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90182   std::size_t result;
90183
90184   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90185   {
90186     try {
90187       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90188     } catch (std::out_of_range& e) {
90189       {
90190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90191       };
90192     } catch (std::exception& e) {
90193       {
90194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90195       };
90196     } catch (...) {
90197       {
90198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90199       };
90200     }
90201   }
90202   jresult = (unsigned long)result;
90203   return jresult;
90204 }
90205
90206
90207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
90208   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90209   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90210
90211   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90212   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90213   {
90214     try {
90215       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
90216     } catch (std::out_of_range& e) {
90217       {
90218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90219       };
90220     } catch (std::exception& e) {
90221       {
90222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90223       };
90224     } catch (...) {
90225       {
90226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90227       };
90228     }
90229   }
90230 }
90231
90232
90233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
90234   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90235   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90236
90237   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90238   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90239   {
90240     try {
90241       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
90242     } catch (std::out_of_range& e) {
90243       {
90244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90245       };
90246     } catch (std::exception& e) {
90247       {
90248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90249       };
90250     } catch (...) {
90251       {
90252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90253       };
90254     }
90255   }
90256 }
90257
90258
90259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
90260   unsigned int jresult ;
90261   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90262   Dali::Toolkit::Button arg2 ;
90263   Dali::Toolkit::Button *argp2 ;
90264   bool result;
90265
90266   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90267   argp2 = (Dali::Toolkit::Button *)jarg2;
90268   if (!argp2) {
90269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
90270     return 0;
90271   }
90272   arg2 = *argp2;
90273   {
90274     try {
90275       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
90276     } catch (std::out_of_range& e) {
90277       {
90278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90279       };
90280     } catch (std::exception& e) {
90281       {
90282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90283       };
90284     } catch (...) {
90285       {
90286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90287       };
90288     }
90289   }
90290   jresult = result;
90291   return jresult;
90292 }
90293
90294
90295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
90296   void * jresult ;
90297   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
90298
90299   {
90300     try {
90301       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
90302     } catch (std::out_of_range& e) {
90303       {
90304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90305       };
90306     } catch (std::exception& e) {
90307       {
90308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90309       };
90310     } catch (...) {
90311       {
90312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90313       };
90314     }
90315   }
90316   jresult = (void *)result;
90317   return jresult;
90318 }
90319
90320
90321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
90322   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90323
90324   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90325   {
90326     try {
90327       delete arg1;
90328     } catch (std::out_of_range& e) {
90329       {
90330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90331       };
90332     } catch (std::exception& e) {
90333       {
90334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90335       };
90336     } catch (...) {
90337       {
90338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90339       };
90340     }
90341   }
90342 }
90343
90344
90345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
90346   unsigned int jresult ;
90347   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90348   bool result;
90349
90350   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90351   {
90352     try {
90353       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90354     } catch (std::out_of_range& e) {
90355       {
90356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90357       };
90358     } catch (std::exception& e) {
90359       {
90360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90361       };
90362     } catch (...) {
90363       {
90364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90365       };
90366     }
90367   }
90368   jresult = result;
90369   return jresult;
90370 }
90371
90372
90373 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
90374   unsigned long jresult ;
90375   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90376   std::size_t result;
90377
90378   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90379   {
90380     try {
90381       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
90382     } catch (std::out_of_range& e) {
90383       {
90384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90385       };
90386     } catch (std::exception& e) {
90387       {
90388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90389       };
90390     } catch (...) {
90391       {
90392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90393       };
90394     }
90395   }
90396   jresult = (unsigned long)result;
90397   return jresult;
90398 }
90399
90400
90401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
90402   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90403   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90404
90405   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90406   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90407   {
90408     try {
90409       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
90410     } catch (std::out_of_range& e) {
90411       {
90412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90413       };
90414     } catch (std::exception& e) {
90415       {
90416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90417       };
90418     } catch (...) {
90419       {
90420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90421       };
90422     }
90423   }
90424 }
90425
90426
90427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
90428   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90429   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
90430
90431   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90432   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
90433   {
90434     try {
90435       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
90436     } catch (std::out_of_range& e) {
90437       {
90438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90439       };
90440     } catch (std::exception& e) {
90441       {
90442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90443       };
90444     } catch (...) {
90445       {
90446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90447       };
90448     }
90449   }
90450 }
90451
90452
90453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
90454   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90455   Dali::Toolkit::GaussianBlurView arg2 ;
90456   Dali::Toolkit::GaussianBlurView *argp2 ;
90457
90458   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90459   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
90460   if (!argp2) {
90461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
90462     return ;
90463   }
90464   arg2 = *argp2;
90465   {
90466     try {
90467       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
90468     } catch (std::out_of_range& e) {
90469       {
90470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90471       };
90472     } catch (std::exception& e) {
90473       {
90474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90475       };
90476     } catch (...) {
90477       {
90478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90479       };
90480     }
90481   }
90482 }
90483
90484
90485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
90486   void * jresult ;
90487   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
90488
90489   {
90490     try {
90491       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
90492     } catch (std::out_of_range& e) {
90493       {
90494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90495       };
90496     } catch (std::exception& e) {
90497       {
90498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90499       };
90500     } catch (...) {
90501       {
90502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90503       };
90504     }
90505   }
90506   jresult = (void *)result;
90507   return jresult;
90508 }
90509
90510
90511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
90512   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
90513
90514   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
90515   {
90516     try {
90517       delete arg1;
90518     } catch (std::out_of_range& e) {
90519       {
90520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90521       };
90522     } catch (std::exception& e) {
90523       {
90524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90525       };
90526     } catch (...) {
90527       {
90528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90529       };
90530     }
90531   }
90532 }
90533
90534
90535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
90536   unsigned int jresult ;
90537   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90538   bool result;
90539
90540   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90541   {
90542     try {
90543       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);
90544     } catch (std::out_of_range& e) {
90545       {
90546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90547       };
90548     } catch (std::exception& e) {
90549       {
90550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90551       };
90552     } catch (...) {
90553       {
90554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90555       };
90556     }
90557   }
90558   jresult = result;
90559   return jresult;
90560 }
90561
90562
90563 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
90564   unsigned long jresult ;
90565   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90566   std::size_t result;
90567
90568   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90569   {
90570     try {
90571       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);
90572     } catch (std::out_of_range& e) {
90573       {
90574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90575       };
90576     } catch (std::exception& e) {
90577       {
90578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90579       };
90580     } catch (...) {
90581       {
90582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90583       };
90584     }
90585   }
90586   jresult = (unsigned long)result;
90587   return jresult;
90588 }
90589
90590
90591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
90592   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90593   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90594
90595   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90596   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90597   {
90598     try {
90599       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
90600     } catch (std::out_of_range& e) {
90601       {
90602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90603       };
90604     } catch (std::exception& e) {
90605       {
90606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90607       };
90608     } catch (...) {
90609       {
90610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90611       };
90612     }
90613   }
90614 }
90615
90616
90617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
90618   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90619   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
90620
90621   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90622   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
90623   {
90624     try {
90625       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90626     } catch (std::out_of_range& e) {
90627       {
90628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90629       };
90630     } catch (std::exception& e) {
90631       {
90632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90633       };
90634     } catch (...) {
90635       {
90636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90637       };
90638     }
90639   }
90640 }
90641
90642
90643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
90644   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90645   Dali::Toolkit::PageTurnView arg2 ;
90646   unsigned int arg3 ;
90647   bool arg4 ;
90648   Dali::Toolkit::PageTurnView *argp2 ;
90649
90650   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90651   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90652   if (!argp2) {
90653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90654     return ;
90655   }
90656   arg2 = *argp2;
90657   arg3 = (unsigned int)jarg3;
90658   arg4 = jarg4 ? true : false;
90659   {
90660     try {
90661       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90662     } catch (std::out_of_range& e) {
90663       {
90664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90665       };
90666     } catch (std::exception& e) {
90667       {
90668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90669       };
90670     } catch (...) {
90671       {
90672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90673       };
90674     }
90675   }
90676 }
90677
90678
90679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
90680   void * jresult ;
90681   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
90682
90683   {
90684     try {
90685       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
90686     } catch (std::out_of_range& e) {
90687       {
90688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90689       };
90690     } catch (std::exception& e) {
90691       {
90692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90693       };
90694     } catch (...) {
90695       {
90696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90697       };
90698     }
90699   }
90700   jresult = (void *)result;
90701   return jresult;
90702 }
90703
90704
90705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
90706   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
90707
90708   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
90709   {
90710     try {
90711       delete arg1;
90712     } catch (std::out_of_range& e) {
90713       {
90714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90715       };
90716     } catch (std::exception& e) {
90717       {
90718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90719       };
90720     } catch (...) {
90721       {
90722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90723       };
90724     }
90725   }
90726 }
90727
90728
90729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
90730   unsigned int jresult ;
90731   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90732   bool result;
90733
90734   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90735   {
90736     try {
90737       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90738     } catch (std::out_of_range& e) {
90739       {
90740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90741       };
90742     } catch (std::exception& e) {
90743       {
90744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90745       };
90746     } catch (...) {
90747       {
90748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90749       };
90750     }
90751   }
90752   jresult = result;
90753   return jresult;
90754 }
90755
90756
90757 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
90758   unsigned long jresult ;
90759   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90760   std::size_t result;
90761
90762   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90763   {
90764     try {
90765       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
90766     } catch (std::out_of_range& e) {
90767       {
90768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90769       };
90770     } catch (std::exception& e) {
90771       {
90772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90773       };
90774     } catch (...) {
90775       {
90776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90777       };
90778     }
90779   }
90780   jresult = (unsigned long)result;
90781   return jresult;
90782 }
90783
90784
90785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
90786   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90787   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90788
90789   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90790   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90791   {
90792     try {
90793       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
90794     } catch (std::out_of_range& e) {
90795       {
90796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90797       };
90798     } catch (std::exception& e) {
90799       {
90800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90801       };
90802     } catch (...) {
90803       {
90804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90805       };
90806     }
90807   }
90808 }
90809
90810
90811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
90812   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90813   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
90814
90815   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90816   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
90817   {
90818     try {
90819       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
90820     } catch (std::out_of_range& e) {
90821       {
90822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90823       };
90824     } catch (std::exception& e) {
90825       {
90826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90827       };
90828     } catch (...) {
90829       {
90830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90831       };
90832     }
90833   }
90834 }
90835
90836
90837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
90838   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90839   Dali::Toolkit::PageTurnView arg2 ;
90840   Dali::Toolkit::PageTurnView *argp2 ;
90841
90842   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90843   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
90844   if (!argp2) {
90845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
90846     return ;
90847   }
90848   arg2 = *argp2;
90849   {
90850     try {
90851       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
90852     } catch (std::out_of_range& e) {
90853       {
90854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90855       };
90856     } catch (std::exception& e) {
90857       {
90858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90859       };
90860     } catch (...) {
90861       {
90862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90863       };
90864     }
90865   }
90866 }
90867
90868
90869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
90870   void * jresult ;
90871   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
90872
90873   {
90874     try {
90875       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
90876     } catch (std::out_of_range& e) {
90877       {
90878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90879       };
90880     } catch (std::exception& e) {
90881       {
90882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90883       };
90884     } catch (...) {
90885       {
90886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90887       };
90888     }
90889   }
90890   jresult = (void *)result;
90891   return jresult;
90892 }
90893
90894
90895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
90896   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
90897
90898   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
90899   {
90900     try {
90901       delete arg1;
90902     } catch (std::out_of_range& e) {
90903       {
90904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90905       };
90906     } catch (std::exception& e) {
90907       {
90908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90909       };
90910     } catch (...) {
90911       {
90912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90913       };
90914     }
90915   }
90916 }
90917
90918
90919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
90920   unsigned int jresult ;
90921   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90922   bool result;
90923
90924   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90925   {
90926     try {
90927       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);
90928     } catch (std::out_of_range& e) {
90929       {
90930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90931       };
90932     } catch (std::exception& e) {
90933       {
90934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90935       };
90936     } catch (...) {
90937       {
90938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90939       };
90940     }
90941   }
90942   jresult = result;
90943   return jresult;
90944 }
90945
90946
90947 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
90948   unsigned long jresult ;
90949   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90950   std::size_t result;
90951
90952   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90953   {
90954     try {
90955       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);
90956     } catch (std::out_of_range& e) {
90957       {
90958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90959       };
90960     } catch (std::exception& e) {
90961       {
90962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90963       };
90964     } catch (...) {
90965       {
90966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90967       };
90968     }
90969   }
90970   jresult = (unsigned long)result;
90971   return jresult;
90972 }
90973
90974
90975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
90976   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90977   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90978
90979   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90980   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90981   {
90982     try {
90983       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90984     } catch (std::out_of_range& e) {
90985       {
90986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90987       };
90988     } catch (std::exception& e) {
90989       {
90990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90991       };
90992     } catch (...) {
90993       {
90994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90995       };
90996     }
90997   }
90998 }
90999
91000
91001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
91002   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91003   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
91004
91005   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91006   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
91007   {
91008     try {
91009       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91010     } catch (std::out_of_range& e) {
91011       {
91012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91013       };
91014     } catch (std::exception& e) {
91015       {
91016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91017       };
91018     } catch (...) {
91019       {
91020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91021       };
91022     }
91023   }
91024 }
91025
91026
91027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
91028   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91029   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
91030
91031   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91032   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
91033   if (!arg2) {
91034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
91035     return ;
91036   }
91037   {
91038     try {
91039       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
91040     } catch (std::out_of_range& e) {
91041       {
91042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91043       };
91044     } catch (std::exception& e) {
91045       {
91046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91047       };
91048     } catch (...) {
91049       {
91050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91051       };
91052     }
91053   }
91054 }
91055
91056
91057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
91058   void * jresult ;
91059   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
91060
91061   {
91062     try {
91063       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
91064     } catch (std::out_of_range& e) {
91065       {
91066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91067       };
91068     } catch (std::exception& e) {
91069       {
91070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91071       };
91072     } catch (...) {
91073       {
91074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91075       };
91076     }
91077   }
91078   jresult = (void *)result;
91079   return jresult;
91080 }
91081
91082
91083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
91084   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
91085
91086   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
91087   {
91088     try {
91089       delete arg1;
91090     } catch (std::out_of_range& e) {
91091       {
91092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91093       };
91094     } catch (std::exception& e) {
91095       {
91096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91097       };
91098     } catch (...) {
91099       {
91100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91101       };
91102     }
91103   }
91104 }
91105
91106
91107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
91108   unsigned int jresult ;
91109   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91110   bool result;
91111
91112   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91113   {
91114     try {
91115       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91116     } catch (std::out_of_range& e) {
91117       {
91118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91119       };
91120     } catch (std::exception& e) {
91121       {
91122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91123       };
91124     } catch (...) {
91125       {
91126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91127       };
91128     }
91129   }
91130   jresult = result;
91131   return jresult;
91132 }
91133
91134
91135 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
91136   unsigned long jresult ;
91137   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91138   std::size_t result;
91139
91140   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91141   {
91142     try {
91143       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
91144     } catch (std::out_of_range& e) {
91145       {
91146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91147       };
91148     } catch (std::exception& e) {
91149       {
91150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91151       };
91152     } catch (...) {
91153       {
91154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91155       };
91156     }
91157   }
91158   jresult = (unsigned long)result;
91159   return jresult;
91160 }
91161
91162
91163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
91164   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91165   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91166
91167   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91168   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91169   {
91170     try {
91171       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91172     } catch (std::out_of_range& e) {
91173       {
91174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91175       };
91176     } catch (std::exception& e) {
91177       {
91178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91179       };
91180     } catch (...) {
91181       {
91182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91183       };
91184     }
91185   }
91186 }
91187
91188
91189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
91190   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91191   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
91192
91193   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91194   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
91195   {
91196     try {
91197       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91198     } catch (std::out_of_range& e) {
91199       {
91200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91201       };
91202     } catch (std::exception& e) {
91203       {
91204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91205       };
91206     } catch (...) {
91207       {
91208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91209       };
91210     }
91211   }
91212 }
91213
91214
91215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
91216   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91217   Dali::Vector2 *arg2 = 0 ;
91218
91219   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91220   arg2 = (Dali::Vector2 *)jarg2;
91221   if (!arg2) {
91222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91223     return ;
91224   }
91225   {
91226     try {
91227       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
91228     } catch (std::out_of_range& e) {
91229       {
91230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91231       };
91232     } catch (std::exception& e) {
91233       {
91234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91235       };
91236     } catch (...) {
91237       {
91238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91239       };
91240     }
91241   }
91242 }
91243
91244
91245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
91246   void * jresult ;
91247   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
91248
91249   {
91250     try {
91251       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
91252     } catch (std::out_of_range& e) {
91253       {
91254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91255       };
91256     } catch (std::exception& e) {
91257       {
91258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91259       };
91260     } catch (...) {
91261       {
91262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91263       };
91264     }
91265   }
91266   jresult = (void *)result;
91267   return jresult;
91268 }
91269
91270
91271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
91272   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
91273
91274   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
91275   {
91276     try {
91277       delete arg1;
91278     } catch (std::out_of_range& e) {
91279       {
91280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91281       };
91282     } catch (std::exception& e) {
91283       {
91284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91285       };
91286     } catch (...) {
91287       {
91288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91289       };
91290     }
91291   }
91292 }
91293
91294
91295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
91296   unsigned int jresult ;
91297   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91298   bool result;
91299
91300   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91301   {
91302     try {
91303       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91304     } catch (std::out_of_range& e) {
91305       {
91306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91307       };
91308     } catch (std::exception& e) {
91309       {
91310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91311       };
91312     } catch (...) {
91313       {
91314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91315       };
91316     }
91317   }
91318   jresult = result;
91319   return jresult;
91320 }
91321
91322
91323 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
91324   unsigned long jresult ;
91325   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91326   std::size_t result;
91327
91328   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91329   {
91330     try {
91331       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
91332     } catch (std::out_of_range& e) {
91333       {
91334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91335       };
91336     } catch (std::exception& e) {
91337       {
91338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91339       };
91340     } catch (...) {
91341       {
91342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91343       };
91344     }
91345   }
91346   jresult = (unsigned long)result;
91347   return jresult;
91348 }
91349
91350
91351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
91352   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91353   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91354
91355   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91356   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91357   {
91358     try {
91359       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
91360     } catch (std::out_of_range& e) {
91361       {
91362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91363       };
91364     } catch (std::exception& e) {
91365       {
91366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91367       };
91368     } catch (...) {
91369       {
91370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91371       };
91372     }
91373   }
91374 }
91375
91376
91377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
91378   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91379   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
91380
91381   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91382   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
91383   {
91384     try {
91385       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
91386     } catch (std::out_of_range& e) {
91387       {
91388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91389       };
91390     } catch (std::exception& e) {
91391       {
91392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91393       };
91394     } catch (...) {
91395       {
91396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91397       };
91398     }
91399   }
91400 }
91401
91402
91403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
91404   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91405   Dali::Toolkit::TextEditor arg2 ;
91406   Dali::Toolkit::TextEditor *argp2 ;
91407
91408   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91409   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
91410   if (!argp2) {
91411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
91412     return ;
91413   }
91414   arg2 = *argp2;
91415   {
91416     try {
91417       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
91418     } catch (std::out_of_range& e) {
91419       {
91420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91421       };
91422     } catch (std::exception& e) {
91423       {
91424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91425       };
91426     } catch (...) {
91427       {
91428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91429       };
91430     }
91431   }
91432 }
91433
91434
91435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
91436   void * jresult ;
91437   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
91438
91439   {
91440     try {
91441       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
91442     } catch (std::out_of_range& e) {
91443       {
91444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91445       };
91446     } catch (std::exception& e) {
91447       {
91448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91449       };
91450     } catch (...) {
91451       {
91452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91453       };
91454     }
91455   }
91456   jresult = (void *)result;
91457   return jresult;
91458 }
91459
91460
91461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
91462   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
91463
91464   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
91465   {
91466     try {
91467       delete arg1;
91468     } catch (std::out_of_range& e) {
91469       {
91470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91471       };
91472     } catch (std::exception& e) {
91473       {
91474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91475       };
91476     } catch (...) {
91477       {
91478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91479       };
91480     }
91481   }
91482 }
91483
91484
91485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
91486   unsigned int jresult ;
91487   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91488   bool result;
91489
91490   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91491   {
91492     try {
91493       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91494     } catch (std::out_of_range& e) {
91495       {
91496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91497       };
91498     } catch (std::exception& e) {
91499       {
91500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91501       };
91502     } catch (...) {
91503       {
91504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91505       };
91506     }
91507   }
91508   jresult = result;
91509   return jresult;
91510 }
91511
91512
91513 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
91514   unsigned long jresult ;
91515   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91516   std::size_t result;
91517
91518   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91519   {
91520     try {
91521       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
91522     } catch (std::out_of_range& e) {
91523       {
91524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91525       };
91526     } catch (std::exception& e) {
91527       {
91528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91529       };
91530     } catch (...) {
91531       {
91532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91533       };
91534     }
91535   }
91536   jresult = (unsigned long)result;
91537   return jresult;
91538 }
91539
91540
91541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
91542   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91543   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91544
91545   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91546   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91547   {
91548     try {
91549       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
91550     } catch (std::out_of_range& e) {
91551       {
91552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91553       };
91554     } catch (std::exception& e) {
91555       {
91556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91557       };
91558     } catch (...) {
91559       {
91560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91561       };
91562     }
91563   }
91564 }
91565
91566
91567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
91568   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91569   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
91570
91571   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91572   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
91573   {
91574     try {
91575       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
91576     } catch (std::out_of_range& e) {
91577       {
91578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91579       };
91580     } catch (std::exception& e) {
91581       {
91582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91583       };
91584     } catch (...) {
91585       {
91586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91587       };
91588     }
91589   }
91590 }
91591
91592
91593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
91594   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91595   Dali::Toolkit::TextField arg2 ;
91596   Dali::Toolkit::TextField *argp2 ;
91597
91598   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91599   argp2 = (Dali::Toolkit::TextField *)jarg2;
91600   if (!argp2) {
91601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
91602     return ;
91603   }
91604   arg2 = *argp2;
91605   {
91606     try {
91607       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
91608     } catch (std::out_of_range& e) {
91609       {
91610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91611       };
91612     } catch (std::exception& e) {
91613       {
91614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91615       };
91616     } catch (...) {
91617       {
91618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91619       };
91620     }
91621   }
91622 }
91623
91624
91625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
91626   void * jresult ;
91627   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
91628
91629   {
91630     try {
91631       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
91632     } catch (std::out_of_range& e) {
91633       {
91634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91635       };
91636     } catch (std::exception& e) {
91637       {
91638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91639       };
91640     } catch (...) {
91641       {
91642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91643       };
91644     }
91645   }
91646   jresult = (void *)result;
91647   return jresult;
91648 }
91649
91650
91651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
91652   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
91653
91654   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
91655   {
91656     try {
91657       delete arg1;
91658     } catch (std::out_of_range& e) {
91659       {
91660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91661       };
91662     } catch (std::exception& e) {
91663       {
91664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91665       };
91666     } catch (...) {
91667       {
91668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91669       };
91670     }
91671   }
91672 }
91673
91674
91675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
91676   unsigned int jresult ;
91677   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91678   bool result;
91679
91680   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91681   {
91682     try {
91683       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);
91684     } catch (std::out_of_range& e) {
91685       {
91686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91687       };
91688     } catch (std::exception& e) {
91689       {
91690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91691       };
91692     } catch (...) {
91693       {
91694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91695       };
91696     }
91697   }
91698   jresult = result;
91699   return jresult;
91700 }
91701
91702
91703 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
91704   unsigned long jresult ;
91705   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91706   std::size_t result;
91707
91708   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91709   {
91710     try {
91711       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);
91712     } catch (std::out_of_range& e) {
91713       {
91714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91715       };
91716     } catch (std::exception& e) {
91717       {
91718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91719       };
91720     } catch (...) {
91721       {
91722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91723       };
91724     }
91725   }
91726   jresult = (unsigned long)result;
91727   return jresult;
91728 }
91729
91730
91731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
91732   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91733   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91734
91735   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91736   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91737   {
91738     try {
91739       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
91740     } catch (std::out_of_range& e) {
91741       {
91742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91743       };
91744     } catch (std::exception& e) {
91745       {
91746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91747       };
91748     } catch (...) {
91749       {
91750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91751       };
91752     }
91753   }
91754 }
91755
91756
91757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
91758   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91759   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
91760
91761   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91762   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
91763   {
91764     try {
91765       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
91766     } catch (std::out_of_range& e) {
91767       {
91768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91769       };
91770     } catch (std::exception& e) {
91771       {
91772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91773       };
91774     } catch (...) {
91775       {
91776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91777       };
91778     }
91779   }
91780 }
91781
91782
91783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
91784   unsigned int jresult ;
91785   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91786   Dali::Toolkit::Control arg2 ;
91787   Dali::KeyEvent *arg3 = 0 ;
91788   Dali::Toolkit::Control *argp2 ;
91789   bool result;
91790
91791   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91792   argp2 = (Dali::Toolkit::Control *)jarg2;
91793   if (!argp2) {
91794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91795     return 0;
91796   }
91797   arg2 = *argp2;
91798   arg3 = (Dali::KeyEvent *)jarg3;
91799   if (!arg3) {
91800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
91801     return 0;
91802   }
91803   {
91804     try {
91805       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);
91806     } catch (std::out_of_range& e) {
91807       {
91808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91809       };
91810     } catch (std::exception& e) {
91811       {
91812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91813       };
91814     } catch (...) {
91815       {
91816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91817       };
91818     }
91819   }
91820   jresult = result;
91821   return jresult;
91822 }
91823
91824
91825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
91826   void * jresult ;
91827   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
91828
91829   {
91830     try {
91831       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
91832     } catch (std::out_of_range& e) {
91833       {
91834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91835       };
91836     } catch (std::exception& e) {
91837       {
91838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91839       };
91840     } catch (...) {
91841       {
91842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91843       };
91844     }
91845   }
91846   jresult = (void *)result;
91847   return jresult;
91848 }
91849
91850
91851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
91852   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91853
91854   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91855   {
91856     try {
91857       delete arg1;
91858     } catch (std::out_of_range& e) {
91859       {
91860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91861       };
91862     } catch (std::exception& e) {
91863       {
91864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91865       };
91866     } catch (...) {
91867       {
91868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91869       };
91870     }
91871   }
91872 }
91873
91874
91875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
91876   unsigned int jresult ;
91877   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91878   bool result;
91879
91880   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91881   {
91882     try {
91883       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91884     } catch (std::out_of_range& e) {
91885       {
91886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91887       };
91888     } catch (std::exception& e) {
91889       {
91890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91891       };
91892     } catch (...) {
91893       {
91894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91895       };
91896     }
91897   }
91898   jresult = result;
91899   return jresult;
91900 }
91901
91902
91903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
91904   unsigned long jresult ;
91905   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91906   std::size_t result;
91907
91908   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91909   {
91910     try {
91911       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91912     } catch (std::out_of_range& e) {
91913       {
91914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91915       };
91916     } catch (std::exception& e) {
91917       {
91918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91919       };
91920     } catch (...) {
91921       {
91922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91923       };
91924     }
91925   }
91926   jresult = (unsigned long)result;
91927   return jresult;
91928 }
91929
91930
91931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
91932   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91933   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91934
91935   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91936   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91937   {
91938     try {
91939       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
91940     } catch (std::out_of_range& e) {
91941       {
91942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91943       };
91944     } catch (std::exception& e) {
91945       {
91946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91947       };
91948     } catch (...) {
91949       {
91950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91951       };
91952     }
91953   }
91954 }
91955
91956
91957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
91958   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91959   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91960
91961   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91962   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91963   {
91964     try {
91965       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
91966     } catch (std::out_of_range& e) {
91967       {
91968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91969       };
91970     } catch (std::exception& e) {
91971       {
91972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91973       };
91974     } catch (...) {
91975       {
91976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91977       };
91978     }
91979   }
91980 }
91981
91982
91983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
91984   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91985   Dali::Toolkit::Control arg2 ;
91986   Dali::Toolkit::Control *argp2 ;
91987
91988   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91989   argp2 = (Dali::Toolkit::Control *)jarg2;
91990   if (!argp2) {
91991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91992     return ;
91993   }
91994   arg2 = *argp2;
91995   {
91996     try {
91997       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
91998     } catch (std::out_of_range& e) {
91999       {
92000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92001       };
92002     } catch (std::exception& e) {
92003       {
92004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92005       };
92006     } catch (...) {
92007       {
92008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92009       };
92010     }
92011   }
92012 }
92013
92014
92015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
92016   void * jresult ;
92017   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
92018
92019   {
92020     try {
92021       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
92022     } catch (std::out_of_range& e) {
92023       {
92024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92025       };
92026     } catch (std::exception& e) {
92027       {
92028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92029       };
92030     } catch (...) {
92031       {
92032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92033       };
92034     }
92035   }
92036   jresult = (void *)result;
92037   return jresult;
92038 }
92039
92040
92041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
92042   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92043
92044   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92045   {
92046     try {
92047       delete arg1;
92048     } catch (std::out_of_range& e) {
92049       {
92050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92051       };
92052     } catch (std::exception& e) {
92053       {
92054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92055       };
92056     } catch (...) {
92057       {
92058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92059       };
92060     }
92061   }
92062 }
92063
92064
92065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
92066   unsigned int jresult ;
92067   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92068   bool result;
92069
92070   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92071   {
92072     try {
92073       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92074     } catch (std::out_of_range& e) {
92075       {
92076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92077       };
92078     } catch (std::exception& e) {
92079       {
92080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92081       };
92082     } catch (...) {
92083       {
92084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92085       };
92086     }
92087   }
92088   jresult = result;
92089   return jresult;
92090 }
92091
92092
92093 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
92094   unsigned long jresult ;
92095   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92096   std::size_t result;
92097
92098   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92099   {
92100     try {
92101       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92102     } catch (std::out_of_range& e) {
92103       {
92104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92105       };
92106     } catch (std::exception& e) {
92107       {
92108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92109       };
92110     } catch (...) {
92111       {
92112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92113       };
92114     }
92115   }
92116   jresult = (unsigned long)result;
92117   return jresult;
92118 }
92119
92120
92121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
92122   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92123   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92124
92125   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92126   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92127   {
92128     try {
92129       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
92130     } catch (std::out_of_range& e) {
92131       {
92132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92133       };
92134     } catch (std::exception& e) {
92135       {
92136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92137       };
92138     } catch (...) {
92139       {
92140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92141       };
92142     }
92143   }
92144 }
92145
92146
92147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
92148   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92149   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
92150
92151   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92152   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
92153   {
92154     try {
92155       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
92156     } catch (std::out_of_range& e) {
92157       {
92158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92159       };
92160     } catch (std::exception& e) {
92161       {
92162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92163       };
92164     } catch (...) {
92165       {
92166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92167       };
92168     }
92169   }
92170 }
92171
92172
92173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
92174   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92175   Dali::Toolkit::VideoView *arg2 = 0 ;
92176
92177   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92178   arg2 = (Dali::Toolkit::VideoView *)jarg2;
92179   if (!arg2) {
92180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
92181     return ;
92182   }
92183   {
92184     try {
92185       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
92186     } catch (std::out_of_range& e) {
92187       {
92188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92189       };
92190     } catch (std::exception& e) {
92191       {
92192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92193       };
92194     } catch (...) {
92195       {
92196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92197       };
92198     }
92199   }
92200 }
92201
92202
92203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
92204   void * jresult ;
92205   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
92206
92207   {
92208     try {
92209       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
92210     } catch (std::out_of_range& e) {
92211       {
92212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92213       };
92214     } catch (std::exception& e) {
92215       {
92216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92217       };
92218     } catch (...) {
92219       {
92220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92221       };
92222     }
92223   }
92224   jresult = (void *)result;
92225   return jresult;
92226 }
92227
92228
92229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
92230   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92231
92232   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92233   {
92234     try {
92235       delete arg1;
92236     } catch (std::out_of_range& e) {
92237       {
92238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92239       };
92240     } catch (std::exception& e) {
92241       {
92242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92243       };
92244     } catch (...) {
92245       {
92246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92247       };
92248     }
92249   }
92250 }
92251
92252
92253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
92254   unsigned int jresult ;
92255   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92256   bool result;
92257
92258   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92259   {
92260     try {
92261       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92262     } catch (std::out_of_range& e) {
92263       {
92264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92265       };
92266     } catch (std::exception& e) {
92267       {
92268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92269       };
92270     } catch (...) {
92271       {
92272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92273       };
92274     }
92275   }
92276   jresult = result;
92277   return jresult;
92278 }
92279
92280
92281 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
92282   unsigned long jresult ;
92283   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92284   std::size_t result;
92285
92286   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92287   {
92288     try {
92289       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
92290     } catch (std::out_of_range& e) {
92291       {
92292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92293       };
92294     } catch (std::exception& e) {
92295       {
92296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92297       };
92298     } catch (...) {
92299       {
92300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92301       };
92302     }
92303   }
92304   jresult = (unsigned long)result;
92305   return jresult;
92306 }
92307
92308
92309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92310   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92311   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92312
92313   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92314   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92315   {
92316     try {
92317       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
92318     } catch (std::out_of_range& e) {
92319       {
92320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92321       };
92322     } catch (std::exception& e) {
92323       {
92324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92325       };
92326     } catch (...) {
92327       {
92328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92329       };
92330     }
92331   }
92332 }
92333
92334
92335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92336   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92337   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
92338
92339   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92340   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
92341   {
92342     try {
92343       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92344     } catch (std::out_of_range& e) {
92345       {
92346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92347       };
92348     } catch (std::exception& e) {
92349       {
92350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92351       };
92352     } catch (...) {
92353       {
92354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92355       };
92356     }
92357   }
92358 }
92359
92360
92361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
92362   unsigned int jresult ;
92363   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92364   Dali::Toolkit::Slider arg2 ;
92365   float arg3 ;
92366   Dali::Toolkit::Slider *argp2 ;
92367   bool result;
92368
92369   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92370   argp2 = (Dali::Toolkit::Slider *)jarg2;
92371   if (!argp2) {
92372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92373     return 0;
92374   }
92375   arg2 = *argp2;
92376   arg3 = (float)jarg3;
92377   {
92378     try {
92379       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
92380     } catch (std::out_of_range& e) {
92381       {
92382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92383       };
92384     } catch (std::exception& e) {
92385       {
92386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92387       };
92388     } catch (...) {
92389       {
92390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92391       };
92392     }
92393   }
92394   jresult = result;
92395   return jresult;
92396 }
92397
92398
92399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
92400   void * jresult ;
92401   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
92402
92403   {
92404     try {
92405       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
92406     } catch (std::out_of_range& e) {
92407       {
92408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92409       };
92410     } catch (std::exception& e) {
92411       {
92412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92413       };
92414     } catch (...) {
92415       {
92416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92417       };
92418     }
92419   }
92420   jresult = (void *)result;
92421   return jresult;
92422 }
92423
92424
92425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
92426   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
92427
92428   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
92429   {
92430     try {
92431       delete arg1;
92432     } catch (std::out_of_range& e) {
92433       {
92434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92435       };
92436     } catch (std::exception& e) {
92437       {
92438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92439       };
92440     } catch (...) {
92441       {
92442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92443       };
92444     }
92445   }
92446 }
92447
92448
92449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
92450   unsigned int jresult ;
92451   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92452   bool result;
92453
92454   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92455   {
92456     try {
92457       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92458     } catch (std::out_of_range& e) {
92459       {
92460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92461       };
92462     } catch (std::exception& e) {
92463       {
92464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92465       };
92466     } catch (...) {
92467       {
92468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92469       };
92470     }
92471   }
92472   jresult = result;
92473   return jresult;
92474 }
92475
92476
92477 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
92478   unsigned long jresult ;
92479   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92480   std::size_t result;
92481
92482   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92483   {
92484     try {
92485       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
92486     } catch (std::out_of_range& e) {
92487       {
92488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92489       };
92490     } catch (std::exception& e) {
92491       {
92492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92493       };
92494     } catch (...) {
92495       {
92496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92497       };
92498     }
92499   }
92500   jresult = (unsigned long)result;
92501   return jresult;
92502 }
92503
92504
92505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
92506   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92507   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92508
92509   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92510   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92511   {
92512     try {
92513       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
92514     } catch (std::out_of_range& e) {
92515       {
92516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92517       };
92518     } catch (std::exception& e) {
92519       {
92520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92521       };
92522     } catch (...) {
92523       {
92524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92525       };
92526     }
92527   }
92528 }
92529
92530
92531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
92532   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92533   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
92534
92535   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92536   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
92537   {
92538     try {
92539       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
92540     } catch (std::out_of_range& e) {
92541       {
92542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92543       };
92544     } catch (std::exception& e) {
92545       {
92546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92547       };
92548     } catch (...) {
92549       {
92550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92551       };
92552     }
92553   }
92554 }
92555
92556
92557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
92558   unsigned int jresult ;
92559   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92560   Dali::Toolkit::Slider arg2 ;
92561   int arg3 ;
92562   Dali::Toolkit::Slider *argp2 ;
92563   bool result;
92564
92565   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92566   argp2 = (Dali::Toolkit::Slider *)jarg2;
92567   if (!argp2) {
92568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
92569     return 0;
92570   }
92571   arg2 = *argp2;
92572   arg3 = (int)jarg3;
92573   {
92574     try {
92575       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
92576     } catch (std::out_of_range& e) {
92577       {
92578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92579       };
92580     } catch (std::exception& e) {
92581       {
92582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92583       };
92584     } catch (...) {
92585       {
92586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92587       };
92588     }
92589   }
92590   jresult = result;
92591   return jresult;
92592 }
92593
92594
92595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
92596   void * jresult ;
92597   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
92598
92599   {
92600     try {
92601       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
92602     } catch (std::out_of_range& e) {
92603       {
92604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92605       };
92606     } catch (std::exception& e) {
92607       {
92608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92609       };
92610     } catch (...) {
92611       {
92612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92613       };
92614     }
92615   }
92616   jresult = (void *)result;
92617   return jresult;
92618 }
92619
92620
92621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
92622   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
92623
92624   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
92625   {
92626     try {
92627       delete arg1;
92628     } catch (std::out_of_range& e) {
92629       {
92630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92631       };
92632     } catch (std::exception& e) {
92633       {
92634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92635       };
92636     } catch (...) {
92637       {
92638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92639       };
92640     }
92641   }
92642 }
92643
92644
92645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
92646   void * jresult ;
92647   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92648
92649   {
92650     try {
92651       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
92652     } catch (std::out_of_range& e) {
92653       {
92654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92655       };
92656     } catch (std::exception& e) {
92657       {
92658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92659       };
92660     } catch (...) {
92661       {
92662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92663       };
92664     }
92665   }
92666   jresult = (void *)result;
92667   return jresult;
92668 }
92669
92670
92671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
92672   void * jresult ;
92673   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
92674   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92675
92676   arg1 = (Dali::Toolkit::Ruler *)jarg1;
92677   {
92678     try {
92679       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
92680     } catch (std::out_of_range& e) {
92681       {
92682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92683       };
92684     } catch (std::exception& e) {
92685       {
92686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92687       };
92688     } catch (...) {
92689       {
92690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92691       };
92692     }
92693   }
92694   jresult = (void *)result;
92695   return jresult;
92696 }
92697
92698
92699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
92700   void * jresult ;
92701   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
92702   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92703
92704   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92705   if (!arg1) {
92706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92707     return 0;
92708   }
92709   {
92710     try {
92711       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
92712     } catch (std::out_of_range& e) {
92713       {
92714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92715       };
92716     } catch (std::exception& e) {
92717       {
92718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92719       };
92720     } catch (...) {
92721       {
92722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92723       };
92724     }
92725   }
92726   jresult = (void *)result;
92727   return jresult;
92728 }
92729
92730
92731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
92732   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92733
92734   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92735   {
92736     try {
92737       delete arg1;
92738     } catch (std::out_of_range& e) {
92739       {
92740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92741       };
92742     } catch (std::exception& e) {
92743       {
92744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92745       };
92746     } catch (...) {
92747       {
92748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92749       };
92750     }
92751   }
92752 }
92753
92754
92755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
92756   void * jresult ;
92757   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92758   Dali::Toolkit::Ruler *result = 0 ;
92759
92760   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92761   {
92762     try {
92763       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
92764     } catch (std::out_of_range& e) {
92765       {
92766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92767       };
92768     } catch (std::exception& e) {
92769       {
92770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92771       };
92772     } catch (...) {
92773       {
92774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92775       };
92776     }
92777   }
92778   jresult = (void *)result;
92779   return jresult;
92780 }
92781
92782
92783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
92784   void * jresult ;
92785   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92786   Dali::Toolkit::Ruler *result = 0 ;
92787
92788   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92789   {
92790     try {
92791       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
92792     } catch (std::out_of_range& e) {
92793       {
92794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92795       };
92796     } catch (std::exception& e) {
92797       {
92798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92799       };
92800     } catch (...) {
92801       {
92802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92803       };
92804     }
92805   }
92806   jresult = (void *)result;
92807   return jresult;
92808 }
92809
92810
92811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
92812   void * jresult ;
92813   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92814   Dali::Toolkit::Ruler *result = 0 ;
92815
92816   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92817   {
92818     try {
92819       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
92820     } catch (std::out_of_range& e) {
92821       {
92822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92823       };
92824     } catch (std::exception& e) {
92825       {
92826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92827       };
92828     } catch (...) {
92829       {
92830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92831       };
92832     }
92833   }
92834   jresult = (void *)result;
92835   return jresult;
92836 }
92837
92838
92839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
92840   void * jresult ;
92841   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92842   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
92843   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92844
92845   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92846   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
92847   if (!arg2) {
92848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92849     return 0;
92850   }
92851   {
92852     try {
92853       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
92854     } catch (std::out_of_range& e) {
92855       {
92856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92857       };
92858     } catch (std::exception& e) {
92859       {
92860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92861       };
92862     } catch (...) {
92863       {
92864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92865       };
92866     }
92867   }
92868   jresult = (void *)result;
92869   return jresult;
92870 }
92871
92872
92873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
92874   void * jresult ;
92875   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92876   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92877   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92878
92879   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92880   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92881   {
92882     try {
92883       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
92884     } catch (std::out_of_range& e) {
92885       {
92886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92887       };
92888     } catch (std::exception& e) {
92889       {
92890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92891       };
92892     } catch (...) {
92893       {
92894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92895       };
92896     }
92897   }
92898   jresult = (void *)result;
92899   return jresult;
92900 }
92901
92902
92903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
92904   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92905
92906   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92907   {
92908     try {
92909       (arg1)->Reset();
92910     } catch (std::out_of_range& e) {
92911       {
92912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92913       };
92914     } catch (std::exception& e) {
92915       {
92916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92917       };
92918     } catch (...) {
92919       {
92920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92921       };
92922     }
92923   }
92924 }
92925
92926
92927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
92928   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92929   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92930
92931   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92932   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92933   {
92934     try {
92935       (arg1)->Reset(arg2);
92936     } catch (std::out_of_range& e) {
92937       {
92938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92939       };
92940     } catch (std::exception& e) {
92941       {
92942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92943       };
92944     } catch (...) {
92945       {
92946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92947       };
92948     }
92949   }
92950 }
92951
92952
92953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
92954   void * jresult ;
92955   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92956   Dali::Toolkit::Ruler *result = 0 ;
92957
92958   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92959   {
92960     try {
92961       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
92962     } catch (std::out_of_range& e) {
92963       {
92964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92965       };
92966     } catch (std::exception& e) {
92967       {
92968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92969       };
92970     } catch (...) {
92971       {
92972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92973       };
92974     }
92975   }
92976   jresult = (void *)result;
92977   return jresult;
92978 }
92979
92980
92981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
92982   float jresult ;
92983   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92984   float arg2 ;
92985   float arg3 ;
92986   float result;
92987
92988   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92989   arg2 = (float)jarg2;
92990   arg3 = (float)jarg3;
92991   {
92992     try {
92993       result = (float)(*arg1)->Snap(arg2,arg3);
92994     } catch (std::out_of_range& e) {
92995       {
92996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92997       };
92998     } catch (std::exception& e) {
92999       {
93000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93001       };
93002     } catch (...) {
93003       {
93004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93005       };
93006     }
93007   }
93008   jresult = result;
93009   return jresult;
93010 }
93011
93012
93013 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
93014   float jresult ;
93015   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93016   float arg2 ;
93017   float result;
93018
93019   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93020   arg2 = (float)jarg2;
93021   {
93022     try {
93023       result = (float)(*arg1)->Snap(arg2);
93024     } catch (std::out_of_range& e) {
93025       {
93026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93027       };
93028     } catch (std::exception& e) {
93029       {
93030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93031       };
93032     } catch (...) {
93033       {
93034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93035       };
93036     }
93037   }
93038   jresult = result;
93039   return jresult;
93040 }
93041
93042
93043 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
93044   float jresult ;
93045   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93046   unsigned int arg2 ;
93047   unsigned int *arg3 = 0 ;
93048   bool arg4 ;
93049   float result;
93050
93051   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93052   arg2 = (unsigned int)jarg2;
93053   arg3 = (unsigned int *)jarg3;
93054   arg4 = jarg4 ? true : false;
93055   {
93056     try {
93057       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
93058     } catch (std::out_of_range& e) {
93059       {
93060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93061       };
93062     } catch (std::exception& e) {
93063       {
93064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93065       };
93066     } catch (...) {
93067       {
93068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93069       };
93070     }
93071   }
93072   jresult = result;
93073   return jresult;
93074 }
93075
93076
93077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
93078   unsigned int jresult ;
93079   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93080   float arg2 ;
93081   bool arg3 ;
93082   unsigned int result;
93083
93084   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93085   arg2 = (float)jarg2;
93086   arg3 = jarg3 ? true : false;
93087   {
93088     try {
93089       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
93090     } catch (std::out_of_range& e) {
93091       {
93092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93093       };
93094     } catch (std::exception& e) {
93095       {
93096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93097       };
93098     } catch (...) {
93099       {
93100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93101       };
93102     }
93103   }
93104   jresult = result;
93105   return jresult;
93106 }
93107
93108
93109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
93110   unsigned int jresult ;
93111   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93112   unsigned int result;
93113
93114   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93115   {
93116     try {
93117       result = (unsigned int)(*arg1)->GetTotalPages();
93118     } catch (std::out_of_range& e) {
93119       {
93120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93121       };
93122     } catch (std::exception& e) {
93123       {
93124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93125       };
93126     } catch (...) {
93127       {
93128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93129       };
93130     }
93131   }
93132   jresult = result;
93133   return jresult;
93134 }
93135
93136
93137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
93138   int jresult ;
93139   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93140   Dali::Toolkit::Ruler::RulerType result;
93141
93142   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93143   {
93144     try {
93145       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
93146     } catch (std::out_of_range& e) {
93147       {
93148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93149       };
93150     } catch (std::exception& e) {
93151       {
93152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93153       };
93154     } catch (...) {
93155       {
93156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93157       };
93158     }
93159   }
93160   jresult = (int)result;
93161   return jresult;
93162 }
93163
93164
93165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
93166   unsigned int jresult ;
93167   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93168   bool result;
93169
93170   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93171   {
93172     try {
93173       result = (bool)(*arg1)->IsEnabled();
93174     } catch (std::out_of_range& e) {
93175       {
93176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93177       };
93178     } catch (std::exception& e) {
93179       {
93180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93181       };
93182     } catch (...) {
93183       {
93184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93185       };
93186     }
93187   }
93188   jresult = result;
93189   return jresult;
93190 }
93191
93192
93193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
93194   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93195
93196   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93197   {
93198     try {
93199       (*arg1)->Enable();
93200     } catch (std::out_of_range& e) {
93201       {
93202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93203       };
93204     } catch (std::exception& e) {
93205       {
93206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93207       };
93208     } catch (...) {
93209       {
93210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93211       };
93212     }
93213   }
93214 }
93215
93216
93217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
93218   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93219
93220   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93221   {
93222     try {
93223       (*arg1)->Disable();
93224     } catch (std::out_of_range& e) {
93225       {
93226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93227       };
93228     } catch (std::exception& e) {
93229       {
93230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93231       };
93232     } catch (...) {
93233       {
93234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93235       };
93236     }
93237   }
93238 }
93239
93240
93241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
93242   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93243   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
93244   Dali::Toolkit::RulerDomain *argp2 ;
93245
93246   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93247   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
93248   if (!argp2) {
93249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
93250     return ;
93251   }
93252   arg2 = *argp2;
93253   {
93254     try {
93255       (*arg1)->SetDomain(arg2);
93256     } catch (std::out_of_range& e) {
93257       {
93258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93259       };
93260     } catch (std::exception& e) {
93261       {
93262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93263       };
93264     } catch (...) {
93265       {
93266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93267       };
93268     }
93269   }
93270 }
93271
93272
93273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
93274   void * jresult ;
93275   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93276   Dali::Toolkit::RulerDomain *result = 0 ;
93277
93278   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93279   {
93280     try {
93281       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
93282     } catch (std::out_of_range& e) {
93283       {
93284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93285       };
93286     } catch (std::exception& e) {
93287       {
93288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93289       };
93290     } catch (...) {
93291       {
93292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93293       };
93294     }
93295   }
93296   jresult = (void *)result;
93297   return jresult;
93298 }
93299
93300
93301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
93302   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93303
93304   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93305   {
93306     try {
93307       (*arg1)->DisableDomain();
93308     } catch (std::out_of_range& e) {
93309       {
93310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93311       };
93312     } catch (std::exception& e) {
93313       {
93314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93315       };
93316     } catch (...) {
93317       {
93318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93319       };
93320     }
93321   }
93322 }
93323
93324
93325 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
93326   float jresult ;
93327   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93328   float arg2 ;
93329   float arg3 ;
93330   float arg4 ;
93331   float result;
93332
93333   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93334   arg2 = (float)jarg2;
93335   arg3 = (float)jarg3;
93336   arg4 = (float)jarg4;
93337   {
93338     try {
93339       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
93340     } catch (std::out_of_range& e) {
93341       {
93342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93343       };
93344     } catch (std::exception& e) {
93345       {
93346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93347       };
93348     } catch (...) {
93349       {
93350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93351       };
93352     }
93353   }
93354   jresult = result;
93355   return jresult;
93356 }
93357
93358
93359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
93360   float jresult ;
93361   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93362   float arg2 ;
93363   float arg3 ;
93364   float result;
93365
93366   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93367   arg2 = (float)jarg2;
93368   arg3 = (float)jarg3;
93369   {
93370     try {
93371       result = (float)(*arg1)->Clamp(arg2,arg3);
93372     } catch (std::out_of_range& e) {
93373       {
93374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93375       };
93376     } catch (std::exception& e) {
93377       {
93378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93379       };
93380     } catch (...) {
93381       {
93382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93383       };
93384     }
93385   }
93386   jresult = result;
93387   return jresult;
93388 }
93389
93390
93391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
93392   float jresult ;
93393   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93394   float arg2 ;
93395   float result;
93396
93397   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93398   arg2 = (float)jarg2;
93399   {
93400     try {
93401       result = (float)(*arg1)->Clamp(arg2);
93402     } catch (std::out_of_range& e) {
93403       {
93404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93405       };
93406     } catch (std::exception& e) {
93407       {
93408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93409       };
93410     } catch (...) {
93411       {
93412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93413       };
93414     }
93415   }
93416   jresult = result;
93417   return jresult;
93418 }
93419
93420
93421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
93422   float jresult ;
93423   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93424   float arg2 ;
93425   float arg3 ;
93426   float arg4 ;
93427   Dali::Toolkit::ClampState *arg5 = 0 ;
93428   float result;
93429
93430   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93431   arg2 = (float)jarg2;
93432   arg3 = (float)jarg3;
93433   arg4 = (float)jarg4;
93434   arg5 = (Dali::Toolkit::ClampState *)jarg5;
93435   if (!arg5) {
93436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93437     return 0;
93438   }
93439   {
93440     try {
93441       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
93442     } catch (std::out_of_range& e) {
93443       {
93444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93445       };
93446     } catch (std::exception& e) {
93447       {
93448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93449       };
93450     } catch (...) {
93451       {
93452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93453       };
93454     }
93455   }
93456   jresult = result;
93457   return jresult;
93458 }
93459
93460
93461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
93462   float jresult ;
93463   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93464   float arg2 ;
93465   float arg3 ;
93466   float arg4 ;
93467   float arg5 ;
93468   float result;
93469
93470   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93471   arg2 = (float)jarg2;
93472   arg3 = (float)jarg3;
93473   arg4 = (float)jarg4;
93474   arg5 = (float)jarg5;
93475   {
93476     try {
93477       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
93478     } catch (std::out_of_range& e) {
93479       {
93480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93481       };
93482     } catch (std::exception& e) {
93483       {
93484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93485       };
93486     } catch (...) {
93487       {
93488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93489       };
93490     }
93491   }
93492   jresult = result;
93493   return jresult;
93494 }
93495
93496
93497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
93498   float jresult ;
93499   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93500   float arg2 ;
93501   float arg3 ;
93502   float arg4 ;
93503   float result;
93504
93505   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93506   arg2 = (float)jarg2;
93507   arg3 = (float)jarg3;
93508   arg4 = (float)jarg4;
93509   {
93510     try {
93511       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
93512     } catch (std::out_of_range& e) {
93513       {
93514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93515       };
93516     } catch (std::exception& e) {
93517       {
93518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93519       };
93520     } catch (...) {
93521       {
93522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93523       };
93524     }
93525   }
93526   jresult = result;
93527   return jresult;
93528 }
93529
93530
93531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
93532   float jresult ;
93533   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93534   float arg2 ;
93535   float arg3 ;
93536   float result;
93537
93538   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93539   arg2 = (float)jarg2;
93540   arg3 = (float)jarg3;
93541   {
93542     try {
93543       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
93544     } catch (std::out_of_range& e) {
93545       {
93546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93547       };
93548     } catch (std::exception& e) {
93549       {
93550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93551       };
93552     } catch (...) {
93553       {
93554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93555       };
93556     }
93557   }
93558   jresult = result;
93559   return jresult;
93560 }
93561
93562
93563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
93564   float jresult ;
93565   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93566   float arg2 ;
93567   float result;
93568
93569   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93570   arg2 = (float)jarg2;
93571   {
93572     try {
93573       result = (float)(*arg1)->SnapAndClamp(arg2);
93574     } catch (std::out_of_range& e) {
93575       {
93576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93577       };
93578     } catch (std::exception& e) {
93579       {
93580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93581       };
93582     } catch (...) {
93583       {
93584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93585       };
93586     }
93587   }
93588   jresult = result;
93589   return jresult;
93590 }
93591
93592
93593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
93594   float jresult ;
93595   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93596   float arg2 ;
93597   float arg3 ;
93598   float arg4 ;
93599   float arg5 ;
93600   Dali::Toolkit::ClampState *arg6 = 0 ;
93601   float result;
93602
93603   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93604   arg2 = (float)jarg2;
93605   arg3 = (float)jarg3;
93606   arg4 = (float)jarg4;
93607   arg5 = (float)jarg5;
93608   arg6 = (Dali::Toolkit::ClampState *)jarg6;
93609   if (!arg6) {
93610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
93611     return 0;
93612   }
93613   {
93614     try {
93615       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
93616     } catch (std::out_of_range& e) {
93617       {
93618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93619       };
93620     } catch (std::exception& e) {
93621       {
93622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93623       };
93624     } catch (...) {
93625       {
93626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93627       };
93628     }
93629   }
93630   jresult = result;
93631   return jresult;
93632 }
93633
93634
93635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
93636   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93637
93638   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93639   {
93640     try {
93641       (*arg1)->Reference();
93642     } catch (std::out_of_range& e) {
93643       {
93644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93645       };
93646     } catch (std::exception& e) {
93647       {
93648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93649       };
93650     } catch (...) {
93651       {
93652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93653       };
93654     }
93655   }
93656 }
93657
93658
93659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
93660   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93661
93662   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93663   {
93664     try {
93665       (*arg1)->Unreference();
93666     } catch (std::out_of_range& e) {
93667       {
93668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93669       };
93670     } catch (std::exception& e) {
93671       {
93672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93673       };
93674     } catch (...) {
93675       {
93676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93677       };
93678     }
93679   }
93680 }
93681
93682
93683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
93684   int jresult ;
93685   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93686   int result;
93687
93688   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93689   {
93690     try {
93691       result = (int)(*arg1)->ReferenceCount();
93692     } catch (std::out_of_range& e) {
93693       {
93694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93695       };
93696     } catch (std::exception& e) {
93697       {
93698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93699       };
93700     } catch (...) {
93701       {
93702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93703       };
93704     }
93705   }
93706   jresult = result;
93707   return jresult;
93708 }
93709
93710
93711 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
93712     return (Dali::RefObject *)jarg1;
93713 }
93714
93715 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
93716     return (Dali::SignalObserver *)jarg1;
93717 }
93718
93719 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
93720     return (Dali::ConnectionTrackerInterface *)jarg1;
93721 }
93722
93723 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
93724     return (Dali::BaseHandle *)jarg1;
93725 }
93726
93727 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
93728     return (Dali::BaseHandle *)jarg1;
93729 }
93730
93731 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
93732     return (Dali::BaseHandle *)jarg1;
93733 }
93734
93735 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
93736     return (Dali::BaseHandle *)jarg1;
93737 }
93738
93739 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
93740     return (Dali::BaseHandle *)jarg1;
93741 }
93742
93743 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
93744     return (Dali::BaseHandle *)jarg1;
93745 }
93746
93747 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
93748     return (Dali::BaseHandle *)jarg1;
93749 }
93750
93751 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
93752     return (Dali::BaseHandle *)jarg1;
93753 }
93754
93755 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
93756     return (Dali::BaseHandle *)jarg1;
93757 }
93758
93759 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
93760     return (Dali::BaseHandle *)jarg1;
93761 }
93762
93763 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
93764     return (Dali::BaseHandle *)jarg1;
93765 }
93766
93767 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
93768     return (Dali::BaseHandle *)jarg1;
93769 }
93770
93771 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
93772     return (Dali::BaseHandle *)jarg1;
93773 }
93774
93775 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
93776     return (Dali::Handle *)jarg1;
93777 }
93778
93779 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
93780     return (Dali::Handle *)jarg1;
93781 }
93782
93783 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
93784     return (Dali::BaseHandle *)jarg1;
93785 }
93786
93787 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
93788     return (Dali::BaseHandle *)jarg1;
93789 }
93790
93791 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
93792     return (Dali::Handle *)jarg1;
93793 }
93794
93795 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
93796     return (Dali::BaseHandle *)jarg1;
93797 }
93798
93799 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
93800     return (Dali::Handle *)jarg1;
93801 }
93802
93803 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
93804     return (Dali::GestureDetector *)jarg1;
93805 }
93806
93807 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
93808     return (Dali::Gesture *)jarg1;
93809 }
93810
93811 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
93812     return (Dali::Handle *)jarg1;
93813 }
93814
93815 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
93816     return (Dali::Actor *)jarg1;
93817 }
93818
93819 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
93820     return (Dali::BaseHandle *)jarg1;
93821 }
93822
93823 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
93824     return (Dali::RefObject *)jarg1;
93825 }
93826
93827 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
93828     return (Dali::Actor *)jarg1;
93829 }
93830
93831 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
93832     return (Dali::GestureDetector *)jarg1;
93833 }
93834
93835 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
93836     return (Dali::Gesture *)jarg1;
93837 }
93838
93839 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
93840     return (Dali::GestureDetector *)jarg1;
93841 }
93842
93843 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
93844     return (Dali::Gesture *)jarg1;
93845 }
93846
93847 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
93848     return (Dali::GestureDetector *)jarg1;
93849 }
93850
93851 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
93852     return (Dali::Gesture *)jarg1;
93853 }
93854
93855 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
93856     return (Dali::BaseHandle *)jarg1;
93857 }
93858
93859 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
93860     return (Dali::Handle *)jarg1;
93861 }
93862
93863 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
93864     return (Dali::BaseHandle *)jarg1;
93865 }
93866
93867 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
93868     return (Dali::Handle *)jarg1;
93869 }
93870
93871 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
93872     return (Dali::Handle *)jarg1;
93873 }
93874
93875 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
93876     return (Dali::Image *)jarg1;
93877 }
93878
93879 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
93880     return (Dali::Image *)jarg1;
93881 }
93882
93883 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
93884     return (Dali::Image *)jarg1;
93885 }
93886
93887 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
93888     return (Dali::RefObject *)jarg1;
93889 }
93890
93891 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
93892     return (Dali::Image *)jarg1;
93893 }
93894
93895 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
93896     return (Dali::Image *)jarg1;
93897 }
93898
93899 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
93900     return (Dali::ResourceImage *)jarg1;
93901 }
93902
93903 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
93904     return (Dali::Actor *)jarg1;
93905 }
93906
93907 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
93908     return (Dali::BaseHandle *)jarg1;
93909 }
93910
93911 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
93912     return (Dali::BaseHandle *)jarg1;
93913 }
93914
93915 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
93916     return (Dali::BaseHandle *)jarg1;
93917 }
93918
93919 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
93920     return (Dali::BaseHandle *)jarg1;
93921 }
93922
93923 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
93924     return (Dali::BaseHandle *)jarg1;
93925 }
93926
93927 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
93928     return (Dali::BaseHandle *)jarg1;
93929 }
93930
93931 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
93932     return (Dali::CustomActorImpl *)jarg1;
93933 }
93934
93935 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
93936     return (Dali::CustomActor *)jarg1;
93937 }
93938
93939 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
93940     return (Dali::BaseHandle *)jarg1;
93941 }
93942
93943 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
93944     return (Dali::Toolkit::Control *)jarg1;
93945 }
93946
93947 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
93948     return (Dali::Toolkit::Control *)jarg1;
93949 }
93950
93951 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
93952     return (Dali::Toolkit::Button *)jarg1;
93953 }
93954
93955 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
93956     return (Dali::Toolkit::Button *)jarg1;
93957 }
93958
93959 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
93960     return (Dali::Toolkit::Button *)jarg1;
93961 }
93962
93963 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
93964     return (Dali::Toolkit::Control *)jarg1;
93965 }
93966
93967 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
93968     return (Dali::Toolkit::Control *)jarg1;
93969 }
93970
93971 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
93972     return (Dali::Toolkit::Control *)jarg1;
93973 }
93974
93975 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
93976     return (Dali::Toolkit::Control *)jarg1;
93977 }
93978
93979 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
93980     return (Dali::Toolkit::Control *)jarg1;
93981 }
93982
93983 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
93984     return (Dali::RefObject *)jarg1;
93985 }
93986
93987 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
93988     return (Dali::Toolkit::Scrollable *)jarg1;
93989 }
93990
93991 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
93992     return (Dali::BaseHandle *)jarg1;
93993 }
93994
93995 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
93996     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
93997 }
93998
93999 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
94000     return (Dali::RefObject *)jarg1;
94001 }
94002
94003 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
94004     return (Dali::Toolkit::Ruler *)jarg1;
94005 }
94006
94007 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
94008     return (Dali::Toolkit::Ruler *)jarg1;
94009 }
94010
94011 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
94012     return (Dali::Toolkit::Scrollable *)jarg1;
94013 }
94014
94015 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
94016     return (Dali::Toolkit::Control *)jarg1;
94017 }
94018
94019 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
94020     return (Dali::Toolkit::Control *)jarg1;
94021 }
94022
94023 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
94024     return (Dali::Toolkit::Control *)jarg1;
94025 }
94026
94027 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
94028     return (Dali::Toolkit::Control *)jarg1;
94029 }
94030
94031 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
94032     return (Dali::BaseHandle *)jarg1;
94033 }
94034
94035 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
94036     return (Dali::BaseHandle *)jarg1;
94037 }
94038
94039 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
94040     return (Dali::Toolkit::Control *)jarg1;
94041 }
94042
94043 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
94044     return (Dali::Toolkit::Control *)jarg1;
94045 }
94046
94047 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
94048     return (Dali::Toolkit::Control *)jarg1;
94049 }
94050
94051 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
94052     return (Dali::Toolkit::Control *)jarg1;
94053 }
94054
94055 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
94056     return (Dali::Toolkit::Control *)jarg1;
94057 }
94058
94059 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
94060     return (Dali::Toolkit::Control *)jarg1;
94061 }
94062
94063 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
94064     return (Dali::Toolkit::PageTurnView *)jarg1;
94065 }
94066
94067 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
94068     return (Dali::Toolkit::PageTurnView *)jarg1;
94069 }
94070
94071 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
94072     return (Dali::Toolkit::Button *)jarg1;
94073 }
94074
94075 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
94076     return (Dali::BaseHandle *)jarg1;
94077 }
94078
94079 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
94080     return (Dali::BaseHandle *)jarg1;
94081 }
94082
94083 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
94084     return (Dali::BaseHandle *)jarg1;
94085 }
94086
94087 #ifdef __cplusplus
94088 }
94089 #endif
94090