dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 208   { SWIG_CSharpApplicationException, NULL },
 209   { SWIG_CSharpArithmeticException, NULL },
 210   { SWIG_CSharpDivideByZeroException, NULL },
 211   { SWIG_CSharpIndexOutOfRangeException, NULL },
 212   { SWIG_CSharpInvalidCastException, NULL },
 213   { SWIG_CSharpInvalidOperationException, NULL },
 214   { SWIG_CSharpIOException, NULL },
 215   { SWIG_CSharpNullReferenceException, NULL },
 216   { SWIG_CSharpOutOfMemoryException, NULL },
 217   { SWIG_CSharpOverflowException, NULL },
 218   { SWIG_CSharpSystemException, NULL }
 219 };
 220
 221 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 228   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 229   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 230     callback = SWIG_csharp_exceptions[code].callback;
 231   }
 232   callback(msg);
 233 }
 234
 235 static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 236   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 237   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 238     callback = SWIG_csharp_exceptions_argument[code].callback;
 239   }
 240   callback(msg, param_name);
 241 }
 242
 243
 244 #ifdef __cplusplus
 245 extern "C"
 246 #endif
 247 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 248                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 249                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 250                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 251                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 252                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 253                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 254                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 255                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 256                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 257                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 258                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 259   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 267   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 268   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 269   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 270 }
 271
 272 #ifdef __cplusplus
 273 extern "C"
 274 #endif
 275 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 276                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 277                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 278                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 279   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 280   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 281   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 282 }
 283
 284
 285 /* Callback for returning strings to C# without leaking memory */
 286 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 287 static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 288
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427
 428 #include <dali/public-api/math/matrix.h>
 429 #include <dali/public-api/math/matrix3.h>
 430 #include <dali/public-api/math/viewport.h>
 431 #include <dali/public-api/object/property-key.h>
 432 #include <dali/devel-api/object/csharp-type-info.h>
 433 #include <dali/devel-api/object/csharp-type-registry.h>
 434
 435 #include <dali/public-api/adaptor-framework/timer.h>
 436 #include <dali/public-api/adaptor-framework/window.h>
 437 #include <dali/public-api/adaptor-framework/style-change.h>
 438 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 439 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 440 #include <dali/devel-api/adaptor-framework/window-devel.h>
 441
 442 #include <dali/devel-api/images/nine-patch-image.h>
 443
 444 #include <dali-toolkit/devel-api/builder/builder.h>
 445
 446 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 447 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 448
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 451 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 456 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 457
 458 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 459 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 460 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 461
 462 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 463
 464 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 465
 466 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 467
 468 // add here SWIG version check
 469
 470 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 471 // disable Swig-dependent warnings
 472
 473 // 'identifier1' has C-linkage specified,
 474 // but returns UDT 'identifier2' which is incompatible with C
 475 #pragma warning(disable: 4190)
 476
 477 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 478 #pragma warning(disable: 4800)
 479
 480 // debug info too long etc etc
 481 #pragma warning(disable: 4786)
 482 #endif
 483
 484
 485 #include <stdexcept>
 486
 487
 488 #include <string>
 489
 490
 491 #include <vector>
 492 #include <algorithm>
 493 #include <stdexcept>
 494
 495
 496 #include <map>
 497 #include <algorithm>
 498 #include <stdexcept>
 499
 500
 501 #include <utility>
 502
 503
 504 typedef float floatp;
 505
 506 SWIGINTERN floatp *new_floatp(){
 507   return new float();
 508 }
 509 SWIGINTERN void delete_floatp(floatp *self){
 510   if (self) delete self;
 511 }
 512 SWIGINTERN void floatp_assign(floatp *self,float value){
 513   *self = value;
 514 }
 515 SWIGINTERN float floatp_value(floatp *self){
 516   return *self;
 517 }
 518 SWIGINTERN float *floatp_cast(floatp *self){
 519   return self;
 520 }
 521 SWIGINTERN floatp *floatp_frompointer(float *t){
 522   return (floatp *) t;
 523 }
 524
 525 typedef int intp;
 526
 527 SWIGINTERN intp *new_intp(){
 528   return new int();
 529 }
 530 SWIGINTERN void delete_intp(intp *self){
 531   if (self) delete self;
 532 }
 533 SWIGINTERN void intp_assign(intp *self,int value){
 534   *self = value;
 535 }
 536 SWIGINTERN int intp_value(intp *self){
 537   return *self;
 538 }
 539 SWIGINTERN int *intp_cast(intp *self){
 540   return self;
 541 }
 542 SWIGINTERN intp *intp_frompointer(int *t){
 543   return (intp *) t;
 544 }
 545
 546 typedef double doublep;
 547
 548 SWIGINTERN doublep *new_doublep(){
 549   return new double();
 550 }
 551 SWIGINTERN void delete_doublep(doublep *self){
 552   if (self) delete self;
 553 }
 554 SWIGINTERN void doublep_assign(doublep *self,double value){
 555   *self = value;
 556 }
 557 SWIGINTERN double doublep_value(doublep *self){
 558   return *self;
 559 }
 560 SWIGINTERN double *doublep_cast(doublep *self){
 561   return self;
 562 }
 563 SWIGINTERN doublep *doublep_frompointer(double *t){
 564   return (doublep *) t;
 565 }
 566
 567 typedef unsigned int uintp;
 568
 569 SWIGINTERN uintp *new_uintp(){
 570   return new unsigned int();
 571 }
 572 SWIGINTERN void delete_uintp(uintp *self){
 573   if (self) delete self;
 574 }
 575 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 576   *self = value;
 577 }
 578 SWIGINTERN unsigned int uintp_value(uintp *self){
 579   return *self;
 580 }
 581 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 582   return self;
 583 }
 584 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 585   return (uintp *) t;
 586 }
 587
 588 typedef unsigned short ushortp;
 589
 590 SWIGINTERN ushortp *new_ushortp(){
 591   return new unsigned short();
 592 }
 593 SWIGINTERN void delete_ushortp(ushortp *self){
 594   if (self) delete self;
 595 }
 596 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 597   *self = value;
 598 }
 599 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 600   return *self;
 601 }
 602 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 603   return self;
 604 }
 605 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 606   return (ushortp *) t;
 607 }
 608
 609 unsigned int int_to_uint(int x) {
 610    return (unsigned int) x;
 611 }
 612
 613
 614 using namespace Dali;
 615 using namespace Dali::Toolkit;
 616
 617 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 618
 619      // C++ code. DALi uses Handle <-> Body design pattern.
 620      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 621      // Handles in DALi can be converted into a boolean type
 622      // to check if the handle has a valid body attached to it.
 623      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 624      if( *self )
 625      {
 626        return true;
 627      }
 628      else
 629      {
 630        return false;
 631      }
 632     }
 633 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 634
 635      // C++ code. Check if two handles reference the same implemtion
 636      if( *self == rhs)
 637      {
 638        return true;
 639      }
 640      else
 641      {
 642        return false;
 643      }
 644     }
 645 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 646      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 647    }
 648 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){
 649      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 650    }
 651 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 652         std::vector< Dali::TouchPoint >* pv = 0;
 653         if (capacity >= 0) {
 654           pv = new std::vector< Dali::TouchPoint >();
 655           pv->reserve(capacity);
 656        } else {
 657           throw std::out_of_range("capacity");
 658        }
 659        return pv;
 660       }
 661 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 662         if (index>=0 && index<(int)self->size())
 663           return (*self)[index];
 664         else
 665           throw std::out_of_range("index");
 666       }
 667 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 668         if (index>=0 && index<(int)self->size())
 669           return (*self)[index];
 670         else
 671           throw std::out_of_range("index");
 672       }
 673 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 674         if (index>=0 && index<(int)self->size())
 675           (*self)[index] = val;
 676         else
 677           throw std::out_of_range("index");
 678       }
 679 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 680         self->insert(self->end(), values.begin(), values.end());
 681       }
 682 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 683         if (index < 0)
 684           throw std::out_of_range("index");
 685         if (count < 0)
 686           throw std::out_of_range("count");
 687         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 688           throw std::invalid_argument("invalid range");
 689         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 690       }
 691 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 692         if (index>=0 && index<(int)self->size()+1)
 693           self->insert(self->begin()+index, x);
 694         else
 695           throw std::out_of_range("index");
 696       }
 697 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 698         if (index>=0 && index<(int)self->size()+1)
 699           self->insert(self->begin()+index, values.begin(), values.end());
 700         else
 701           throw std::out_of_range("index");
 702       }
 703 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 704         if (index>=0 && index<(int)self->size())
 705           self->erase(self->begin() + index);
 706         else
 707           throw std::out_of_range("index");
 708       }
 709 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 710         if (index < 0)
 711           throw std::out_of_range("index");
 712         if (count < 0)
 713           throw std::out_of_range("count");
 714         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 715           throw std::invalid_argument("invalid range");
 716         self->erase(self->begin()+index, self->begin()+index+count);
 717       }
 718 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 719         if (count < 0)
 720           throw std::out_of_range("count");
 721         return new std::vector< Dali::TouchPoint >(count, value);
 722       }
 723 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 724         std::reverse(self->begin(), self->end());
 725       }
 726 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 727         if (index < 0)
 728           throw std::out_of_range("index");
 729         if (count < 0)
 730           throw std::out_of_range("count");
 731         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 732           throw std::invalid_argument("invalid range");
 733         std::reverse(self->begin()+index, self->begin()+index+count);
 734       }
 735 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 736         if (index < 0)
 737           throw std::out_of_range("index");
 738         if (index+values.size() > self->size())
 739           throw std::out_of_range("index");
 740         std::copy(values.begin(), values.end(), self->begin()+index);
 741       }
 742 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 743          return self->Empty();
 744       }
 745 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 746         return self->GetConnectionCount();
 747       }
 748 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 749           self->Connect( func );
 750       }
 751 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 752           self->Disconnect( func );
 753       }
 754 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 755           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 756 /*@SWIG@*/ self->Emit( arg );
 757       }
 758 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 759          return self->Empty();
 760       }
 761 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 762         return self->GetConnectionCount();
 763       }
 764 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 765           self->Connect( func );
 766       }
 767 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 768           self->Disconnect( func );
 769       }
 770 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 771           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 772 /*@SWIG@*/ self->Emit( arg );
 773       }
 774 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 775          return self->Empty();
 776       }
 777 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){
 778         return self->GetConnectionCount();
 779       }
 780 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 *)){
 781           self->Connect( func );
 782       }
 783 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 *)){
 784           self->Disconnect( func );
 785       }
 786 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){
 787           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 788 /*@SWIG@*/ self->Emit( arg );
 789       }
 790 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 791          return self->Empty();
 792       }
 793 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 794         return self->GetConnectionCount();
 795       }
 796 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 797           self->Connect( func );
 798       }
 799 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 800           self->Disconnect( func );
 801       }
 802 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 803           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 804 /*@SWIG@*/ self->Emit( arg );
 805       }
 806 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 807          return self->Empty();
 808       }
 809 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 810         return self->GetConnectionCount();
 811       }
 812 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 813           self->Connect( func );
 814       }
 815 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 816           self->Disconnect( func );
 817       }
 818 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 819           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 820 /*@SWIG@*/ self->Emit( arg );
 821       }
 822 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){
 823          return self->Empty();
 824       }
 825 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){
 826         return self->GetConnectionCount();
 827       }
 828 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 &)){
 829         self->Connect( func );
 830       }
 831 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 &)){
 832         self->Disconnect( func );
 833       }
 834 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){
 835         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 836 /*@SWIG@*/ self->Emit( arg1, arg2 );
 837       }
 838 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){
 839          return self->Empty();
 840       }
 841 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){
 842         return self->GetConnectionCount();
 843       }
 844 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 &)){
 845         self->Connect( func );
 846       }
 847 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 &)){
 848         self->Disconnect( func );
 849       }
 850 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){
 851         return self->Emit( arg1, arg2 );
 852       }
 853 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){
 854          return self->Empty();
 855       }
 856 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){
 857         return self->GetConnectionCount();
 858       }
 859 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 &)){
 860         self->Connect( func );
 861       }
 862 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 &)){
 863         self->Disconnect( func );
 864       }
 865 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){
 866         return self->Emit( arg1, arg2 );
 867       }
 868 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){
 869          return self->Empty();
 870       }
 871 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){
 872         return self->GetConnectionCount();
 873       }
 874 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 &)){
 875         self->Connect( func );
 876       }
 877 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 &)){
 878         self->Disconnect( func );
 879       }
 880 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){
 881         return self->Emit( arg1, arg2 );
 882       }
 883 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 884          return self->Empty();
 885       }
 886 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 887         return self->GetConnectionCount();
 888       }
 889 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 890           self->Connect( func );
 891       }
 892 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 893           self->Disconnect( func );
 894       }
 895 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 896           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 897 /*@SWIG@*/ self->Emit( arg );
 898       }
 899 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 900          return self->Empty();
 901       }
 902 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){
 903         return self->GetConnectionCount();
 904       }
 905 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 &)){
 906           self->Connect( func );
 907       }
 908 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 &)){
 909           self->Disconnect( func );
 910       }
 911 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){
 912           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 913 /*@SWIG@*/ self->Emit( arg );
 914       }
 915 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 916          return self->Empty();
 917       }
 918 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){
 919         return self->GetConnectionCount();
 920       }
 921 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 &)){
 922           self->Connect( func );
 923       }
 924 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 &)){
 925           self->Disconnect( func );
 926       }
 927 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){
 928           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 929 /*@SWIG@*/ self->Emit( arg );
 930       }
 931 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 932          return self->Empty();
 933       }
 934 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){
 935         return self->GetConnectionCount();
 936       }
 937 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 &)){
 938           self->Connect( func );
 939       }
 940 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 &)){
 941           self->Disconnect( func );
 942       }
 943 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){
 944           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 945 /*@SWIG@*/ self->Emit( arg );
 946       }
 947 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){
 948          return self->Empty();
 949       }
 950 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){
 951         return self->GetConnectionCount();
 952       }
 953 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 &)){
 954         self->Connect( func );
 955       }
 956 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 &)){
 957         self->Disconnect( func );
 958       }
 959 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){
 960         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 961 /*@SWIG@*/ self->Emit( arg1, arg2 );
 962       }
 963 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){
 964          return self->Empty();
 965       }
 966 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){
 967         return self->GetConnectionCount();
 968       }
 969 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 &)){
 970         self->Connect( func );
 971       }
 972 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 &)){
 973         self->Disconnect( func );
 974       }
 975 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){
 976         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 977 /*@SWIG@*/ self->Emit( arg1, arg2 );
 978       }
 979 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){
 980          return self->Empty();
 981       }
 982 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){
 983         return self->GetConnectionCount();
 984       }
 985 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 &)){
 986         self->Connect( func );
 987       }
 988 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 &)){
 989         self->Disconnect( func );
 990       }
 991 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){
 992         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 993 /*@SWIG@*/ self->Emit( arg1, arg2 );
 994       }
 995 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
 996          return self->Empty();
 997       }
 998 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
 999         return self->GetConnectionCount();
1000       }
1001 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1002           self->Connect( func );
1003       }
1004 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1005           self->Disconnect( func );
1006       }
1007 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1008           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1009 /*@SWIG@*/ self->Emit( arg );
1010       }
1011 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1012          return self->Empty();
1013       }
1014 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1015         return self->GetConnectionCount();
1016       }
1017 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1018           self->Connect( func );
1019       }
1020 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1021           self->Disconnect( func );
1022       }
1023 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1024           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1025 /*@SWIG@*/ self->Emit( arg );
1026       }
1027
1028   // keep argcs and argv so they're always available to DALi
1029   int argC = 1;
1030   char **argV = NULL;
1031
1032 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1033          return self->Empty();
1034       }
1035 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1036         return self->GetConnectionCount();
1037       }
1038 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1039           self->Connect( func );
1040       }
1041 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1042           self->Disconnect( func );
1043       }
1044 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1045           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1046 /*@SWIG@*/ self->Emit( arg );
1047       }
1048 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1049          return self->Empty();
1050       }
1051 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){
1052         return self->GetConnectionCount();
1053       }
1054 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 *)){
1055         self->Connect( func );
1056       }
1057 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 *)){
1058         self->Disconnect( func );
1059       }
1060 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){
1061         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1062 /*@SWIG@*/ self->Emit( arg1, arg2 );
1063       }
1064 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1065          return self->Empty();
1066       }
1067 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1068         return self->GetConnectionCount();
1069       }
1070 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1071           self->Connect( func );
1072       }
1073 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1074           self->Disconnect( func );
1075       }
1076 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1077           return self->Emit();
1078       }
1079 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
1080          return self->Empty();
1081       }
1082 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
1083         return self->GetConnectionCount();
1084       }
1085 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1086           self->Connect( func );
1087       }
1088 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1089           self->Disconnect( func );
1090       }
1091 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
1092           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1093 /*@SWIG@*/ self->Emit( arg );
1094       }
1095 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1096         std::vector< unsigned int >* pv = 0;
1097         if (capacity >= 0) {
1098           pv = new std::vector< unsigned int >();
1099           pv->reserve(capacity);
1100        } else {
1101           throw std::out_of_range("capacity");
1102        }
1103        return pv;
1104       }
1105 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1106         if (index>=0 && index<(int)self->size())
1107           return (*self)[index];
1108         else
1109           throw std::out_of_range("index");
1110       }
1111 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1112         if (index>=0 && index<(int)self->size())
1113           return (*self)[index];
1114         else
1115           throw std::out_of_range("index");
1116       }
1117 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1118         if (index>=0 && index<(int)self->size())
1119           (*self)[index] = val;
1120         else
1121           throw std::out_of_range("index");
1122       }
1123 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1124         self->insert(self->end(), values.begin(), values.end());
1125       }
1126 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1127         if (index < 0)
1128           throw std::out_of_range("index");
1129         if (count < 0)
1130           throw std::out_of_range("count");
1131         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1132           throw std::invalid_argument("invalid range");
1133         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1134       }
1135 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1136         if (index>=0 && index<(int)self->size()+1)
1137           self->insert(self->begin()+index, x);
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1142         if (index>=0 && index<(int)self->size()+1)
1143           self->insert(self->begin()+index, values.begin(), values.end());
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1148         if (index>=0 && index<(int)self->size())
1149           self->erase(self->begin() + index);
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1154         if (index < 0)
1155           throw std::out_of_range("index");
1156         if (count < 0)
1157           throw std::out_of_range("count");
1158         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1159           throw std::invalid_argument("invalid range");
1160         self->erase(self->begin()+index, self->begin()+index+count);
1161       }
1162 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1163         if (count < 0)
1164           throw std::out_of_range("count");
1165         return new std::vector< unsigned int >(count, value);
1166       }
1167 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1168         std::reverse(self->begin(), self->end());
1169       }
1170 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1171         if (index < 0)
1172           throw std::out_of_range("index");
1173         if (count < 0)
1174           throw std::out_of_range("count");
1175         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1176           throw std::invalid_argument("invalid range");
1177         std::reverse(self->begin()+index, self->begin()+index+count);
1178       }
1179 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1180         if (index < 0)
1181           throw std::out_of_range("index");
1182         if (index+values.size() > self->size())
1183           throw std::out_of_range("index");
1184         std::copy(values.begin(), values.end(), self->begin()+index);
1185       }
1186 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1187         return std::find(self->begin(), self->end(), value) != self->end();
1188       }
1189 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1190         int index = -1;
1191         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1192         if (it != self->end())
1193           index = (int)(it - self->begin());
1194         return index;
1195       }
1196 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1197         int index = -1;
1198         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1199         if (rit != self->rend())
1200           index = (int)(self->rend() - 1 - rit);
1201         return index;
1202       }
1203 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1204         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1205         if (it != self->end()) {
1206           self->erase(it);
1207           return true;
1208         }
1209         return false;
1210       }
1211 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){
1212         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1213         if (capacity >= 0) {
1214           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1215           pv->reserve(capacity);
1216        } else {
1217           throw std::out_of_range("capacity");
1218        }
1219        return pv;
1220       }
1221 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){
1222         if (index>=0 && index<(int)self->size())
1223           return (*self)[index];
1224         else
1225           throw std::out_of_range("index");
1226       }
1227 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){
1228         if (index>=0 && index<(int)self->size())
1229           return (*self)[index];
1230         else
1231           throw std::out_of_range("index");
1232       }
1233 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){
1234         if (index>=0 && index<(int)self->size())
1235           (*self)[index] = val;
1236         else
1237           throw std::out_of_range("index");
1238       }
1239 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1240         self->insert(self->end(), values.begin(), values.end());
1241       }
1242 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){
1243         if (index < 0)
1244           throw std::out_of_range("index");
1245         if (count < 0)
1246           throw std::out_of_range("count");
1247         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1248           throw std::invalid_argument("invalid range");
1249         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1250       }
1251 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){
1252         if (index>=0 && index<(int)self->size()+1)
1253           self->insert(self->begin()+index, x);
1254         else
1255           throw std::out_of_range("index");
1256       }
1257 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){
1258         if (index>=0 && index<(int)self->size()+1)
1259           self->insert(self->begin()+index, values.begin(), values.end());
1260         else
1261           throw std::out_of_range("index");
1262       }
1263 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){
1264         if (index>=0 && index<(int)self->size())
1265           self->erase(self->begin() + index);
1266         else
1267           throw std::out_of_range("index");
1268       }
1269 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){
1270         if (index < 0)
1271           throw std::out_of_range("index");
1272         if (count < 0)
1273           throw std::out_of_range("count");
1274         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1275           throw std::invalid_argument("invalid range");
1276         self->erase(self->begin()+index, self->begin()+index+count);
1277       }
1278 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){
1279         if (count < 0)
1280           throw std::out_of_range("count");
1281         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1282       }
1283 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){
1284         std::reverse(self->begin(), self->end());
1285       }
1286 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){
1287         if (index < 0)
1288           throw std::out_of_range("index");
1289         if (count < 0)
1290           throw std::out_of_range("count");
1291         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1292           throw std::invalid_argument("invalid range");
1293         std::reverse(self->begin()+index, self->begin()+index+count);
1294       }
1295 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){
1296         if (index < 0)
1297           throw std::out_of_range("index");
1298         if (index+values.size() > self->size())
1299           throw std::out_of_range("index");
1300         std::copy(values.begin(), values.end(), self->begin()+index);
1301       }
1302 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1303         std::vector< Dali::Actor >* pv = 0;
1304         if (capacity >= 0) {
1305           pv = new std::vector< Dali::Actor >();
1306           pv->reserve(capacity);
1307        } else {
1308           throw std::out_of_range("capacity");
1309        }
1310        return pv;
1311       }
1312 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1313         if (index>=0 && index<(int)self->size())
1314           return (*self)[index];
1315         else
1316           throw std::out_of_range("index");
1317       }
1318 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1319         if (index>=0 && index<(int)self->size())
1320           return (*self)[index];
1321         else
1322           throw std::out_of_range("index");
1323       }
1324 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1325         if (index>=0 && index<(int)self->size())
1326           (*self)[index] = val;
1327         else
1328           throw std::out_of_range("index");
1329       }
1330 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1331         self->insert(self->end(), values.begin(), values.end());
1332       }
1333 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1334         if (index < 0)
1335           throw std::out_of_range("index");
1336         if (count < 0)
1337           throw std::out_of_range("count");
1338         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1339           throw std::invalid_argument("invalid range");
1340         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1341       }
1342 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1343         if (index>=0 && index<(int)self->size()+1)
1344           self->insert(self->begin()+index, x);
1345         else
1346           throw std::out_of_range("index");
1347       }
1348 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1349         if (index>=0 && index<(int)self->size()+1)
1350           self->insert(self->begin()+index, values.begin(), values.end());
1351         else
1352           throw std::out_of_range("index");
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1355         if (index>=0 && index<(int)self->size())
1356           self->erase(self->begin() + index);
1357         else
1358           throw std::out_of_range("index");
1359       }
1360 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1361         if (index < 0)
1362           throw std::out_of_range("index");
1363         if (count < 0)
1364           throw std::out_of_range("count");
1365         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1366           throw std::invalid_argument("invalid range");
1367         self->erase(self->begin()+index, self->begin()+index+count);
1368       }
1369 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1370         if (count < 0)
1371           throw std::out_of_range("count");
1372         return new std::vector< Dali::Actor >(count, value);
1373       }
1374 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1375         std::reverse(self->begin(), self->end());
1376       }
1377 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1378         if (index < 0)
1379           throw std::out_of_range("index");
1380         if (count < 0)
1381           throw std::out_of_range("count");
1382         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1383           throw std::invalid_argument("invalid range");
1384         std::reverse(self->begin()+index, self->begin()+index+count);
1385       }
1386 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1387         if (index < 0)
1388           throw std::out_of_range("index");
1389         if (index+values.size() > self->size())
1390           throw std::out_of_range("index");
1391         std::copy(values.begin(), values.end(), self->begin()+index);
1392       }
1393 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1394          return self->Empty();
1395       }
1396 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1397         return self->GetConnectionCount();
1398       }
1399 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 &)){
1400           self->Connect( func );
1401       }
1402 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 &)){
1403           self->Disconnect( func );
1404       }
1405 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){
1406           return self->Emit( arg );
1407       }
1408 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){
1409          return self->Empty();
1410       }
1411 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){
1412         return self->GetConnectionCount();
1413       }
1414 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)){
1415         self->Connect( func );
1416       }
1417 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)){
1418         self->Disconnect( func );
1419       }
1420 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){
1421         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1422 /*@SWIG@*/ self->Emit( arg1, arg2 );
1423       }
1424 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1425          return self->Empty();
1426       }
1427 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){
1428         return self->GetConnectionCount();
1429       }
1430 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)){
1431         self->Connect( func );
1432       }
1433 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)){
1434         self->Disconnect( func );
1435       }
1436 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){
1437         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1438 /*@SWIG@*/ self->Emit( arg1, arg2 );
1439       }
1440 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1441          return self->Empty();
1442       }
1443 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1444         return self->GetConnectionCount();
1445       }
1446 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)){
1447         self->Connect( func );
1448       }
1449 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)){
1450         self->Disconnect( func );
1451       }
1452 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){
1453         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1454 /*@SWIG@*/ self->Emit( arg1, arg2 );
1455       }
1456 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){
1457          return self->Empty();
1458       }
1459 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){
1460         return self->GetConnectionCount();
1461       }
1462 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)){
1463         self->Connect( func );
1464       }
1465 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)){
1466         self->Disconnect( func );
1467       }
1468 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){
1469         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1470 /*@SWIG@*/ self->Emit( arg1, arg2 );
1471       }
1472 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1473          return self->Empty();
1474       }
1475 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1476         return self->GetConnectionCount();
1477       }
1478 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)){
1479           self->Connect( func );
1480       }
1481 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)){
1482           self->Disconnect( func );
1483       }
1484 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1485           return self->Emit( arg );
1486       }
1487 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1488          return self->Empty();
1489       }
1490 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1491         return self->GetConnectionCount();
1492       }
1493 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)){
1494           self->Connect( func );
1495       }
1496 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)){
1497           self->Disconnect( func );
1498       }
1499 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1500           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1501 /*@SWIG@*/ self->Emit( arg );
1502       }
1503 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){
1504          return self->Empty();
1505       }
1506 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){
1507         return self->GetConnectionCount();
1508       }
1509 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)){
1510           return self->Connect( func );
1511       }
1512 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)){
1513           self->Disconnect( func );
1514       }
1515 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){
1516           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1517 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1518       }
1519 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1520          return self->Empty();
1521       }
1522 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1523         return self->GetConnectionCount();
1524       }
1525 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)){
1526           self->Connect( func );
1527       }
1528 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)){
1529           self->Disconnect( func );
1530       }
1531 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1532           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1533 /*@SWIG@*/ self->Emit( arg );
1534       }
1535 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1536          return self->Empty();
1537       }
1538 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *self){
1539         return self->GetConnectionCount();
1540       }
1541 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1542           return self->Connect( func );
1543       }
1544 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,void (*func)(Dali::Toolkit::ProgressBar,float,float)){
1545           self->Disconnect( func );
1546       }
1547 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *self,Dali::Toolkit::ProgressBar arg1,float arg2,float arg3){
1548           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1549 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1550       }
1551 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){
1552          return self->Empty();
1553       }
1554 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){
1555         return self->GetConnectionCount();
1556       }
1557 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 &)){
1558           self->Connect( func );
1559       }
1560 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 &)){
1561           self->Disconnect( func );
1562       }
1563 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){
1564           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1565 /*@SWIG@*/ self->Emit( arg );
1566       }
1567 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1568          return self->Empty();
1569       }
1570 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){
1571         return self->GetConnectionCount();
1572       }
1573 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 &)){
1574           self->Connect( func );
1575       }
1576 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 &)){
1577           self->Disconnect( func );
1578       }
1579 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){
1580           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1581 /*@SWIG@*/ self->Emit( arg );
1582       }
1583 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1584          return self->Empty();
1585       }
1586 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1587         return self->GetConnectionCount();
1588       }
1589 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)){
1590           self->Connect( func );
1591       }
1592 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)){
1593           self->Disconnect( func );
1594       }
1595 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1596           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1597 /*@SWIG@*/ self->Emit( arg );
1598       }
1599 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1600          return self->Empty();
1601       }
1602 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1603         return self->GetConnectionCount();
1604       }
1605 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)){
1606           self->Connect( func );
1607       }
1608 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)){
1609           self->Disconnect( func );
1610       }
1611 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1612           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1613 /*@SWIG@*/ self->Emit( arg );
1614       }
1615 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){
1616          return self->Empty();
1617       }
1618 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){
1619         return self->GetConnectionCount();
1620       }
1621 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 &)){
1622         self->Connect( func );
1623       }
1624 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 &)){
1625         self->Disconnect( func );
1626       }
1627 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){
1628         return self->Emit( arg1, arg2 );
1629       }
1630 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1631          return self->Empty();
1632       }
1633 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1634         return self->GetConnectionCount();
1635       }
1636 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)){
1637           self->Connect( func );
1638       }
1639 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)){
1640           self->Disconnect( func );
1641       }
1642 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1643           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1644 /*@SWIG@*/ self->Emit( arg );
1645       }
1646 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1647          return self->Empty();
1648       }
1649 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1650         return self->GetConnectionCount();
1651       }
1652 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 &)){
1653           self->Connect( func );
1654       }
1655 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 &)){
1656           self->Disconnect( func );
1657       }
1658 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){
1659           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1660 /*@SWIG@*/ self->Emit( arg );
1661       }
1662 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1663          return self->Empty();
1664       }
1665 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){
1666         return self->GetConnectionCount();
1667       }
1668 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)){
1669         self->Connect( func );
1670       }
1671 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)){
1672         self->Disconnect( func );
1673       }
1674 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){
1675         return self->Emit( arg1, arg2 );
1676       }
1677 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1678          return self->Empty();
1679       }
1680 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){
1681         return self->GetConnectionCount();
1682       }
1683 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)){
1684         self->Connect( func );
1685       }
1686 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)){
1687         self->Disconnect( func );
1688       }
1689 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){
1690         return self->Emit( arg1, arg2 );
1691       }
1692
1693
1694 /* ---------------------------------------------------
1695  * C++ director class methods
1696  * --------------------------------------------------- */
1697
1698 #include "dali_wrap.h"
1699
1700 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1701   swig_init_callbacks();
1702 }
1703
1704 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1705
1706 }
1707
1708
1709 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1710   int jdepth  ;
1711
1712   if (!swig_callbackOnStageConnection) {
1713     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1714     return;
1715   } else {
1716     jdepth = depth;
1717     swig_callbackOnStageConnection(jdepth);
1718   }
1719 }
1720
1721 void SwigDirector_ViewImpl::OnStageDisconnection() {
1722   if (!swig_callbackOnStageDisconnection) {
1723     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1724     return;
1725   } else {
1726     swig_callbackOnStageDisconnection();
1727   }
1728 }
1729
1730 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1731   void * jchild = 0 ;
1732
1733   if (!swig_callbackOnChildAdd) {
1734     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1735     return;
1736   } else {
1737     jchild = (Dali::Actor *) &child;
1738     swig_callbackOnChildAdd(jchild);
1739   }
1740 }
1741
1742 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1743   void * jchild = 0 ;
1744
1745   if (!swig_callbackOnChildRemove) {
1746     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1747     return;
1748   } else {
1749     jchild = (Dali::Actor *) &child;
1750     swig_callbackOnChildRemove(jchild);
1751   }
1752 }
1753
1754 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1755   int jindex  ;
1756   void * jpropertyValue  ;
1757
1758   if (!swig_callbackOnPropertySet) {
1759     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1760     return;
1761   } else {
1762     jindex = index;
1763     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1764     swig_callbackOnPropertySet(jindex, jpropertyValue);
1765   }
1766 }
1767
1768 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1769   void * jtargetSize = 0 ;
1770
1771   if (!swig_callbackOnSizeSet) {
1772     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1773     return;
1774   } else {
1775     jtargetSize = (Dali::Vector3 *) &targetSize;
1776     swig_callbackOnSizeSet(jtargetSize);
1777   }
1778 }
1779
1780 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1781   void * janimation = 0 ;
1782   void * jtargetSize = 0 ;
1783
1784   if (!swig_callbackOnSizeAnimation) {
1785     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1786     return;
1787   } else {
1788     janimation = (Dali::Animation *) &animation;
1789     jtargetSize = (Dali::Vector3 *) &targetSize;
1790     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1791   }
1792 }
1793
1794 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1795   bool c_result = SwigValueInit< bool >() ;
1796   unsigned int jresult = 0 ;
1797   void * jarg0 = 0 ;
1798
1799   if (!swig_callbackOnTouchEvent) {
1800     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1801   } else {
1802     jarg0 = (Dali::TouchEvent *) &event;
1803     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1804     c_result = jresult ? true : false;
1805   }
1806   return c_result;
1807 }
1808
1809 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1810   bool c_result = SwigValueInit< bool >() ;
1811   unsigned int jresult = 0 ;
1812   void * jarg0 = 0 ;
1813
1814   if (!swig_callbackOnHoverEvent) {
1815     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1816   } else {
1817     jarg0 = (Dali::HoverEvent *) &event;
1818     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1819     c_result = jresult ? true : false;
1820   }
1821   return c_result;
1822 }
1823
1824 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1825   bool c_result = SwigValueInit< bool >() ;
1826   unsigned int jresult = 0 ;
1827   void * jarg0 = 0 ;
1828
1829   if (!swig_callbackOnKeyEvent) {
1830     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1831   } else {
1832     jarg0 = (Dali::KeyEvent *) &event;
1833     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1834     c_result = jresult ? true : false;
1835   }
1836   return c_result;
1837 }
1838
1839 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1840   bool c_result = SwigValueInit< bool >() ;
1841   unsigned int jresult = 0 ;
1842   void * jarg0 = 0 ;
1843
1844   if (!swig_callbackOnWheelEvent) {
1845     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1846   } else {
1847     jarg0 = (Dali::WheelEvent *) &event;
1848     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1849     c_result = jresult ? true : false;
1850   }
1851   return c_result;
1852 }
1853
1854 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1855   void * jsize = 0 ;
1856   void * jcontainer = 0 ;
1857
1858   if (!swig_callbackOnRelayout) {
1859     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1860     return;
1861   } else {
1862     jsize = (Dali::Vector2 *) &size;
1863     jcontainer = (Dali::RelayoutContainer *) &container;
1864     swig_callbackOnRelayout(jsize, jcontainer);
1865   }
1866 }
1867
1868 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1869   int jpolicy  ;
1870   int jdimension  ;
1871
1872   if (!swig_callbackOnSetResizePolicy) {
1873     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1874     return;
1875   } else {
1876     jpolicy = (int)policy;
1877     jdimension = (int)dimension;
1878     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1879   }
1880 }
1881
1882 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1883   Dali::Vector3 c_result ;
1884   void * jresult = 0 ;
1885
1886   if (!swig_callbackGetNaturalSize) {
1887     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1888   } else {
1889     jresult = (void *) swig_callbackGetNaturalSize();
1890     if (!jresult) {
1891       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1892       return c_result;
1893     }
1894     c_result = *(Dali::Vector3 *)jresult;
1895   }
1896   return c_result;
1897 }
1898
1899 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1900   float c_result = SwigValueInit< float >() ;
1901   float jresult = 0 ;
1902   void * jchild = 0 ;
1903   int jdimension  ;
1904
1905   if (!swig_callbackCalculateChildSize) {
1906     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1907   } else {
1908     jchild = (Dali::Actor *) &child;
1909     jdimension = (int)dimension;
1910     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1911     c_result = (float)jresult;
1912   }
1913   return c_result;
1914 }
1915
1916 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1917   float c_result = SwigValueInit< float >() ;
1918   float jresult = 0 ;
1919   float jwidth  ;
1920
1921   if (!swig_callbackGetHeightForWidth) {
1922     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1923   } else {
1924     jwidth = width;
1925     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1926     c_result = (float)jresult;
1927   }
1928   return c_result;
1929 }
1930
1931 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1932   float c_result = SwigValueInit< float >() ;
1933   float jresult = 0 ;
1934   float jheight  ;
1935
1936   if (!swig_callbackGetWidthForHeight) {
1937     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1938   } else {
1939     jheight = height;
1940     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1941     c_result = (float)jresult;
1942   }
1943   return c_result;
1944 }
1945
1946 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1947   bool c_result = SwigValueInit< bool >() ;
1948   unsigned int jresult = 0 ;
1949   int jdimension  ;
1950
1951   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1952     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1953   } else {
1954     jdimension = (int)dimension;
1955     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1956     c_result = jresult ? true : false;
1957   }
1958   return c_result;
1959 }
1960
1961 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1962   int jdimension  ;
1963
1964   if (!swig_callbackOnCalculateRelayoutSize) {
1965     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1966     return;
1967   } else {
1968     jdimension = (int)dimension;
1969     swig_callbackOnCalculateRelayoutSize(jdimension);
1970   }
1971 }
1972
1973 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1974   float jsize  ;
1975   int jdimension  ;
1976
1977   if (!swig_callbackOnLayoutNegotiated) {
1978     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1979     return;
1980   } else {
1981     jsize = size;
1982     jdimension = (int)dimension;
1983     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1984   }
1985 }
1986
1987 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1988   return Dali::CustomActorImpl::GetExtension();
1989 }
1990
1991 void SwigDirector_ViewImpl::OnInitialize() {
1992   if (!swig_callbackOnInitialize) {
1993     Dali::Toolkit::Internal::Control::OnInitialize();
1994     return;
1995   } else {
1996     swig_callbackOnInitialize();
1997   }
1998 }
1999
2000 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2001   void * jchild = 0 ;
2002
2003   if (!swig_callbackOnControlChildAdd) {
2004     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2005     return;
2006   } else {
2007     jchild = (Dali::Actor *) &child;
2008     swig_callbackOnControlChildAdd(jchild);
2009   }
2010 }
2011
2012 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2013   void * jchild = 0 ;
2014
2015   if (!swig_callbackOnControlChildRemove) {
2016     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2017     return;
2018   } else {
2019     jchild = (Dali::Actor *) &child;
2020     swig_callbackOnControlChildRemove(jchild);
2021   }
2022 }
2023
2024 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2025   void * jstyleManager  ;
2026   int jchange  ;
2027
2028   if (!swig_callbackOnStyleChange) {
2029     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2030     return;
2031   } else {
2032     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2033     jchange = (int)change;
2034     swig_callbackOnStyleChange(jstyleManager, jchange);
2035   }
2036 }
2037
2038 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2039   bool c_result = SwigValueInit< bool >() ;
2040   unsigned int jresult = 0 ;
2041
2042   if (!swig_callbackOnAccessibilityActivated) {
2043     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2044   } else {
2045     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2046     c_result = jresult ? true : false;
2047   }
2048   return c_result;
2049 }
2050
2051 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2052   bool c_result = SwigValueInit< bool >() ;
2053   unsigned int jresult = 0 ;
2054   void * jgesture  ;
2055
2056   if (!swig_callbackOnAccessibilityPan) {
2057     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2058   } else {
2059     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2060     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2061     c_result = jresult ? true : false;
2062   }
2063   return c_result;
2064 }
2065
2066 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2067   bool c_result = SwigValueInit< bool >() ;
2068   unsigned int jresult = 0 ;
2069   void * jtouchEvent = 0 ;
2070
2071   if (!swig_callbackOnAccessibilityTouch) {
2072     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2073   } else {
2074     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2075     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2076     c_result = jresult ? true : false;
2077   }
2078   return c_result;
2079 }
2080
2081 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2082   bool c_result = SwigValueInit< bool >() ;
2083   unsigned int jresult = 0 ;
2084   unsigned int jisIncrease  ;
2085
2086   if (!swig_callbackOnAccessibilityValueChange) {
2087     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2088   } else {
2089     jisIncrease = isIncrease;
2090     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2091     c_result = jresult ? true : false;
2092   }
2093   return c_result;
2094 }
2095
2096 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2097   bool c_result = SwigValueInit< bool >() ;
2098   unsigned int jresult = 0 ;
2099
2100   if (!swig_callbackOnAccessibilityZoom) {
2101     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2102   } else {
2103     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2104     c_result = jresult ? true : false;
2105   }
2106   return c_result;
2107 }
2108
2109 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2110   if (!swig_callbackOnKeyInputFocusGained) {
2111     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2112     return;
2113   } else {
2114     swig_callbackOnKeyInputFocusGained();
2115   }
2116 }
2117
2118 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2119   if (!swig_callbackOnKeyInputFocusLost) {
2120     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2121     return;
2122   } else {
2123     swig_callbackOnKeyInputFocusLost();
2124   }
2125 }
2126
2127 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2128   Dali::Actor c_result ;
2129   void * jresult = 0 ;
2130   void * jcurrentFocusedActor  ;
2131   int jdirection  ;
2132   unsigned int jloopEnabled  ;
2133
2134   if (!swig_callbackGetNextKeyboardFocusableActor) {
2135     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2136   } else {
2137     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2138     jdirection = (int)direction;
2139     jloopEnabled = loopEnabled;
2140     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2141     if (!jresult) {
2142       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2143       return c_result;
2144     }
2145     c_result = *(Dali::Actor *)jresult;
2146   }
2147   return c_result;
2148 }
2149
2150 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2151   void * jcommitedFocusableActor  ;
2152
2153   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2154     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2155     return;
2156   } else {
2157     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2158     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2159   }
2160 }
2161
2162 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2163   bool c_result = SwigValueInit< bool >() ;
2164   unsigned int jresult = 0 ;
2165
2166   if (!swig_callbackOnKeyboardEnter) {
2167     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2168   } else {
2169     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2170     c_result = jresult ? true : false;
2171   }
2172   return c_result;
2173 }
2174
2175 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2176   void * jpinch = 0 ;
2177
2178   if (!swig_callbackOnPinch) {
2179     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2180     return;
2181   } else {
2182     jpinch = (Dali::PinchGesture *) &pinch;
2183     swig_callbackOnPinch(jpinch);
2184   }
2185 }
2186
2187 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2188   void * jpan = 0 ;
2189
2190   if (!swig_callbackOnPan) {
2191     Dali::Toolkit::Internal::Control::OnPan(pan);
2192     return;
2193   } else {
2194     jpan = (Dali::PanGesture *) &pan;
2195     swig_callbackOnPan(jpan);
2196   }
2197 }
2198
2199 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2200   void * jtap = 0 ;
2201
2202   if (!swig_callbackOnTap) {
2203     Dali::Toolkit::Internal::Control::OnTap(tap);
2204     return;
2205   } else {
2206     jtap = (Dali::TapGesture *) &tap;
2207     swig_callbackOnTap(jtap);
2208   }
2209 }
2210
2211 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2212   void * jlongPress = 0 ;
2213
2214   if (!swig_callbackOnLongPress) {
2215     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2216     return;
2217   } else {
2218     jlongPress = (Dali::LongPressGesture *) &longPress;
2219     swig_callbackOnLongPress(jlongPress);
2220   }
2221 }
2222
2223 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2224   void * jslotObserver = 0 ;
2225   void * jcallback = 0 ;
2226
2227   if (!swig_callbackSignalConnected) {
2228     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2229     return;
2230   } else {
2231     jslotObserver = (void *) slotObserver;
2232     jcallback = (void *) callback;
2233     swig_callbackSignalConnected(jslotObserver, jcallback);
2234   }
2235 }
2236
2237 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2238   void * jslotObserver = 0 ;
2239   void * jcallback = 0 ;
2240
2241   if (!swig_callbackSignalDisconnected) {
2242     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2243     return;
2244   } else {
2245     jslotObserver = (void *) slotObserver;
2246     jcallback = (void *) callback;
2247     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2248   }
2249 }
2250
2251 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2252   return Dali::Toolkit::Internal::Control::GetControlExtension();
2253 }
2254
2255 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) {
2256   swig_callbackOnStageConnection = callbackOnStageConnection;
2257   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2258   swig_callbackOnChildAdd = callbackOnChildAdd;
2259   swig_callbackOnChildRemove = callbackOnChildRemove;
2260   swig_callbackOnPropertySet = callbackOnPropertySet;
2261   swig_callbackOnSizeSet = callbackOnSizeSet;
2262   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2263   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2264   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2265   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2266   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2267   swig_callbackOnRelayout = callbackOnRelayout;
2268   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2269   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2270   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2271   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2272   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2273   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2274   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2275   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2276   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2277   swig_callbackOnInitialize = callbackOnInitialize;
2278   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2279   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2280   swig_callbackOnStyleChange = callbackOnStyleChange;
2281   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2282   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2283   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2284   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2285   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2286   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2287   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2288   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2289   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2290   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2291   swig_callbackOnPinch = callbackOnPinch;
2292   swig_callbackOnPan = callbackOnPan;
2293   swig_callbackOnTap = callbackOnTap;
2294   swig_callbackOnLongPress = callbackOnLongPress;
2295   swig_callbackSignalConnected = callbackSignalConnected;
2296   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2297 }
2298
2299 void SwigDirector_ViewImpl::swig_init_callbacks() {
2300   swig_callbackOnStageConnection = 0;
2301   swig_callbackOnStageDisconnection = 0;
2302   swig_callbackOnChildAdd = 0;
2303   swig_callbackOnChildRemove = 0;
2304   swig_callbackOnPropertySet = 0;
2305   swig_callbackOnSizeSet = 0;
2306   swig_callbackOnSizeAnimation = 0;
2307   swig_callbackOnTouchEvent = 0;
2308   swig_callbackOnHoverEvent = 0;
2309   swig_callbackOnKeyEvent = 0;
2310   swig_callbackOnWheelEvent = 0;
2311   swig_callbackOnRelayout = 0;
2312   swig_callbackOnSetResizePolicy = 0;
2313   swig_callbackGetNaturalSize = 0;
2314   swig_callbackCalculateChildSize = 0;
2315   swig_callbackGetHeightForWidth = 0;
2316   swig_callbackGetWidthForHeight = 0;
2317   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2318   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2319   swig_callbackOnCalculateRelayoutSize = 0;
2320   swig_callbackOnLayoutNegotiated = 0;
2321   swig_callbackOnInitialize = 0;
2322   swig_callbackOnControlChildAdd = 0;
2323   swig_callbackOnControlChildRemove = 0;
2324   swig_callbackOnStyleChange = 0;
2325   swig_callbackOnAccessibilityActivated = 0;
2326   swig_callbackOnAccessibilityPan = 0;
2327   swig_callbackOnAccessibilityTouch = 0;
2328   swig_callbackOnAccessibilityValueChange = 0;
2329   swig_callbackOnAccessibilityZoom = 0;
2330   swig_callbackOnKeyInputFocusGained = 0;
2331   swig_callbackOnKeyInputFocusLost = 0;
2332   swig_callbackGetNextKeyboardFocusableActor = 0;
2333   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2334   swig_callbackOnKeyboardEnter = 0;
2335   swig_callbackOnPinch = 0;
2336   swig_callbackOnPan = 0;
2337   swig_callbackOnTap = 0;
2338   swig_callbackOnLongPress = 0;
2339   swig_callbackSignalConnected = 0;
2340   swig_callbackSignalDisconnected = 0;
2341 }
2342
2343 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2344   swig_init_callbacks();
2345 }
2346
2347 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2348
2349 }
2350
2351
2352 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2353   unsigned int c_result = SwigValueInit< unsigned int >() ;
2354   unsigned int jresult = 0 ;
2355
2356   if (!swig_callbackGetNumberOfItems) {
2357     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2358   } else {
2359     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2360     c_result = (unsigned int)jresult;
2361   }
2362   return c_result;
2363 }
2364
2365 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2366   Dali::Actor c_result ;
2367   void * jresult = 0 ;
2368   unsigned int jitemId  ;
2369
2370   if (!swig_callbackNewItem) {
2371     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2372   } else {
2373     jitemId = itemId;
2374     jresult = (void *) swig_callbackNewItem(jitemId);
2375     if (!jresult) {
2376       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2377       return c_result;
2378     }
2379     c_result = *(Dali::Actor *)jresult;
2380   }
2381   return c_result;
2382 }
2383
2384 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2385   unsigned int jitemId  ;
2386   void * jactor  ;
2387
2388   if (!swig_callbackItemReleased) {
2389     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2390     return;
2391   } else {
2392     jitemId = itemId;
2393     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2394     swig_callbackItemReleased(jitemId, jactor);
2395   }
2396 }
2397
2398 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2399   return Dali::Toolkit::ItemFactory::GetExtension();
2400 }
2401
2402 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2403   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2404   swig_callbackNewItem = callbackNewItem;
2405   swig_callbackItemReleased = callbackItemReleased;
2406 }
2407
2408 void SwigDirector_ItemFactory::swig_init_callbacks() {
2409   swig_callbackGetNumberOfItems = 0;
2410   swig_callbackNewItem = 0;
2411   swig_callbackItemReleased = 0;
2412 }
2413
2414 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2415   swig_init_callbacks();
2416 }
2417
2418 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2419
2420 }
2421
2422
2423 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2424   Dali::Actor c_result ;
2425   void * jresult = 0 ;
2426   void * jcurrent  ;
2427   void * jproposed  ;
2428   int jdirection  ;
2429
2430   if (!swig_callbackGetNextFocusableActor) {
2431     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2432   } else {
2433     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2434     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2435     jdirection = (int)direction;
2436     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2437     if (!jresult) {
2438       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2439       return c_result;
2440     }
2441     c_result = *(Dali::Actor *)jresult;
2442   }
2443   return c_result;
2444 }
2445
2446 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2447   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2448 }
2449
2450 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2451   swig_callbackGetNextFocusableActor = 0;
2452 }
2453
2454
2455 #ifdef __cplusplus
2456 extern "C" {
2457 #endif
2458
2459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2460   void * jresult ;
2461   floatp *result = 0 ;
2462
2463   {
2464     try {
2465       result = (floatp *)new_floatp();
2466     } catch (std::out_of_range& e) {
2467       {
2468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2469       };
2470     } catch (std::exception& e) {
2471       {
2472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2473       };
2474     } catch (...) {
2475       {
2476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2477       };
2478     }
2479   }
2480   jresult = (void *)result;
2481   return jresult;
2482 }
2483
2484
2485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2486   floatp *arg1 = (floatp *) 0 ;
2487
2488   arg1 = (floatp *)jarg1;
2489   {
2490     try {
2491       delete_floatp(arg1);
2492     } catch (std::out_of_range& e) {
2493       {
2494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2495       };
2496     } catch (std::exception& e) {
2497       {
2498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2499       };
2500     } catch (...) {
2501       {
2502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2503       };
2504     }
2505   }
2506 }
2507
2508
2509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2510   floatp *arg1 = (floatp *) 0 ;
2511   float arg2 ;
2512
2513   arg1 = (floatp *)jarg1;
2514   arg2 = (float)jarg2;
2515   {
2516     try {
2517       floatp_assign(arg1,arg2);
2518     } catch (std::out_of_range& e) {
2519       {
2520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2521       };
2522     } catch (std::exception& e) {
2523       {
2524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2525       };
2526     } catch (...) {
2527       {
2528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2529       };
2530     }
2531   }
2532 }
2533
2534
2535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2536   float jresult ;
2537   floatp *arg1 = (floatp *) 0 ;
2538   float result;
2539
2540   arg1 = (floatp *)jarg1;
2541   {
2542     try {
2543       result = (float)floatp_value(arg1);
2544     } catch (std::out_of_range& e) {
2545       {
2546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2547       };
2548     } catch (std::exception& e) {
2549       {
2550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2551       };
2552     } catch (...) {
2553       {
2554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2555       };
2556     }
2557   }
2558   jresult = result;
2559   return jresult;
2560 }
2561
2562
2563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2564   void * jresult ;
2565   floatp *arg1 = (floatp *) 0 ;
2566   float *result = 0 ;
2567
2568   arg1 = (floatp *)jarg1;
2569   {
2570     try {
2571       result = (float *)floatp_cast(arg1);
2572     } catch (std::out_of_range& e) {
2573       {
2574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2575       };
2576     } catch (std::exception& e) {
2577       {
2578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2579       };
2580     } catch (...) {
2581       {
2582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2583       };
2584     }
2585   }
2586   jresult = (void *)result;
2587   return jresult;
2588 }
2589
2590
2591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2592   void * jresult ;
2593   float *arg1 = (float *) 0 ;
2594   floatp *result = 0 ;
2595
2596   arg1 = (float *)jarg1;
2597   {
2598     try {
2599       result = (floatp *)floatp_frompointer(arg1);
2600     } catch (std::out_of_range& e) {
2601       {
2602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2603       };
2604     } catch (std::exception& e) {
2605       {
2606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2607       };
2608     } catch (...) {
2609       {
2610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2611       };
2612     }
2613   }
2614   jresult = (void *)result;
2615   return jresult;
2616 }
2617
2618
2619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2620   void * jresult ;
2621   intp *result = 0 ;
2622
2623   {
2624     try {
2625       result = (intp *)new_intp();
2626     } catch (std::out_of_range& e) {
2627       {
2628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2629       };
2630     } catch (std::exception& e) {
2631       {
2632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2633       };
2634     } catch (...) {
2635       {
2636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2637       };
2638     }
2639   }
2640   jresult = (void *)result;
2641   return jresult;
2642 }
2643
2644
2645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2646   intp *arg1 = (intp *) 0 ;
2647
2648   arg1 = (intp *)jarg1;
2649   {
2650     try {
2651       delete_intp(arg1);
2652     } catch (std::out_of_range& e) {
2653       {
2654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2655       };
2656     } catch (std::exception& e) {
2657       {
2658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2659       };
2660     } catch (...) {
2661       {
2662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2663       };
2664     }
2665   }
2666 }
2667
2668
2669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2670   intp *arg1 = (intp *) 0 ;
2671   int arg2 ;
2672
2673   arg1 = (intp *)jarg1;
2674   arg2 = (int)jarg2;
2675   {
2676     try {
2677       intp_assign(arg1,arg2);
2678     } catch (std::out_of_range& e) {
2679       {
2680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2681       };
2682     } catch (std::exception& e) {
2683       {
2684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2685       };
2686     } catch (...) {
2687       {
2688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2689       };
2690     }
2691   }
2692 }
2693
2694
2695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2696   int jresult ;
2697   intp *arg1 = (intp *) 0 ;
2698   int result;
2699
2700   arg1 = (intp *)jarg1;
2701   {
2702     try {
2703       result = (int)intp_value(arg1);
2704     } catch (std::out_of_range& e) {
2705       {
2706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2707       };
2708     } catch (std::exception& e) {
2709       {
2710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2711       };
2712     } catch (...) {
2713       {
2714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2715       };
2716     }
2717   }
2718   jresult = result;
2719   return jresult;
2720 }
2721
2722
2723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2724   void * jresult ;
2725   intp *arg1 = (intp *) 0 ;
2726   int *result = 0 ;
2727
2728   arg1 = (intp *)jarg1;
2729   {
2730     try {
2731       result = (int *)intp_cast(arg1);
2732     } catch (std::out_of_range& e) {
2733       {
2734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2735       };
2736     } catch (std::exception& e) {
2737       {
2738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2739       };
2740     } catch (...) {
2741       {
2742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2743       };
2744     }
2745   }
2746   jresult = (void *)result;
2747   return jresult;
2748 }
2749
2750
2751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2752   void * jresult ;
2753   int *arg1 = (int *) 0 ;
2754   intp *result = 0 ;
2755
2756   arg1 = (int *)jarg1;
2757   {
2758     try {
2759       result = (intp *)intp_frompointer(arg1);
2760     } catch (std::out_of_range& e) {
2761       {
2762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2763       };
2764     } catch (std::exception& e) {
2765       {
2766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2767       };
2768     } catch (...) {
2769       {
2770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2771       };
2772     }
2773   }
2774   jresult = (void *)result;
2775   return jresult;
2776 }
2777
2778
2779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2780   void * jresult ;
2781   doublep *result = 0 ;
2782
2783   {
2784     try {
2785       result = (doublep *)new_doublep();
2786     } catch (std::out_of_range& e) {
2787       {
2788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2789       };
2790     } catch (std::exception& e) {
2791       {
2792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2793       };
2794     } catch (...) {
2795       {
2796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2797       };
2798     }
2799   }
2800   jresult = (void *)result;
2801   return jresult;
2802 }
2803
2804
2805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2806   doublep *arg1 = (doublep *) 0 ;
2807
2808   arg1 = (doublep *)jarg1;
2809   {
2810     try {
2811       delete_doublep(arg1);
2812     } catch (std::out_of_range& e) {
2813       {
2814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2815       };
2816     } catch (std::exception& e) {
2817       {
2818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2819       };
2820     } catch (...) {
2821       {
2822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2823       };
2824     }
2825   }
2826 }
2827
2828
2829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2830   doublep *arg1 = (doublep *) 0 ;
2831   double arg2 ;
2832
2833   arg1 = (doublep *)jarg1;
2834   arg2 = (double)jarg2;
2835   {
2836     try {
2837       doublep_assign(arg1,arg2);
2838     } catch (std::out_of_range& e) {
2839       {
2840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2841       };
2842     } catch (std::exception& e) {
2843       {
2844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2845       };
2846     } catch (...) {
2847       {
2848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2849       };
2850     }
2851   }
2852 }
2853
2854
2855 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2856   double jresult ;
2857   doublep *arg1 = (doublep *) 0 ;
2858   double result;
2859
2860   arg1 = (doublep *)jarg1;
2861   {
2862     try {
2863       result = (double)doublep_value(arg1);
2864     } catch (std::out_of_range& e) {
2865       {
2866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2867       };
2868     } catch (std::exception& e) {
2869       {
2870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2871       };
2872     } catch (...) {
2873       {
2874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2875       };
2876     }
2877   }
2878   jresult = result;
2879   return jresult;
2880 }
2881
2882
2883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2884   void * jresult ;
2885   doublep *arg1 = (doublep *) 0 ;
2886   double *result = 0 ;
2887
2888   arg1 = (doublep *)jarg1;
2889   {
2890     try {
2891       result = (double *)doublep_cast(arg1);
2892     } catch (std::out_of_range& e) {
2893       {
2894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2895       };
2896     } catch (std::exception& e) {
2897       {
2898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2899       };
2900     } catch (...) {
2901       {
2902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2903       };
2904     }
2905   }
2906   jresult = (void *)result;
2907   return jresult;
2908 }
2909
2910
2911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2912   void * jresult ;
2913   double *arg1 = (double *) 0 ;
2914   doublep *result = 0 ;
2915
2916   arg1 = (double *)jarg1;
2917   {
2918     try {
2919       result = (doublep *)doublep_frompointer(arg1);
2920     } catch (std::out_of_range& e) {
2921       {
2922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2923       };
2924     } catch (std::exception& e) {
2925       {
2926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2927       };
2928     } catch (...) {
2929       {
2930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2931       };
2932     }
2933   }
2934   jresult = (void *)result;
2935   return jresult;
2936 }
2937
2938
2939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2940   void * jresult ;
2941   uintp *result = 0 ;
2942
2943   {
2944     try {
2945       result = (uintp *)new_uintp();
2946     } catch (std::out_of_range& e) {
2947       {
2948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2949       };
2950     } catch (std::exception& e) {
2951       {
2952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2953       };
2954     } catch (...) {
2955       {
2956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2957       };
2958     }
2959   }
2960   jresult = (void *)result;
2961   return jresult;
2962 }
2963
2964
2965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2966   uintp *arg1 = (uintp *) 0 ;
2967
2968   arg1 = (uintp *)jarg1;
2969   {
2970     try {
2971       delete_uintp(arg1);
2972     } catch (std::out_of_range& e) {
2973       {
2974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2975       };
2976     } catch (std::exception& e) {
2977       {
2978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2979       };
2980     } catch (...) {
2981       {
2982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2983       };
2984     }
2985   }
2986 }
2987
2988
2989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2990   uintp *arg1 = (uintp *) 0 ;
2991   unsigned int arg2 ;
2992
2993   arg1 = (uintp *)jarg1;
2994   arg2 = (unsigned int)jarg2;
2995   {
2996     try {
2997       uintp_assign(arg1,arg2);
2998     } catch (std::out_of_range& e) {
2999       {
3000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3001       };
3002     } catch (std::exception& e) {
3003       {
3004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3005       };
3006     } catch (...) {
3007       {
3008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3009       };
3010     }
3011   }
3012 }
3013
3014
3015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3016   unsigned int jresult ;
3017   uintp *arg1 = (uintp *) 0 ;
3018   unsigned int result;
3019
3020   arg1 = (uintp *)jarg1;
3021   {
3022     try {
3023       result = (unsigned int)uintp_value(arg1);
3024     } catch (std::out_of_range& e) {
3025       {
3026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3027       };
3028     } catch (std::exception& e) {
3029       {
3030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3031       };
3032     } catch (...) {
3033       {
3034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3035       };
3036     }
3037   }
3038   jresult = result;
3039   return jresult;
3040 }
3041
3042
3043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3044   void * jresult ;
3045   uintp *arg1 = (uintp *) 0 ;
3046   unsigned int *result = 0 ;
3047
3048   arg1 = (uintp *)jarg1;
3049   {
3050     try {
3051       result = (unsigned int *)uintp_cast(arg1);
3052     } catch (std::out_of_range& e) {
3053       {
3054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3055       };
3056     } catch (std::exception& e) {
3057       {
3058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3059       };
3060     } catch (...) {
3061       {
3062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3063       };
3064     }
3065   }
3066   jresult = (void *)result;
3067   return jresult;
3068 }
3069
3070
3071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3072   void * jresult ;
3073   unsigned int *arg1 = (unsigned int *) 0 ;
3074   uintp *result = 0 ;
3075
3076   arg1 = (unsigned int *)jarg1;
3077   {
3078     try {
3079       result = (uintp *)uintp_frompointer(arg1);
3080     } catch (std::out_of_range& e) {
3081       {
3082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3083       };
3084     } catch (std::exception& e) {
3085       {
3086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3087       };
3088     } catch (...) {
3089       {
3090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3091       };
3092     }
3093   }
3094   jresult = (void *)result;
3095   return jresult;
3096 }
3097
3098
3099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3100   void * jresult ;
3101   ushortp *result = 0 ;
3102
3103   {
3104     try {
3105       result = (ushortp *)new_ushortp();
3106     } catch (std::out_of_range& e) {
3107       {
3108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3109       };
3110     } catch (std::exception& e) {
3111       {
3112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3113       };
3114     } catch (...) {
3115       {
3116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3117       };
3118     }
3119   }
3120   jresult = (void *)result;
3121   return jresult;
3122 }
3123
3124
3125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3126   ushortp *arg1 = (ushortp *) 0 ;
3127
3128   arg1 = (ushortp *)jarg1;
3129   {
3130     try {
3131       delete_ushortp(arg1);
3132     } catch (std::out_of_range& e) {
3133       {
3134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3135       };
3136     } catch (std::exception& e) {
3137       {
3138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3139       };
3140     } catch (...) {
3141       {
3142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3143       };
3144     }
3145   }
3146 }
3147
3148
3149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3150   ushortp *arg1 = (ushortp *) 0 ;
3151   unsigned short arg2 ;
3152
3153   arg1 = (ushortp *)jarg1;
3154   arg2 = (unsigned short)jarg2;
3155   {
3156     try {
3157       ushortp_assign(arg1,arg2);
3158     } catch (std::out_of_range& e) {
3159       {
3160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3161       };
3162     } catch (std::exception& e) {
3163       {
3164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3165       };
3166     } catch (...) {
3167       {
3168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3169       };
3170     }
3171   }
3172 }
3173
3174
3175 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3176   unsigned short jresult ;
3177   ushortp *arg1 = (ushortp *) 0 ;
3178   unsigned short result;
3179
3180   arg1 = (ushortp *)jarg1;
3181   {
3182     try {
3183       result = (unsigned short)ushortp_value(arg1);
3184     } catch (std::out_of_range& e) {
3185       {
3186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3187       };
3188     } catch (std::exception& e) {
3189       {
3190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3191       };
3192     } catch (...) {
3193       {
3194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3195       };
3196     }
3197   }
3198   jresult = result;
3199   return jresult;
3200 }
3201
3202
3203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3204   void * jresult ;
3205   ushortp *arg1 = (ushortp *) 0 ;
3206   unsigned short *result = 0 ;
3207
3208   arg1 = (ushortp *)jarg1;
3209   {
3210     try {
3211       result = (unsigned short *)ushortp_cast(arg1);
3212     } catch (std::out_of_range& e) {
3213       {
3214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3215       };
3216     } catch (std::exception& e) {
3217       {
3218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3219       };
3220     } catch (...) {
3221       {
3222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3223       };
3224     }
3225   }
3226   jresult = (void *)result;
3227   return jresult;
3228 }
3229
3230
3231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3232   void * jresult ;
3233   unsigned short *arg1 = (unsigned short *) 0 ;
3234   ushortp *result = 0 ;
3235
3236   arg1 = (unsigned short *)jarg1;
3237   {
3238     try {
3239       result = (ushortp *)ushortp_frompointer(arg1);
3240     } catch (std::out_of_range& e) {
3241       {
3242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3243       };
3244     } catch (std::exception& e) {
3245       {
3246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3247       };
3248     } catch (...) {
3249       {
3250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3251       };
3252     }
3253   }
3254   jresult = (void *)result;
3255   return jresult;
3256 }
3257
3258
3259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3260   unsigned int jresult ;
3261   int arg1 ;
3262   unsigned int result;
3263
3264   arg1 = (int)jarg1;
3265   {
3266     try {
3267       result = (unsigned int)int_to_uint(arg1);
3268     } catch (std::out_of_range& e) {
3269       {
3270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3271       };
3272     } catch (std::exception& e) {
3273       {
3274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3275       };
3276     } catch (...) {
3277       {
3278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3279       };
3280     }
3281   }
3282   jresult = result;
3283   return jresult;
3284 }
3285
3286
3287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3288   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3289
3290   arg1 = (Dali::RefObject *)jarg1;
3291   {
3292     try {
3293       (arg1)->Reference();
3294     } catch (std::out_of_range& e) {
3295       {
3296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3297       };
3298     } catch (std::exception& e) {
3299       {
3300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3301       };
3302     } catch (...) {
3303       {
3304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3305       };
3306     }
3307   }
3308 }
3309
3310
3311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3312   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3313
3314   arg1 = (Dali::RefObject *)jarg1;
3315   {
3316     try {
3317       (arg1)->Unreference();
3318     } catch (std::out_of_range& e) {
3319       {
3320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3321       };
3322     } catch (std::exception& e) {
3323       {
3324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3325       };
3326     } catch (...) {
3327       {
3328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3329       };
3330     }
3331   }
3332 }
3333
3334
3335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3336   int jresult ;
3337   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3338   int result;
3339
3340   arg1 = (Dali::RefObject *)jarg1;
3341   {
3342     try {
3343       result = (int)(arg1)->ReferenceCount();
3344     } catch (std::out_of_range& e) {
3345       {
3346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3347       };
3348     } catch (std::exception& e) {
3349       {
3350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3351       };
3352     } catch (...) {
3353       {
3354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3355       };
3356     }
3357   }
3358   jresult = result;
3359   return jresult;
3360 }
3361
3362
3363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3364   void * jresult ;
3365   Dali::Any *result = 0 ;
3366
3367   {
3368     try {
3369       result = (Dali::Any *)new Dali::Any();
3370     } catch (std::out_of_range& e) {
3371       {
3372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3373       };
3374     } catch (std::exception& e) {
3375       {
3376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3377       };
3378     } catch (...) {
3379       {
3380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3381       };
3382     }
3383   }
3384   jresult = (void *)result;
3385   return jresult;
3386 }
3387
3388
3389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3390   Dali::Any *arg1 = (Dali::Any *) 0 ;
3391
3392   arg1 = (Dali::Any *)jarg1;
3393   {
3394     try {
3395       delete arg1;
3396     } catch (std::out_of_range& e) {
3397       {
3398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3399       };
3400     } catch (std::exception& e) {
3401       {
3402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3403       };
3404     } catch (...) {
3405       {
3406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3407       };
3408     }
3409   }
3410 }
3411
3412
3413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3414   char *arg1 = (char *) 0 ;
3415
3416   arg1 = (char *)jarg1;
3417   {
3418     try {
3419       Dali::Any::AssertAlways((char const *)arg1);
3420     } catch (std::out_of_range& e) {
3421       {
3422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3423       };
3424     } catch (std::exception& e) {
3425       {
3426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3427       };
3428     } catch (...) {
3429       {
3430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3431       };
3432     }
3433   }
3434 }
3435
3436
3437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3438   void * jresult ;
3439   Dali::Any *arg1 = 0 ;
3440   Dali::Any *result = 0 ;
3441
3442   arg1 = (Dali::Any *)jarg1;
3443   if (!arg1) {
3444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3445     return 0;
3446   }
3447   {
3448     try {
3449       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3450     } catch (std::out_of_range& e) {
3451       {
3452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3453       };
3454     } catch (std::exception& e) {
3455       {
3456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3457       };
3458     } catch (...) {
3459       {
3460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3461       };
3462     }
3463   }
3464   jresult = (void *)result;
3465   return jresult;
3466 }
3467
3468
3469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3470   void * jresult ;
3471   Dali::Any *arg1 = (Dali::Any *) 0 ;
3472   Dali::Any *arg2 = 0 ;
3473   Dali::Any *result = 0 ;
3474
3475   arg1 = (Dali::Any *)jarg1;
3476   arg2 = (Dali::Any *)jarg2;
3477   if (!arg2) {
3478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3479     return 0;
3480   }
3481   {
3482     try {
3483       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3484     } catch (std::out_of_range& e) {
3485       {
3486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3487       };
3488     } catch (std::exception& e) {
3489       {
3490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3491       };
3492     } catch (...) {
3493       {
3494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3495       };
3496     }
3497   }
3498   jresult = (void *)result;
3499   return jresult;
3500 }
3501
3502
3503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3504   void * jresult ;
3505   Dali::Any *arg1 = (Dali::Any *) 0 ;
3506   std::type_info *result = 0 ;
3507
3508   arg1 = (Dali::Any *)jarg1;
3509   {
3510     try {
3511       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3512     } catch (std::out_of_range& e) {
3513       {
3514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3515       };
3516     } catch (std::exception& e) {
3517       {
3518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3519       };
3520     } catch (...) {
3521       {
3522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3523       };
3524     }
3525   }
3526   jresult = (void *)result;
3527   return jresult;
3528 }
3529
3530
3531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3532   unsigned int jresult ;
3533   Dali::Any *arg1 = (Dali::Any *) 0 ;
3534   bool result;
3535
3536   arg1 = (Dali::Any *)jarg1;
3537   {
3538     try {
3539       result = (bool)((Dali::Any const *)arg1)->Empty();
3540     } catch (std::out_of_range& e) {
3541       {
3542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3543       };
3544     } catch (std::exception& e) {
3545       {
3546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3547       };
3548     } catch (...) {
3549       {
3550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3551       };
3552     }
3553   }
3554   jresult = result;
3555   return jresult;
3556 }
3557
3558
3559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3560   void * jresult ;
3561   std::type_info *arg1 = 0 ;
3562   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3563   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3564   Dali::Any::AnyContainerBase *result = 0 ;
3565
3566   arg1 = (std::type_info *)jarg1;
3567   if (!arg1) {
3568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3569     return 0;
3570   }
3571   arg2 = (Dali::Any::CloneFunc)jarg2;
3572   arg3 = (Dali::Any::DeleteFunc)jarg3;
3573   {
3574     try {
3575       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3576     } catch (std::out_of_range& e) {
3577       {
3578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3579       };
3580     } catch (std::exception& e) {
3581       {
3582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3583       };
3584     } catch (...) {
3585       {
3586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3587       };
3588     }
3589   }
3590   jresult = (void *)result;
3591   return jresult;
3592 }
3593
3594
3595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3596   void * jresult ;
3597   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3598   std::type_info *result = 0 ;
3599
3600   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3601   {
3602     try {
3603       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3604     } catch (std::out_of_range& e) {
3605       {
3606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3607       };
3608     } catch (std::exception& e) {
3609       {
3610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3611       };
3612     } catch (...) {
3613       {
3614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3615       };
3616     }
3617   }
3618   jresult = (void *)result;
3619   return jresult;
3620 }
3621
3622
3623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3624   void * jresult ;
3625   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3626   ::std::type_info *result = 0 ;
3627
3628   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3629   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3630   jresult = (void *)result;
3631   return jresult;
3632 }
3633
3634
3635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3636   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3637   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3638
3639   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3640   arg2 = (Dali::Any::CloneFunc)jarg2;
3641   if (arg1) (arg1)->mCloneFunc = arg2;
3642 }
3643
3644
3645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3646   void * jresult ;
3647   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3648   Dali::Any::CloneFunc result;
3649
3650   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3651   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3652   jresult = (void *)result;
3653   return jresult;
3654 }
3655
3656
3657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3658   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3659   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3660
3661   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3662   arg2 = (Dali::Any::DeleteFunc)jarg2;
3663   if (arg1) (arg1)->mDeleteFunc = arg2;
3664 }
3665
3666
3667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3668   void * jresult ;
3669   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3670   Dali::Any::DeleteFunc result;
3671
3672   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3673   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3674   jresult = (void *)result;
3675   return jresult;
3676 }
3677
3678
3679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3680   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3681
3682   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3683   {
3684     try {
3685       delete arg1;
3686     } catch (std::out_of_range& e) {
3687       {
3688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3689       };
3690     } catch (std::exception& e) {
3691       {
3692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3693       };
3694     } catch (...) {
3695       {
3696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3697       };
3698     }
3699   }
3700 }
3701
3702
3703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3704   Dali::Any *arg1 = (Dali::Any *) 0 ;
3705   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3706
3707   arg1 = (Dali::Any *)jarg1;
3708   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3709   if (arg1) (arg1)->mContainer = arg2;
3710 }
3711
3712
3713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3714   void * jresult ;
3715   Dali::Any *arg1 = (Dali::Any *) 0 ;
3716   Dali::Any::AnyContainerBase *result = 0 ;
3717
3718   arg1 = (Dali::Any *)jarg1;
3719   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3720   jresult = (void *)result;
3721   return jresult;
3722 }
3723
3724
3725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3726   char *arg1 = (char *) 0 ;
3727   char *arg2 = (char *) 0 ;
3728
3729   arg1 = (char *)jarg1;
3730   arg2 = (char *)jarg2;
3731   {
3732     try {
3733       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3734     } catch (std::out_of_range& e) {
3735       {
3736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3737       };
3738     } catch (std::exception& e) {
3739       {
3740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3741       };
3742     } catch (...) {
3743       {
3744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3745       };
3746     }
3747   }
3748 }
3749
3750
3751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3752   void * jresult ;
3753   char *arg1 = (char *) 0 ;
3754   char *arg2 = (char *) 0 ;
3755   Dali::DaliException *result = 0 ;
3756
3757   arg1 = (char *)jarg1;
3758   arg2 = (char *)jarg2;
3759   {
3760     try {
3761       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3762     } catch (std::out_of_range& e) {
3763       {
3764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3765       };
3766     } catch (std::exception& e) {
3767       {
3768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3769       };
3770     } catch (...) {
3771       {
3772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3773       };
3774     }
3775   }
3776   jresult = (void *)result;
3777   return jresult;
3778 }
3779
3780
3781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3782   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3783   char *arg2 = (char *) 0 ;
3784
3785   arg1 = (Dali::DaliException *)jarg1;
3786   arg2 = (char *)jarg2;
3787   {
3788     if (arg2) {
3789       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3790       strcpy((char *)arg1->location, (const char *)arg2);
3791     } else {
3792       arg1->location = 0;
3793     }
3794   }
3795 }
3796
3797
3798 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3799   char * jresult ;
3800   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3801   char *result = 0 ;
3802
3803   arg1 = (Dali::DaliException *)jarg1;
3804   result = (char *) ((arg1)->location);
3805   jresult = SWIG_csharp_string_callback((const char *)result);
3806   return jresult;
3807 }
3808
3809
3810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3811   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3812   char *arg2 = (char *) 0 ;
3813
3814   arg1 = (Dali::DaliException *)jarg1;
3815   arg2 = (char *)jarg2;
3816   {
3817     if (arg2) {
3818       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3819       strcpy((char *)arg1->condition, (const char *)arg2);
3820     } else {
3821       arg1->condition = 0;
3822     }
3823   }
3824 }
3825
3826
3827 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3828   char * jresult ;
3829   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3830   char *result = 0 ;
3831
3832   arg1 = (Dali::DaliException *)jarg1;
3833   result = (char *) ((arg1)->condition);
3834   jresult = SWIG_csharp_string_callback((const char *)result);
3835   return jresult;
3836 }
3837
3838
3839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3840   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3841
3842   arg1 = (Dali::DaliException *)jarg1;
3843   {
3844     try {
3845       delete arg1;
3846     } catch (std::out_of_range& e) {
3847       {
3848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3849       };
3850     } catch (std::exception& e) {
3851       {
3852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3853       };
3854     } catch (...) {
3855       {
3856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3857       };
3858     }
3859   }
3860 }
3861
3862
3863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3864   void * jresult ;
3865   Dali::Vector2 *result = 0 ;
3866
3867   {
3868     try {
3869       result = (Dali::Vector2 *)new Dali::Vector2();
3870     } catch (std::out_of_range& e) {
3871       {
3872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3873       };
3874     } catch (std::exception& e) {
3875       {
3876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3877       };
3878     } catch (...) {
3879       {
3880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3881       };
3882     }
3883   }
3884   jresult = (void *)result;
3885   return jresult;
3886 }
3887
3888
3889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3890   void * jresult ;
3891   float arg1 ;
3892   float arg2 ;
3893   Dali::Vector2 *result = 0 ;
3894
3895   arg1 = (float)jarg1;
3896   arg2 = (float)jarg2;
3897   {
3898     try {
3899       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3900     } catch (std::out_of_range& e) {
3901       {
3902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3903       };
3904     } catch (std::exception& e) {
3905       {
3906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3907       };
3908     } catch (...) {
3909       {
3910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3911       };
3912     }
3913   }
3914   jresult = (void *)result;
3915   return jresult;
3916 }
3917
3918
3919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3920   void * jresult ;
3921   float *arg1 = (float *) 0 ;
3922   Dali::Vector2 *result = 0 ;
3923
3924   arg1 = jarg1;
3925   {
3926     try {
3927       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3928     } catch (std::out_of_range& e) {
3929       {
3930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3931       };
3932     } catch (std::exception& e) {
3933       {
3934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3935       };
3936     } catch (...) {
3937       {
3938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3939       };
3940     }
3941   }
3942   jresult = (void *)result;
3943
3944
3945   return jresult;
3946 }
3947
3948
3949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3950   void * jresult ;
3951   Dali::Vector3 *arg1 = 0 ;
3952   Dali::Vector2 *result = 0 ;
3953
3954   arg1 = (Dali::Vector3 *)jarg1;
3955   if (!arg1) {
3956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3957     return 0;
3958   }
3959   {
3960     try {
3961       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3962     } catch (std::out_of_range& e) {
3963       {
3964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3965       };
3966     } catch (std::exception& e) {
3967       {
3968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3969       };
3970     } catch (...) {
3971       {
3972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3973       };
3974     }
3975   }
3976   jresult = (void *)result;
3977   return jresult;
3978 }
3979
3980
3981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3982   void * jresult ;
3983   Dali::Vector4 *arg1 = 0 ;
3984   Dali::Vector2 *result = 0 ;
3985
3986   arg1 = (Dali::Vector4 *)jarg1;
3987   if (!arg1) {
3988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3989     return 0;
3990   }
3991   {
3992     try {
3993       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3994     } catch (std::out_of_range& e) {
3995       {
3996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3997       };
3998     } catch (std::exception& e) {
3999       {
4000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4001       };
4002     } catch (...) {
4003       {
4004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4005       };
4006     }
4007   }
4008   jresult = (void *)result;
4009   return jresult;
4010 }
4011
4012
4013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4014   void * jresult ;
4015   Dali::Vector2 *result = 0 ;
4016
4017   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4018   jresult = (void *)result;
4019   return jresult;
4020 }
4021
4022
4023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4024   void * jresult ;
4025   Dali::Vector2 *result = 0 ;
4026
4027   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4028   jresult = (void *)result;
4029   return jresult;
4030 }
4031
4032
4033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4034   void * jresult ;
4035   Dali::Vector2 *result = 0 ;
4036
4037   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4038   jresult = (void *)result;
4039   return jresult;
4040 }
4041
4042
4043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4044   void * jresult ;
4045   Dali::Vector2 *result = 0 ;
4046
4047   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4048   jresult = (void *)result;
4049   return jresult;
4050 }
4051
4052
4053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4054   void * jresult ;
4055   Dali::Vector2 *result = 0 ;
4056
4057   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4058   jresult = (void *)result;
4059   return jresult;
4060 }
4061
4062
4063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4064   void * jresult ;
4065   Dali::Vector2 *result = 0 ;
4066
4067   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4068   jresult = (void *)result;
4069   return jresult;
4070 }
4071
4072
4073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4074   void * jresult ;
4075   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4076   float *arg2 = (float *) 0 ;
4077   Dali::Vector2 *result = 0 ;
4078
4079   arg1 = (Dali::Vector2 *)jarg1;
4080   arg2 = jarg2;
4081   {
4082     try {
4083       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4084     } catch (std::out_of_range& e) {
4085       {
4086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4087       };
4088     } catch (std::exception& e) {
4089       {
4090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4091       };
4092     } catch (...) {
4093       {
4094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4095       };
4096     }
4097   }
4098   jresult = (void *)result;
4099
4100
4101   return jresult;
4102 }
4103
4104
4105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4106   void * jresult ;
4107   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4108   Dali::Vector3 *arg2 = 0 ;
4109   Dali::Vector2 *result = 0 ;
4110
4111   arg1 = (Dali::Vector2 *)jarg1;
4112   arg2 = (Dali::Vector3 *)jarg2;
4113   if (!arg2) {
4114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4115     return 0;
4116   }
4117   {
4118     try {
4119       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4120     } catch (std::out_of_range& e) {
4121       {
4122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4123       };
4124     } catch (std::exception& e) {
4125       {
4126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4127       };
4128     } catch (...) {
4129       {
4130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4131       };
4132     }
4133   }
4134   jresult = (void *)result;
4135   return jresult;
4136 }
4137
4138
4139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4140   void * jresult ;
4141   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4142   Dali::Vector4 *arg2 = 0 ;
4143   Dali::Vector2 *result = 0 ;
4144
4145   arg1 = (Dali::Vector2 *)jarg1;
4146   arg2 = (Dali::Vector4 *)jarg2;
4147   if (!arg2) {
4148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4149     return 0;
4150   }
4151   {
4152     try {
4153       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4154     } catch (std::out_of_range& e) {
4155       {
4156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4157       };
4158     } catch (std::exception& e) {
4159       {
4160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4161       };
4162     } catch (...) {
4163       {
4164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4165       };
4166     }
4167   }
4168   jresult = (void *)result;
4169   return jresult;
4170 }
4171
4172
4173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4174   void * jresult ;
4175   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4176   Dali::Vector2 *arg2 = 0 ;
4177   Dali::Vector2 result;
4178
4179   arg1 = (Dali::Vector2 *)jarg1;
4180   arg2 = (Dali::Vector2 *)jarg2;
4181   if (!arg2) {
4182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4183     return 0;
4184   }
4185   {
4186     try {
4187       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4188     } catch (std::out_of_range& e) {
4189       {
4190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4191       };
4192     } catch (std::exception& e) {
4193       {
4194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4195       };
4196     } catch (...) {
4197       {
4198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4199       };
4200     }
4201   }
4202   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4203   return jresult;
4204 }
4205
4206
4207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4208   void * jresult ;
4209   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4210   Dali::Vector2 *arg2 = 0 ;
4211   Dali::Vector2 *result = 0 ;
4212
4213   arg1 = (Dali::Vector2 *)jarg1;
4214   arg2 = (Dali::Vector2 *)jarg2;
4215   if (!arg2) {
4216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4217     return 0;
4218   }
4219   {
4220     try {
4221       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4222     } catch (std::out_of_range& e) {
4223       {
4224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4225       };
4226     } catch (std::exception& e) {
4227       {
4228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4229       };
4230     } catch (...) {
4231       {
4232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4233       };
4234     }
4235   }
4236   jresult = (void *)result;
4237   return jresult;
4238 }
4239
4240
4241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4242   void * jresult ;
4243   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4244   Dali::Vector2 *arg2 = 0 ;
4245   Dali::Vector2 result;
4246
4247   arg1 = (Dali::Vector2 *)jarg1;
4248   arg2 = (Dali::Vector2 *)jarg2;
4249   if (!arg2) {
4250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4251     return 0;
4252   }
4253   {
4254     try {
4255       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4256     } catch (std::out_of_range& e) {
4257       {
4258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4259       };
4260     } catch (std::exception& e) {
4261       {
4262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4263       };
4264     } catch (...) {
4265       {
4266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4267       };
4268     }
4269   }
4270   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4271   return jresult;
4272 }
4273
4274
4275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4276   void * jresult ;
4277   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4278   Dali::Vector2 *arg2 = 0 ;
4279   Dali::Vector2 *result = 0 ;
4280
4281   arg1 = (Dali::Vector2 *)jarg1;
4282   arg2 = (Dali::Vector2 *)jarg2;
4283   if (!arg2) {
4284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4285     return 0;
4286   }
4287   {
4288     try {
4289       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4290     } catch (std::out_of_range& e) {
4291       {
4292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4293       };
4294     } catch (std::exception& e) {
4295       {
4296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4297       };
4298     } catch (...) {
4299       {
4300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4301       };
4302     }
4303   }
4304   jresult = (void *)result;
4305   return jresult;
4306 }
4307
4308
4309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4310   void * jresult ;
4311   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4312   Dali::Vector2 *arg2 = 0 ;
4313   Dali::Vector2 result;
4314
4315   arg1 = (Dali::Vector2 *)jarg1;
4316   arg2 = (Dali::Vector2 *)jarg2;
4317   if (!arg2) {
4318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4319     return 0;
4320   }
4321   {
4322     try {
4323       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4324     } catch (std::out_of_range& e) {
4325       {
4326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4327       };
4328     } catch (std::exception& e) {
4329       {
4330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4331       };
4332     } catch (...) {
4333       {
4334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4335       };
4336     }
4337   }
4338   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4339   return jresult;
4340 }
4341
4342
4343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4344   void * jresult ;
4345   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4346   float arg2 ;
4347   Dali::Vector2 result;
4348
4349   arg1 = (Dali::Vector2 *)jarg1;
4350   arg2 = (float)jarg2;
4351   {
4352     try {
4353       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4354     } catch (std::out_of_range& e) {
4355       {
4356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4357       };
4358     } catch (std::exception& e) {
4359       {
4360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4361       };
4362     } catch (...) {
4363       {
4364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4365       };
4366     }
4367   }
4368   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4369   return jresult;
4370 }
4371
4372
4373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4374   void * jresult ;
4375   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4376   Dali::Vector2 *arg2 = 0 ;
4377   Dali::Vector2 *result = 0 ;
4378
4379   arg1 = (Dali::Vector2 *)jarg1;
4380   arg2 = (Dali::Vector2 *)jarg2;
4381   if (!arg2) {
4382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4383     return 0;
4384   }
4385   {
4386     try {
4387       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4388     } catch (std::out_of_range& e) {
4389       {
4390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4391       };
4392     } catch (std::exception& e) {
4393       {
4394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4395       };
4396     } catch (...) {
4397       {
4398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4399       };
4400     }
4401   }
4402   jresult = (void *)result;
4403   return jresult;
4404 }
4405
4406
4407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4408   void * jresult ;
4409   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4410   float arg2 ;
4411   Dali::Vector2 *result = 0 ;
4412
4413   arg1 = (Dali::Vector2 *)jarg1;
4414   arg2 = (float)jarg2;
4415   {
4416     try {
4417       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4418     } catch (std::out_of_range& e) {
4419       {
4420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4421       };
4422     } catch (std::exception& e) {
4423       {
4424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4425       };
4426     } catch (...) {
4427       {
4428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4429       };
4430     }
4431   }
4432   jresult = (void *)result;
4433   return jresult;
4434 }
4435
4436
4437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4438   void * jresult ;
4439   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4440   Dali::Vector2 *arg2 = 0 ;
4441   Dali::Vector2 result;
4442
4443   arg1 = (Dali::Vector2 *)jarg1;
4444   arg2 = (Dali::Vector2 *)jarg2;
4445   if (!arg2) {
4446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4447     return 0;
4448   }
4449   {
4450     try {
4451       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4452     } catch (std::out_of_range& e) {
4453       {
4454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4455       };
4456     } catch (std::exception& e) {
4457       {
4458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4459       };
4460     } catch (...) {
4461       {
4462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4463       };
4464     }
4465   }
4466   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4467   return jresult;
4468 }
4469
4470
4471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4472   void * jresult ;
4473   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4474   float arg2 ;
4475   Dali::Vector2 result;
4476
4477   arg1 = (Dali::Vector2 *)jarg1;
4478   arg2 = (float)jarg2;
4479   {
4480     try {
4481       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4482     } catch (std::out_of_range& e) {
4483       {
4484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4485       };
4486     } catch (std::exception& e) {
4487       {
4488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4489       };
4490     } catch (...) {
4491       {
4492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4493       };
4494     }
4495   }
4496   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4497   return jresult;
4498 }
4499
4500
4501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4502   void * jresult ;
4503   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4504   Dali::Vector2 *arg2 = 0 ;
4505   Dali::Vector2 *result = 0 ;
4506
4507   arg1 = (Dali::Vector2 *)jarg1;
4508   arg2 = (Dali::Vector2 *)jarg2;
4509   if (!arg2) {
4510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4511     return 0;
4512   }
4513   {
4514     try {
4515       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4516     } catch (std::out_of_range& e) {
4517       {
4518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4519       };
4520     } catch (std::exception& e) {
4521       {
4522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4523       };
4524     } catch (...) {
4525       {
4526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4527       };
4528     }
4529   }
4530   jresult = (void *)result;
4531   return jresult;
4532 }
4533
4534
4535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4536   void * jresult ;
4537   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4538   float arg2 ;
4539   Dali::Vector2 *result = 0 ;
4540
4541   arg1 = (Dali::Vector2 *)jarg1;
4542   arg2 = (float)jarg2;
4543   {
4544     try {
4545       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4546     } catch (std::out_of_range& e) {
4547       {
4548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4549       };
4550     } catch (std::exception& e) {
4551       {
4552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4553       };
4554     } catch (...) {
4555       {
4556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4557       };
4558     }
4559   }
4560   jresult = (void *)result;
4561   return jresult;
4562 }
4563
4564
4565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4566   void * jresult ;
4567   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4568   Dali::Vector2 result;
4569
4570   arg1 = (Dali::Vector2 *)jarg1;
4571   {
4572     try {
4573       result = ((Dali::Vector2 const *)arg1)->operator -();
4574     } catch (std::out_of_range& e) {
4575       {
4576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4577       };
4578     } catch (std::exception& e) {
4579       {
4580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4581       };
4582     } catch (...) {
4583       {
4584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4585       };
4586     }
4587   }
4588   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4589   return jresult;
4590 }
4591
4592
4593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4594   unsigned int jresult ;
4595   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4596   Dali::Vector2 *arg2 = 0 ;
4597   bool result;
4598
4599   arg1 = (Dali::Vector2 *)jarg1;
4600   arg2 = (Dali::Vector2 *)jarg2;
4601   if (!arg2) {
4602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4603     return 0;
4604   }
4605   {
4606     try {
4607       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4608     } catch (std::out_of_range& e) {
4609       {
4610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4611       };
4612     } catch (std::exception& e) {
4613       {
4614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4615       };
4616     } catch (...) {
4617       {
4618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4619       };
4620     }
4621   }
4622   jresult = result;
4623   return jresult;
4624 }
4625
4626
4627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4628   unsigned int jresult ;
4629   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4630   Dali::Vector2 *arg2 = 0 ;
4631   bool result;
4632
4633   arg1 = (Dali::Vector2 *)jarg1;
4634   arg2 = (Dali::Vector2 *)jarg2;
4635   if (!arg2) {
4636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4637     return 0;
4638   }
4639   {
4640     try {
4641       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4642     } catch (std::out_of_range& e) {
4643       {
4644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4645       };
4646     } catch (std::exception& e) {
4647       {
4648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4649       };
4650     } catch (...) {
4651       {
4652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4653       };
4654     }
4655   }
4656   jresult = result;
4657   return jresult;
4658 }
4659
4660
4661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4662   float jresult ;
4663   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4664   unsigned int arg2 ;
4665   float *result = 0 ;
4666
4667   arg1 = (Dali::Vector2 *)jarg1;
4668   arg2 = (unsigned int)jarg2;
4669   {
4670     try {
4671       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4672     } catch (std::out_of_range& e) {
4673       {
4674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4675       };
4676     } catch (std::exception& e) {
4677       {
4678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4679       };
4680     } catch (...) {
4681       {
4682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4683       };
4684     }
4685   }
4686   jresult = *result;
4687   return jresult;
4688 }
4689
4690
4691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4692   float jresult ;
4693   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4694   float result;
4695
4696   arg1 = (Dali::Vector2 *)jarg1;
4697   {
4698     try {
4699       result = (float)((Dali::Vector2 const *)arg1)->Length();
4700     } catch (std::out_of_range& e) {
4701       {
4702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4703       };
4704     } catch (std::exception& e) {
4705       {
4706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4707       };
4708     } catch (...) {
4709       {
4710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4711       };
4712     }
4713   }
4714   jresult = result;
4715   return jresult;
4716 }
4717
4718
4719 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4720   float jresult ;
4721   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4722   float result;
4723
4724   arg1 = (Dali::Vector2 *)jarg1;
4725   {
4726     try {
4727       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4728     } catch (std::out_of_range& e) {
4729       {
4730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4731       };
4732     } catch (std::exception& e) {
4733       {
4734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4735       };
4736     } catch (...) {
4737       {
4738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4739       };
4740     }
4741   }
4742   jresult = result;
4743   return jresult;
4744 }
4745
4746
4747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4748   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4749
4750   arg1 = (Dali::Vector2 *)jarg1;
4751   {
4752     try {
4753       (arg1)->Normalize();
4754     } catch (std::out_of_range& e) {
4755       {
4756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4757       };
4758     } catch (std::exception& e) {
4759       {
4760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4761       };
4762     } catch (...) {
4763       {
4764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4765       };
4766     }
4767   }
4768 }
4769
4770
4771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4772   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4773   Dali::Vector2 *arg2 = 0 ;
4774   Dali::Vector2 *arg3 = 0 ;
4775
4776   arg1 = (Dali::Vector2 *)jarg1;
4777   arg2 = (Dali::Vector2 *)jarg2;
4778   if (!arg2) {
4779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4780     return ;
4781   }
4782   arg3 = (Dali::Vector2 *)jarg3;
4783   if (!arg3) {
4784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4785     return ;
4786   }
4787   {
4788     try {
4789       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4790     } catch (std::out_of_range& e) {
4791       {
4792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4793       };
4794     } catch (std::exception& e) {
4795       {
4796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4797       };
4798     } catch (...) {
4799       {
4800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4801       };
4802     }
4803   }
4804 }
4805
4806
4807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4808   void * jresult ;
4809   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4810   float *result = 0 ;
4811
4812   arg1 = (Dali::Vector2 *)jarg1;
4813   {
4814     try {
4815       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4816     } catch (std::out_of_range& e) {
4817       {
4818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4819       };
4820     } catch (std::exception& e) {
4821       {
4822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4823       };
4824     } catch (...) {
4825       {
4826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4827       };
4828     }
4829   }
4830   jresult = (void *)result;
4831   return jresult;
4832 }
4833
4834
4835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4836   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4837   float arg2 ;
4838
4839   arg1 = (Dali::Vector2 *)jarg1;
4840   arg2 = (float)jarg2;
4841   if (arg1) (arg1)->x = arg2;
4842 }
4843
4844
4845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4846   float jresult ;
4847   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4848   float result;
4849
4850   arg1 = (Dali::Vector2 *)jarg1;
4851   result = (float) ((arg1)->x);
4852   jresult = result;
4853   return jresult;
4854 }
4855
4856
4857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4858   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4859   float arg2 ;
4860
4861   arg1 = (Dali::Vector2 *)jarg1;
4862   arg2 = (float)jarg2;
4863   if (arg1) (arg1)->width = arg2;
4864 }
4865
4866
4867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4868   float jresult ;
4869   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4870   float result;
4871
4872   arg1 = (Dali::Vector2 *)jarg1;
4873   result = (float) ((arg1)->width);
4874   jresult = result;
4875   return jresult;
4876 }
4877
4878
4879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4880   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4881   float arg2 ;
4882
4883   arg1 = (Dali::Vector2 *)jarg1;
4884   arg2 = (float)jarg2;
4885   if (arg1) (arg1)->y = arg2;
4886 }
4887
4888
4889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4890   float jresult ;
4891   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4892   float result;
4893
4894   arg1 = (Dali::Vector2 *)jarg1;
4895   result = (float) ((arg1)->y);
4896   jresult = result;
4897   return jresult;
4898 }
4899
4900
4901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4902   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4903   float arg2 ;
4904
4905   arg1 = (Dali::Vector2 *)jarg1;
4906   arg2 = (float)jarg2;
4907   if (arg1) (arg1)->height = arg2;
4908 }
4909
4910
4911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4912   float jresult ;
4913   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4914   float result;
4915
4916   arg1 = (Dali::Vector2 *)jarg1;
4917   result = (float) ((arg1)->height);
4918   jresult = result;
4919   return jresult;
4920 }
4921
4922
4923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4924   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4925
4926   arg1 = (Dali::Vector2 *)jarg1;
4927   {
4928     try {
4929       delete arg1;
4930     } catch (std::out_of_range& e) {
4931       {
4932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4933       };
4934     } catch (std::exception& e) {
4935       {
4936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4937       };
4938     } catch (...) {
4939       {
4940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4941       };
4942     }
4943   }
4944 }
4945
4946
4947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4948   void * jresult ;
4949   Dali::Vector2 *arg1 = 0 ;
4950   Dali::Vector2 *arg2 = 0 ;
4951   Dali::Vector2 result;
4952
4953   arg1 = (Dali::Vector2 *)jarg1;
4954   if (!arg1) {
4955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4956     return 0;
4957   }
4958   arg2 = (Dali::Vector2 *)jarg2;
4959   if (!arg2) {
4960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4961     return 0;
4962   }
4963   {
4964     try {
4965       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4966     } catch (std::out_of_range& e) {
4967       {
4968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4969       };
4970     } catch (std::exception& e) {
4971       {
4972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4973       };
4974     } catch (...) {
4975       {
4976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4977       };
4978     }
4979   }
4980   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4981   return jresult;
4982 }
4983
4984
4985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4986   void * jresult ;
4987   Dali::Vector2 *arg1 = 0 ;
4988   Dali::Vector2 *arg2 = 0 ;
4989   Dali::Vector2 result;
4990
4991   arg1 = (Dali::Vector2 *)jarg1;
4992   if (!arg1) {
4993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4994     return 0;
4995   }
4996   arg2 = (Dali::Vector2 *)jarg2;
4997   if (!arg2) {
4998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4999     return 0;
5000   }
5001   {
5002     try {
5003       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5004     } catch (std::out_of_range& e) {
5005       {
5006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5007       };
5008     } catch (std::exception& e) {
5009       {
5010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5011       };
5012     } catch (...) {
5013       {
5014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5015       };
5016     }
5017   }
5018   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5019   return jresult;
5020 }
5021
5022
5023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5024   void * jresult ;
5025   Dali::Vector2 *arg1 = 0 ;
5026   float *arg2 = 0 ;
5027   float *arg3 = 0 ;
5028   float temp2 ;
5029   float temp3 ;
5030   Dali::Vector2 result;
5031
5032   arg1 = (Dali::Vector2 *)jarg1;
5033   if (!arg1) {
5034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5035     return 0;
5036   }
5037   temp2 = (float)jarg2;
5038   arg2 = &temp2;
5039   temp3 = (float)jarg3;
5040   arg3 = &temp3;
5041   {
5042     try {
5043       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5044     } catch (std::out_of_range& e) {
5045       {
5046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5047       };
5048     } catch (std::exception& e) {
5049       {
5050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5051       };
5052     } catch (...) {
5053       {
5054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5055       };
5056     }
5057   }
5058   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5059   return jresult;
5060 }
5061
5062
5063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5064   void * jresult ;
5065   Dali::Vector3 *result = 0 ;
5066
5067   {
5068     try {
5069       result = (Dali::Vector3 *)new Dali::Vector3();
5070     } catch (std::out_of_range& e) {
5071       {
5072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5073       };
5074     } catch (std::exception& e) {
5075       {
5076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5077       };
5078     } catch (...) {
5079       {
5080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5081       };
5082     }
5083   }
5084   jresult = (void *)result;
5085   return jresult;
5086 }
5087
5088
5089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5090   void * jresult ;
5091   float arg1 ;
5092   float arg2 ;
5093   float arg3 ;
5094   Dali::Vector3 *result = 0 ;
5095
5096   arg1 = (float)jarg1;
5097   arg2 = (float)jarg2;
5098   arg3 = (float)jarg3;
5099   {
5100     try {
5101       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5102     } catch (std::out_of_range& e) {
5103       {
5104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5105       };
5106     } catch (std::exception& e) {
5107       {
5108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5109       };
5110     } catch (...) {
5111       {
5112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5113       };
5114     }
5115   }
5116   jresult = (void *)result;
5117   return jresult;
5118 }
5119
5120
5121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5122   void * jresult ;
5123   float *arg1 = (float *) 0 ;
5124   Dali::Vector3 *result = 0 ;
5125
5126   arg1 = jarg1;
5127   {
5128     try {
5129       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5130     } catch (std::out_of_range& e) {
5131       {
5132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5133       };
5134     } catch (std::exception& e) {
5135       {
5136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5137       };
5138     } catch (...) {
5139       {
5140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5141       };
5142     }
5143   }
5144   jresult = (void *)result;
5145
5146
5147   return jresult;
5148 }
5149
5150
5151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5152   void * jresult ;
5153   Dali::Vector2 *arg1 = 0 ;
5154   Dali::Vector3 *result = 0 ;
5155
5156   arg1 = (Dali::Vector2 *)jarg1;
5157   if (!arg1) {
5158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5159     return 0;
5160   }
5161   {
5162     try {
5163       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5164     } catch (std::out_of_range& e) {
5165       {
5166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5167       };
5168     } catch (std::exception& e) {
5169       {
5170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5171       };
5172     } catch (...) {
5173       {
5174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5175       };
5176     }
5177   }
5178   jresult = (void *)result;
5179   return jresult;
5180 }
5181
5182
5183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5184   void * jresult ;
5185   Dali::Vector4 *arg1 = 0 ;
5186   Dali::Vector3 *result = 0 ;
5187
5188   arg1 = (Dali::Vector4 *)jarg1;
5189   if (!arg1) {
5190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5191     return 0;
5192   }
5193   {
5194     try {
5195       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5196     } catch (std::out_of_range& e) {
5197       {
5198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5199       };
5200     } catch (std::exception& e) {
5201       {
5202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5203       };
5204     } catch (...) {
5205       {
5206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5207       };
5208     }
5209   }
5210   jresult = (void *)result;
5211   return jresult;
5212 }
5213
5214
5215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5216   void * jresult ;
5217   Dali::Vector3 *result = 0 ;
5218
5219   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5220   jresult = (void *)result;
5221   return jresult;
5222 }
5223
5224
5225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5226   void * jresult ;
5227   Dali::Vector3 *result = 0 ;
5228
5229   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5230   jresult = (void *)result;
5231   return jresult;
5232 }
5233
5234
5235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5236   void * jresult ;
5237   Dali::Vector3 *result = 0 ;
5238
5239   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5240   jresult = (void *)result;
5241   return jresult;
5242 }
5243
5244
5245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5246   void * jresult ;
5247   Dali::Vector3 *result = 0 ;
5248
5249   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5250   jresult = (void *)result;
5251   return jresult;
5252 }
5253
5254
5255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5256   void * jresult ;
5257   Dali::Vector3 *result = 0 ;
5258
5259   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5260   jresult = (void *)result;
5261   return jresult;
5262 }
5263
5264
5265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5266   void * jresult ;
5267   Dali::Vector3 *result = 0 ;
5268
5269   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5270   jresult = (void *)result;
5271   return jresult;
5272 }
5273
5274
5275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5276   void * jresult ;
5277   Dali::Vector3 *result = 0 ;
5278
5279   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5280   jresult = (void *)result;
5281   return jresult;
5282 }
5283
5284
5285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5286   void * jresult ;
5287   Dali::Vector3 *result = 0 ;
5288
5289   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5290   jresult = (void *)result;
5291   return jresult;
5292 }
5293
5294
5295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5296   void * jresult ;
5297   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5298   float *arg2 = (float *) 0 ;
5299   Dali::Vector3 *result = 0 ;
5300
5301   arg1 = (Dali::Vector3 *)jarg1;
5302   arg2 = jarg2;
5303   {
5304     try {
5305       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5306     } catch (std::out_of_range& e) {
5307       {
5308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5309       };
5310     } catch (std::exception& e) {
5311       {
5312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5313       };
5314     } catch (...) {
5315       {
5316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5317       };
5318     }
5319   }
5320   jresult = (void *)result;
5321
5322
5323   return jresult;
5324 }
5325
5326
5327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5328   void * jresult ;
5329   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5330   Dali::Vector2 *arg2 = 0 ;
5331   Dali::Vector3 *result = 0 ;
5332
5333   arg1 = (Dali::Vector3 *)jarg1;
5334   arg2 = (Dali::Vector2 *)jarg2;
5335   if (!arg2) {
5336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5337     return 0;
5338   }
5339   {
5340     try {
5341       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5342     } catch (std::out_of_range& e) {
5343       {
5344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5345       };
5346     } catch (std::exception& e) {
5347       {
5348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5349       };
5350     } catch (...) {
5351       {
5352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5353       };
5354     }
5355   }
5356   jresult = (void *)result;
5357   return jresult;
5358 }
5359
5360
5361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5362   void * jresult ;
5363   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5364   Dali::Vector4 *arg2 = 0 ;
5365   Dali::Vector3 *result = 0 ;
5366
5367   arg1 = (Dali::Vector3 *)jarg1;
5368   arg2 = (Dali::Vector4 *)jarg2;
5369   if (!arg2) {
5370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5371     return 0;
5372   }
5373   {
5374     try {
5375       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5376     } catch (std::out_of_range& e) {
5377       {
5378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5379       };
5380     } catch (std::exception& e) {
5381       {
5382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5383       };
5384     } catch (...) {
5385       {
5386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5387       };
5388     }
5389   }
5390   jresult = (void *)result;
5391   return jresult;
5392 }
5393
5394
5395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5396   void * jresult ;
5397   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5398   Dali::Vector3 *arg2 = 0 ;
5399   Dali::Vector3 result;
5400
5401   arg1 = (Dali::Vector3 *)jarg1;
5402   arg2 = (Dali::Vector3 *)jarg2;
5403   if (!arg2) {
5404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5405     return 0;
5406   }
5407   {
5408     try {
5409       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5410     } catch (std::out_of_range& e) {
5411       {
5412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5413       };
5414     } catch (std::exception& e) {
5415       {
5416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5417       };
5418     } catch (...) {
5419       {
5420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5421       };
5422     }
5423   }
5424   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5425   return jresult;
5426 }
5427
5428
5429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5430   void * jresult ;
5431   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5432   Dali::Vector3 *arg2 = 0 ;
5433   Dali::Vector3 *result = 0 ;
5434
5435   arg1 = (Dali::Vector3 *)jarg1;
5436   arg2 = (Dali::Vector3 *)jarg2;
5437   if (!arg2) {
5438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5439     return 0;
5440   }
5441   {
5442     try {
5443       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5444     } catch (std::out_of_range& e) {
5445       {
5446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5447       };
5448     } catch (std::exception& e) {
5449       {
5450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5451       };
5452     } catch (...) {
5453       {
5454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5455       };
5456     }
5457   }
5458   jresult = (void *)result;
5459   return jresult;
5460 }
5461
5462
5463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5464   void * jresult ;
5465   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5466   Dali::Vector3 *arg2 = 0 ;
5467   Dali::Vector3 result;
5468
5469   arg1 = (Dali::Vector3 *)jarg1;
5470   arg2 = (Dali::Vector3 *)jarg2;
5471   if (!arg2) {
5472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5473     return 0;
5474   }
5475   {
5476     try {
5477       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5478     } catch (std::out_of_range& e) {
5479       {
5480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5481       };
5482     } catch (std::exception& e) {
5483       {
5484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5485       };
5486     } catch (...) {
5487       {
5488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5489       };
5490     }
5491   }
5492   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5493   return jresult;
5494 }
5495
5496
5497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5498   void * jresult ;
5499   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5500   Dali::Vector3 *arg2 = 0 ;
5501   Dali::Vector3 *result = 0 ;
5502
5503   arg1 = (Dali::Vector3 *)jarg1;
5504   arg2 = (Dali::Vector3 *)jarg2;
5505   if (!arg2) {
5506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5507     return 0;
5508   }
5509   {
5510     try {
5511       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5512     } catch (std::out_of_range& e) {
5513       {
5514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5515       };
5516     } catch (std::exception& e) {
5517       {
5518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5519       };
5520     } catch (...) {
5521       {
5522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5523       };
5524     }
5525   }
5526   jresult = (void *)result;
5527   return jresult;
5528 }
5529
5530
5531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5532   void * jresult ;
5533   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5534   Dali::Vector3 *arg2 = 0 ;
5535   Dali::Vector3 result;
5536
5537   arg1 = (Dali::Vector3 *)jarg1;
5538   arg2 = (Dali::Vector3 *)jarg2;
5539   if (!arg2) {
5540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5541     return 0;
5542   }
5543   {
5544     try {
5545       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5546     } catch (std::out_of_range& e) {
5547       {
5548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5549       };
5550     } catch (std::exception& e) {
5551       {
5552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5553       };
5554     } catch (...) {
5555       {
5556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5557       };
5558     }
5559   }
5560   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5561   return jresult;
5562 }
5563
5564
5565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5566   void * jresult ;
5567   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5568   float arg2 ;
5569   Dali::Vector3 result;
5570
5571   arg1 = (Dali::Vector3 *)jarg1;
5572   arg2 = (float)jarg2;
5573   {
5574     try {
5575       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5576     } catch (std::out_of_range& e) {
5577       {
5578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5579       };
5580     } catch (std::exception& e) {
5581       {
5582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5583       };
5584     } catch (...) {
5585       {
5586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5587       };
5588     }
5589   }
5590   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5591   return jresult;
5592 }
5593
5594
5595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5596   void * jresult ;
5597   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5598   Dali::Vector3 *arg2 = 0 ;
5599   Dali::Vector3 *result = 0 ;
5600
5601   arg1 = (Dali::Vector3 *)jarg1;
5602   arg2 = (Dali::Vector3 *)jarg2;
5603   if (!arg2) {
5604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5605     return 0;
5606   }
5607   {
5608     try {
5609       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5610     } catch (std::out_of_range& e) {
5611       {
5612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5613       };
5614     } catch (std::exception& e) {
5615       {
5616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5617       };
5618     } catch (...) {
5619       {
5620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5621       };
5622     }
5623   }
5624   jresult = (void *)result;
5625   return jresult;
5626 }
5627
5628
5629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5630   void * jresult ;
5631   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5632   float arg2 ;
5633   Dali::Vector3 *result = 0 ;
5634
5635   arg1 = (Dali::Vector3 *)jarg1;
5636   arg2 = (float)jarg2;
5637   {
5638     try {
5639       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5640     } catch (std::out_of_range& e) {
5641       {
5642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5643       };
5644     } catch (std::exception& e) {
5645       {
5646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5647       };
5648     } catch (...) {
5649       {
5650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5651       };
5652     }
5653   }
5654   jresult = (void *)result;
5655   return jresult;
5656 }
5657
5658
5659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5660   void * jresult ;
5661   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5662   Dali::Quaternion *arg2 = 0 ;
5663   Dali::Vector3 *result = 0 ;
5664
5665   arg1 = (Dali::Vector3 *)jarg1;
5666   arg2 = (Dali::Quaternion *)jarg2;
5667   if (!arg2) {
5668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5669     return 0;
5670   }
5671   {
5672     try {
5673       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5674     } catch (std::out_of_range& e) {
5675       {
5676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5677       };
5678     } catch (std::exception& e) {
5679       {
5680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5681       };
5682     } catch (...) {
5683       {
5684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5685       };
5686     }
5687   }
5688   jresult = (void *)result;
5689   return jresult;
5690 }
5691
5692
5693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5694   void * jresult ;
5695   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5696   Dali::Vector3 *arg2 = 0 ;
5697   Dali::Vector3 result;
5698
5699   arg1 = (Dali::Vector3 *)jarg1;
5700   arg2 = (Dali::Vector3 *)jarg2;
5701   if (!arg2) {
5702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5703     return 0;
5704   }
5705   {
5706     try {
5707       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5708     } catch (std::out_of_range& e) {
5709       {
5710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5711       };
5712     } catch (std::exception& e) {
5713       {
5714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5715       };
5716     } catch (...) {
5717       {
5718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5719       };
5720     }
5721   }
5722   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5723   return jresult;
5724 }
5725
5726
5727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5728   void * jresult ;
5729   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5730   float arg2 ;
5731   Dali::Vector3 result;
5732
5733   arg1 = (Dali::Vector3 *)jarg1;
5734   arg2 = (float)jarg2;
5735   {
5736     try {
5737       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5738     } catch (std::out_of_range& e) {
5739       {
5740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5741       };
5742     } catch (std::exception& e) {
5743       {
5744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5745       };
5746     } catch (...) {
5747       {
5748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5749       };
5750     }
5751   }
5752   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5753   return jresult;
5754 }
5755
5756
5757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5758   void * jresult ;
5759   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5760   Dali::Vector3 *arg2 = 0 ;
5761   Dali::Vector3 *result = 0 ;
5762
5763   arg1 = (Dali::Vector3 *)jarg1;
5764   arg2 = (Dali::Vector3 *)jarg2;
5765   if (!arg2) {
5766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5767     return 0;
5768   }
5769   {
5770     try {
5771       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5772     } catch (std::out_of_range& e) {
5773       {
5774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5775       };
5776     } catch (std::exception& e) {
5777       {
5778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5779       };
5780     } catch (...) {
5781       {
5782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5783       };
5784     }
5785   }
5786   jresult = (void *)result;
5787   return jresult;
5788 }
5789
5790
5791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5792   void * jresult ;
5793   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5794   float arg2 ;
5795   Dali::Vector3 *result = 0 ;
5796
5797   arg1 = (Dali::Vector3 *)jarg1;
5798   arg2 = (float)jarg2;
5799   {
5800     try {
5801       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5802     } catch (std::out_of_range& e) {
5803       {
5804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5805       };
5806     } catch (std::exception& e) {
5807       {
5808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5809       };
5810     } catch (...) {
5811       {
5812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5813       };
5814     }
5815   }
5816   jresult = (void *)result;
5817   return jresult;
5818 }
5819
5820
5821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5822   void * jresult ;
5823   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5824   Dali::Vector3 result;
5825
5826   arg1 = (Dali::Vector3 *)jarg1;
5827   {
5828     try {
5829       result = ((Dali::Vector3 const *)arg1)->operator -();
5830     } catch (std::out_of_range& e) {
5831       {
5832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5833       };
5834     } catch (std::exception& e) {
5835       {
5836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5837       };
5838     } catch (...) {
5839       {
5840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5841       };
5842     }
5843   }
5844   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5845   return jresult;
5846 }
5847
5848
5849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5850   unsigned int jresult ;
5851   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5852   Dali::Vector3 *arg2 = 0 ;
5853   bool result;
5854
5855   arg1 = (Dali::Vector3 *)jarg1;
5856   arg2 = (Dali::Vector3 *)jarg2;
5857   if (!arg2) {
5858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5859     return 0;
5860   }
5861   {
5862     try {
5863       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5864     } catch (std::out_of_range& e) {
5865       {
5866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5867       };
5868     } catch (std::exception& e) {
5869       {
5870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5871       };
5872     } catch (...) {
5873       {
5874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5875       };
5876     }
5877   }
5878   jresult = result;
5879   return jresult;
5880 }
5881
5882
5883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5884   unsigned int jresult ;
5885   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5886   Dali::Vector3 *arg2 = 0 ;
5887   bool result;
5888
5889   arg1 = (Dali::Vector3 *)jarg1;
5890   arg2 = (Dali::Vector3 *)jarg2;
5891   if (!arg2) {
5892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5893     return 0;
5894   }
5895   {
5896     try {
5897       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5898     } catch (std::out_of_range& e) {
5899       {
5900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5901       };
5902     } catch (std::exception& e) {
5903       {
5904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5905       };
5906     } catch (...) {
5907       {
5908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5909       };
5910     }
5911   }
5912   jresult = result;
5913   return jresult;
5914 }
5915
5916
5917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5918   float jresult ;
5919   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5920   unsigned int arg2 ;
5921   float *result = 0 ;
5922
5923   arg1 = (Dali::Vector3 *)jarg1;
5924   arg2 = (unsigned int)jarg2;
5925   {
5926     try {
5927       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5928     } catch (std::out_of_range& e) {
5929       {
5930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5931       };
5932     } catch (std::exception& e) {
5933       {
5934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5935       };
5936     } catch (...) {
5937       {
5938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5939       };
5940     }
5941   }
5942   jresult = *result;
5943   return jresult;
5944 }
5945
5946
5947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5948   float jresult ;
5949   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5950   Dali::Vector3 *arg2 = 0 ;
5951   float result;
5952
5953   arg1 = (Dali::Vector3 *)jarg1;
5954   arg2 = (Dali::Vector3 *)jarg2;
5955   if (!arg2) {
5956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5957     return 0;
5958   }
5959   {
5960     try {
5961       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5962     } catch (std::out_of_range& e) {
5963       {
5964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5965       };
5966     } catch (std::exception& e) {
5967       {
5968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5969       };
5970     } catch (...) {
5971       {
5972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5973       };
5974     }
5975   }
5976   jresult = result;
5977   return jresult;
5978 }
5979
5980
5981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5982   void * jresult ;
5983   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5984   Dali::Vector3 *arg2 = 0 ;
5985   Dali::Vector3 result;
5986
5987   arg1 = (Dali::Vector3 *)jarg1;
5988   arg2 = (Dali::Vector3 *)jarg2;
5989   if (!arg2) {
5990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5991     return 0;
5992   }
5993   {
5994     try {
5995       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5996     } catch (std::out_of_range& e) {
5997       {
5998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5999       };
6000     } catch (std::exception& e) {
6001       {
6002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6003       };
6004     } catch (...) {
6005       {
6006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6007       };
6008     }
6009   }
6010   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6011   return jresult;
6012 }
6013
6014
6015 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6016   float jresult ;
6017   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6018   float result;
6019
6020   arg1 = (Dali::Vector3 *)jarg1;
6021   {
6022     try {
6023       result = (float)((Dali::Vector3 const *)arg1)->Length();
6024     } catch (std::out_of_range& e) {
6025       {
6026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6027       };
6028     } catch (std::exception& e) {
6029       {
6030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6031       };
6032     } catch (...) {
6033       {
6034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6035       };
6036     }
6037   }
6038   jresult = result;
6039   return jresult;
6040 }
6041
6042
6043 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6044   float jresult ;
6045   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6046   float result;
6047
6048   arg1 = (Dali::Vector3 *)jarg1;
6049   {
6050     try {
6051       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6052     } catch (std::out_of_range& e) {
6053       {
6054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6055       };
6056     } catch (std::exception& e) {
6057       {
6058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6059       };
6060     } catch (...) {
6061       {
6062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6063       };
6064     }
6065   }
6066   jresult = result;
6067   return jresult;
6068 }
6069
6070
6071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6072   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6073
6074   arg1 = (Dali::Vector3 *)jarg1;
6075   {
6076     try {
6077       (arg1)->Normalize();
6078     } catch (std::out_of_range& e) {
6079       {
6080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6081       };
6082     } catch (std::exception& e) {
6083       {
6084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6085       };
6086     } catch (...) {
6087       {
6088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6089       };
6090     }
6091   }
6092 }
6093
6094
6095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6096   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6097   Dali::Vector3 *arg2 = 0 ;
6098   Dali::Vector3 *arg3 = 0 ;
6099
6100   arg1 = (Dali::Vector3 *)jarg1;
6101   arg2 = (Dali::Vector3 *)jarg2;
6102   if (!arg2) {
6103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6104     return ;
6105   }
6106   arg3 = (Dali::Vector3 *)jarg3;
6107   if (!arg3) {
6108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6109     return ;
6110   }
6111   {
6112     try {
6113       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6114     } catch (std::out_of_range& e) {
6115       {
6116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6117       };
6118     } catch (std::exception& e) {
6119       {
6120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6121       };
6122     } catch (...) {
6123       {
6124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6125       };
6126     }
6127   }
6128 }
6129
6130
6131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6132   void * jresult ;
6133   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6134   float *result = 0 ;
6135
6136   arg1 = (Dali::Vector3 *)jarg1;
6137   {
6138     try {
6139       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6140     } catch (std::out_of_range& e) {
6141       {
6142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6143       };
6144     } catch (std::exception& e) {
6145       {
6146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6147       };
6148     } catch (...) {
6149       {
6150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6151       };
6152     }
6153   }
6154   jresult = (void *)result;
6155   return jresult;
6156 }
6157
6158
6159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6160   void * jresult ;
6161   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6162   Dali::Vector2 *result = 0 ;
6163
6164   arg1 = (Dali::Vector3 *)jarg1;
6165   {
6166     try {
6167       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6168     } catch (std::out_of_range& e) {
6169       {
6170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6171       };
6172     } catch (std::exception& e) {
6173       {
6174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6175       };
6176     } catch (...) {
6177       {
6178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6179       };
6180     }
6181   }
6182   jresult = (void *)result;
6183   return jresult;
6184 }
6185
6186
6187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6188   void * jresult ;
6189   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6190   Dali::Vector2 *result = 0 ;
6191
6192   arg1 = (Dali::Vector3 *)jarg1;
6193   {
6194     try {
6195       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6196     } catch (std::out_of_range& e) {
6197       {
6198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6199       };
6200     } catch (std::exception& e) {
6201       {
6202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6203       };
6204     } catch (...) {
6205       {
6206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6207       };
6208     }
6209   }
6210   jresult = (void *)result;
6211   return jresult;
6212 }
6213
6214
6215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6216   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6217   float arg2 ;
6218
6219   arg1 = (Dali::Vector3 *)jarg1;
6220   arg2 = (float)jarg2;
6221   if (arg1) (arg1)->x = arg2;
6222 }
6223
6224
6225 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6226   float jresult ;
6227   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6228   float result;
6229
6230   arg1 = (Dali::Vector3 *)jarg1;
6231   result = (float) ((arg1)->x);
6232   jresult = result;
6233   return jresult;
6234 }
6235
6236
6237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6238   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6239   float arg2 ;
6240
6241   arg1 = (Dali::Vector3 *)jarg1;
6242   arg2 = (float)jarg2;
6243   if (arg1) (arg1)->width = arg2;
6244 }
6245
6246
6247 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6248   float jresult ;
6249   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6250   float result;
6251
6252   arg1 = (Dali::Vector3 *)jarg1;
6253   result = (float) ((arg1)->width);
6254   jresult = result;
6255   return jresult;
6256 }
6257
6258
6259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6260   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6261   float arg2 ;
6262
6263   arg1 = (Dali::Vector3 *)jarg1;
6264   arg2 = (float)jarg2;
6265   if (arg1) (arg1)->r = arg2;
6266 }
6267
6268
6269 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6270   float jresult ;
6271   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6272   float result;
6273
6274   arg1 = (Dali::Vector3 *)jarg1;
6275   result = (float) ((arg1)->r);
6276   jresult = result;
6277   return jresult;
6278 }
6279
6280
6281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6282   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6283   float arg2 ;
6284
6285   arg1 = (Dali::Vector3 *)jarg1;
6286   arg2 = (float)jarg2;
6287   if (arg1) (arg1)->y = arg2;
6288 }
6289
6290
6291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6292   float jresult ;
6293   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6294   float result;
6295
6296   arg1 = (Dali::Vector3 *)jarg1;
6297   result = (float) ((arg1)->y);
6298   jresult = result;
6299   return jresult;
6300 }
6301
6302
6303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6304   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6305   float arg2 ;
6306
6307   arg1 = (Dali::Vector3 *)jarg1;
6308   arg2 = (float)jarg2;
6309   if (arg1) (arg1)->height = arg2;
6310 }
6311
6312
6313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6314   float jresult ;
6315   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6316   float result;
6317
6318   arg1 = (Dali::Vector3 *)jarg1;
6319   result = (float) ((arg1)->height);
6320   jresult = result;
6321   return jresult;
6322 }
6323
6324
6325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6326   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6327   float arg2 ;
6328
6329   arg1 = (Dali::Vector3 *)jarg1;
6330   arg2 = (float)jarg2;
6331   if (arg1) (arg1)->g = arg2;
6332 }
6333
6334
6335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6336   float jresult ;
6337   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6338   float result;
6339
6340   arg1 = (Dali::Vector3 *)jarg1;
6341   result = (float) ((arg1)->g);
6342   jresult = result;
6343   return jresult;
6344 }
6345
6346
6347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6348   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6349   float arg2 ;
6350
6351   arg1 = (Dali::Vector3 *)jarg1;
6352   arg2 = (float)jarg2;
6353   if (arg1) (arg1)->z = arg2;
6354 }
6355
6356
6357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6358   float jresult ;
6359   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6360   float result;
6361
6362   arg1 = (Dali::Vector3 *)jarg1;
6363   result = (float) ((arg1)->z);
6364   jresult = result;
6365   return jresult;
6366 }
6367
6368
6369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6370   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6371   float arg2 ;
6372
6373   arg1 = (Dali::Vector3 *)jarg1;
6374   arg2 = (float)jarg2;
6375   if (arg1) (arg1)->depth = arg2;
6376 }
6377
6378
6379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6380   float jresult ;
6381   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6382   float result;
6383
6384   arg1 = (Dali::Vector3 *)jarg1;
6385   result = (float) ((arg1)->depth);
6386   jresult = result;
6387   return jresult;
6388 }
6389
6390
6391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6392   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6393   float arg2 ;
6394
6395   arg1 = (Dali::Vector3 *)jarg1;
6396   arg2 = (float)jarg2;
6397   if (arg1) (arg1)->b = arg2;
6398 }
6399
6400
6401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6402   float jresult ;
6403   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6404   float result;
6405
6406   arg1 = (Dali::Vector3 *)jarg1;
6407   result = (float) ((arg1)->b);
6408   jresult = result;
6409   return jresult;
6410 }
6411
6412
6413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6414   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6415
6416   arg1 = (Dali::Vector3 *)jarg1;
6417   {
6418     try {
6419       delete arg1;
6420     } catch (std::out_of_range& e) {
6421       {
6422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6423       };
6424     } catch (std::exception& e) {
6425       {
6426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6427       };
6428     } catch (...) {
6429       {
6430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6431       };
6432     }
6433   }
6434 }
6435
6436
6437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6438   void * jresult ;
6439   Dali::Vector3 *arg1 = 0 ;
6440   Dali::Vector3 *arg2 = 0 ;
6441   Dali::Vector3 result;
6442
6443   arg1 = (Dali::Vector3 *)jarg1;
6444   if (!arg1) {
6445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6446     return 0;
6447   }
6448   arg2 = (Dali::Vector3 *)jarg2;
6449   if (!arg2) {
6450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6451     return 0;
6452   }
6453   {
6454     try {
6455       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6456     } catch (std::out_of_range& e) {
6457       {
6458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6459       };
6460     } catch (std::exception& e) {
6461       {
6462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6463       };
6464     } catch (...) {
6465       {
6466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6467       };
6468     }
6469   }
6470   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6471   return jresult;
6472 }
6473
6474
6475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6476   void * jresult ;
6477   Dali::Vector3 *arg1 = 0 ;
6478   Dali::Vector3 *arg2 = 0 ;
6479   Dali::Vector3 result;
6480
6481   arg1 = (Dali::Vector3 *)jarg1;
6482   if (!arg1) {
6483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6484     return 0;
6485   }
6486   arg2 = (Dali::Vector3 *)jarg2;
6487   if (!arg2) {
6488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6489     return 0;
6490   }
6491   {
6492     try {
6493       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6494     } catch (std::out_of_range& e) {
6495       {
6496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6497       };
6498     } catch (std::exception& e) {
6499       {
6500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6501       };
6502     } catch (...) {
6503       {
6504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6505       };
6506     }
6507   }
6508   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6509   return jresult;
6510 }
6511
6512
6513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6514   void * jresult ;
6515   Dali::Vector3 *arg1 = 0 ;
6516   float *arg2 = 0 ;
6517   float *arg3 = 0 ;
6518   float temp2 ;
6519   float temp3 ;
6520   Dali::Vector3 result;
6521
6522   arg1 = (Dali::Vector3 *)jarg1;
6523   if (!arg1) {
6524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6525     return 0;
6526   }
6527   temp2 = (float)jarg2;
6528   arg2 = &temp2;
6529   temp3 = (float)jarg3;
6530   arg3 = &temp3;
6531   {
6532     try {
6533       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6534     } catch (std::out_of_range& e) {
6535       {
6536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6537       };
6538     } catch (std::exception& e) {
6539       {
6540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6541       };
6542     } catch (...) {
6543       {
6544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6545       };
6546     }
6547   }
6548   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6549   return jresult;
6550 }
6551
6552
6553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6554   void * jresult ;
6555   Dali::Vector4 *result = 0 ;
6556
6557   {
6558     try {
6559       result = (Dali::Vector4 *)new Dali::Vector4();
6560     } catch (std::out_of_range& e) {
6561       {
6562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6563       };
6564     } catch (std::exception& e) {
6565       {
6566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6567       };
6568     } catch (...) {
6569       {
6570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6571       };
6572     }
6573   }
6574   jresult = (void *)result;
6575   return jresult;
6576 }
6577
6578
6579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6580   void * jresult ;
6581   float arg1 ;
6582   float arg2 ;
6583   float arg3 ;
6584   float arg4 ;
6585   Dali::Vector4 *result = 0 ;
6586
6587   arg1 = (float)jarg1;
6588   arg2 = (float)jarg2;
6589   arg3 = (float)jarg3;
6590   arg4 = (float)jarg4;
6591   {
6592     try {
6593       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6594     } catch (std::out_of_range& e) {
6595       {
6596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6597       };
6598     } catch (std::exception& e) {
6599       {
6600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6601       };
6602     } catch (...) {
6603       {
6604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6605       };
6606     }
6607   }
6608   jresult = (void *)result;
6609   return jresult;
6610 }
6611
6612
6613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6614   void * jresult ;
6615   float *arg1 = (float *) 0 ;
6616   Dali::Vector4 *result = 0 ;
6617
6618   arg1 = jarg1;
6619   {
6620     try {
6621       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6622     } catch (std::out_of_range& e) {
6623       {
6624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6625       };
6626     } catch (std::exception& e) {
6627       {
6628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6629       };
6630     } catch (...) {
6631       {
6632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6633       };
6634     }
6635   }
6636   jresult = (void *)result;
6637
6638
6639   return jresult;
6640 }
6641
6642
6643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6644   void * jresult ;
6645   Dali::Vector2 *arg1 = 0 ;
6646   Dali::Vector4 *result = 0 ;
6647
6648   arg1 = (Dali::Vector2 *)jarg1;
6649   if (!arg1) {
6650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6651     return 0;
6652   }
6653   {
6654     try {
6655       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6656     } catch (std::out_of_range& e) {
6657       {
6658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6659       };
6660     } catch (std::exception& e) {
6661       {
6662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6663       };
6664     } catch (...) {
6665       {
6666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6667       };
6668     }
6669   }
6670   jresult = (void *)result;
6671   return jresult;
6672 }
6673
6674
6675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6676   void * jresult ;
6677   Dali::Vector3 *arg1 = 0 ;
6678   Dali::Vector4 *result = 0 ;
6679
6680   arg1 = (Dali::Vector3 *)jarg1;
6681   if (!arg1) {
6682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6683     return 0;
6684   }
6685   {
6686     try {
6687       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6688     } catch (std::out_of_range& e) {
6689       {
6690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6691       };
6692     } catch (std::exception& e) {
6693       {
6694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6695       };
6696     } catch (...) {
6697       {
6698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6699       };
6700     }
6701   }
6702   jresult = (void *)result;
6703   return jresult;
6704 }
6705
6706
6707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6708   void * jresult ;
6709   Dali::Vector4 *result = 0 ;
6710
6711   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6712   jresult = (void *)result;
6713   return jresult;
6714 }
6715
6716
6717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6718   void * jresult ;
6719   Dali::Vector4 *result = 0 ;
6720
6721   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6722   jresult = (void *)result;
6723   return jresult;
6724 }
6725
6726
6727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6728   void * jresult ;
6729   Dali::Vector4 *result = 0 ;
6730
6731   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6732   jresult = (void *)result;
6733   return jresult;
6734 }
6735
6736
6737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6738   void * jresult ;
6739   Dali::Vector4 *result = 0 ;
6740
6741   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6742   jresult = (void *)result;
6743   return jresult;
6744 }
6745
6746
6747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6748   void * jresult ;
6749   Dali::Vector4 *result = 0 ;
6750
6751   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6752   jresult = (void *)result;
6753   return jresult;
6754 }
6755
6756
6757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6758   void * jresult ;
6759   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6760   float *arg2 = (float *) 0 ;
6761   Dali::Vector4 *result = 0 ;
6762
6763   arg1 = (Dali::Vector4 *)jarg1;
6764   arg2 = jarg2;
6765   {
6766     try {
6767       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6768     } catch (std::out_of_range& e) {
6769       {
6770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6771       };
6772     } catch (std::exception& e) {
6773       {
6774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6775       };
6776     } catch (...) {
6777       {
6778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6779       };
6780     }
6781   }
6782   jresult = (void *)result;
6783
6784
6785   return jresult;
6786 }
6787
6788
6789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6790   void * jresult ;
6791   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6792   Dali::Vector2 *arg2 = 0 ;
6793   Dali::Vector4 *result = 0 ;
6794
6795   arg1 = (Dali::Vector4 *)jarg1;
6796   arg2 = (Dali::Vector2 *)jarg2;
6797   if (!arg2) {
6798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6799     return 0;
6800   }
6801   {
6802     try {
6803       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6804     } catch (std::out_of_range& e) {
6805       {
6806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6807       };
6808     } catch (std::exception& e) {
6809       {
6810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6811       };
6812     } catch (...) {
6813       {
6814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6815       };
6816     }
6817   }
6818   jresult = (void *)result;
6819   return jresult;
6820 }
6821
6822
6823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6824   void * jresult ;
6825   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6826   Dali::Vector3 *arg2 = 0 ;
6827   Dali::Vector4 *result = 0 ;
6828
6829   arg1 = (Dali::Vector4 *)jarg1;
6830   arg2 = (Dali::Vector3 *)jarg2;
6831   if (!arg2) {
6832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6833     return 0;
6834   }
6835   {
6836     try {
6837       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6838     } catch (std::out_of_range& e) {
6839       {
6840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6841       };
6842     } catch (std::exception& e) {
6843       {
6844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6845       };
6846     } catch (...) {
6847       {
6848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6849       };
6850     }
6851   }
6852   jresult = (void *)result;
6853   return jresult;
6854 }
6855
6856
6857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6858   void * jresult ;
6859   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6860   Dali::Vector4 *arg2 = 0 ;
6861   Dali::Vector4 result;
6862
6863   arg1 = (Dali::Vector4 *)jarg1;
6864   arg2 = (Dali::Vector4 *)jarg2;
6865   if (!arg2) {
6866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6867     return 0;
6868   }
6869   {
6870     try {
6871       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6872     } catch (std::out_of_range& e) {
6873       {
6874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6875       };
6876     } catch (std::exception& e) {
6877       {
6878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6879       };
6880     } catch (...) {
6881       {
6882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6883       };
6884     }
6885   }
6886   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6887   return jresult;
6888 }
6889
6890
6891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6892   void * jresult ;
6893   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6894   Dali::Vector4 *arg2 = 0 ;
6895   Dali::Vector4 *result = 0 ;
6896
6897   arg1 = (Dali::Vector4 *)jarg1;
6898   arg2 = (Dali::Vector4 *)jarg2;
6899   if (!arg2) {
6900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6901     return 0;
6902   }
6903   {
6904     try {
6905       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6906     } catch (std::out_of_range& e) {
6907       {
6908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6909       };
6910     } catch (std::exception& e) {
6911       {
6912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6913       };
6914     } catch (...) {
6915       {
6916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6917       };
6918     }
6919   }
6920   jresult = (void *)result;
6921   return jresult;
6922 }
6923
6924
6925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6926   void * jresult ;
6927   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6928   Dali::Vector4 *arg2 = 0 ;
6929   Dali::Vector4 result;
6930
6931   arg1 = (Dali::Vector4 *)jarg1;
6932   arg2 = (Dali::Vector4 *)jarg2;
6933   if (!arg2) {
6934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6935     return 0;
6936   }
6937   {
6938     try {
6939       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6940     } catch (std::out_of_range& e) {
6941       {
6942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6943       };
6944     } catch (std::exception& e) {
6945       {
6946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6947       };
6948     } catch (...) {
6949       {
6950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6951       };
6952     }
6953   }
6954   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6955   return jresult;
6956 }
6957
6958
6959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6960   void * jresult ;
6961   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6962   Dali::Vector4 *arg2 = 0 ;
6963   Dali::Vector4 *result = 0 ;
6964
6965   arg1 = (Dali::Vector4 *)jarg1;
6966   arg2 = (Dali::Vector4 *)jarg2;
6967   if (!arg2) {
6968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6969     return 0;
6970   }
6971   {
6972     try {
6973       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6974     } catch (std::out_of_range& e) {
6975       {
6976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6977       };
6978     } catch (std::exception& e) {
6979       {
6980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6981       };
6982     } catch (...) {
6983       {
6984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6985       };
6986     }
6987   }
6988   jresult = (void *)result;
6989   return jresult;
6990 }
6991
6992
6993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6994   void * jresult ;
6995   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6996   Dali::Vector4 *arg2 = 0 ;
6997   Dali::Vector4 result;
6998
6999   arg1 = (Dali::Vector4 *)jarg1;
7000   arg2 = (Dali::Vector4 *)jarg2;
7001   if (!arg2) {
7002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7003     return 0;
7004   }
7005   {
7006     try {
7007       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7008     } catch (std::out_of_range& e) {
7009       {
7010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7011       };
7012     } catch (std::exception& e) {
7013       {
7014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7015       };
7016     } catch (...) {
7017       {
7018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7019       };
7020     }
7021   }
7022   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7023   return jresult;
7024 }
7025
7026
7027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7028   void * jresult ;
7029   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7030   float arg2 ;
7031   Dali::Vector4 result;
7032
7033   arg1 = (Dali::Vector4 *)jarg1;
7034   arg2 = (float)jarg2;
7035   {
7036     try {
7037       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7038     } catch (std::out_of_range& e) {
7039       {
7040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7041       };
7042     } catch (std::exception& e) {
7043       {
7044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7045       };
7046     } catch (...) {
7047       {
7048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7049       };
7050     }
7051   }
7052   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7053   return jresult;
7054 }
7055
7056
7057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7058   void * jresult ;
7059   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7060   Dali::Vector4 *arg2 = 0 ;
7061   Dali::Vector4 *result = 0 ;
7062
7063   arg1 = (Dali::Vector4 *)jarg1;
7064   arg2 = (Dali::Vector4 *)jarg2;
7065   if (!arg2) {
7066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7067     return 0;
7068   }
7069   {
7070     try {
7071       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7072     } catch (std::out_of_range& e) {
7073       {
7074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7075       };
7076     } catch (std::exception& e) {
7077       {
7078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7079       };
7080     } catch (...) {
7081       {
7082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7083       };
7084     }
7085   }
7086   jresult = (void *)result;
7087   return jresult;
7088 }
7089
7090
7091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7092   void * jresult ;
7093   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7094   float arg2 ;
7095   Dali::Vector4 *result = 0 ;
7096
7097   arg1 = (Dali::Vector4 *)jarg1;
7098   arg2 = (float)jarg2;
7099   {
7100     try {
7101       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7102     } catch (std::out_of_range& e) {
7103       {
7104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7105       };
7106     } catch (std::exception& e) {
7107       {
7108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7109       };
7110     } catch (...) {
7111       {
7112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7113       };
7114     }
7115   }
7116   jresult = (void *)result;
7117   return jresult;
7118 }
7119
7120
7121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7122   void * jresult ;
7123   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7124   Dali::Vector4 *arg2 = 0 ;
7125   Dali::Vector4 result;
7126
7127   arg1 = (Dali::Vector4 *)jarg1;
7128   arg2 = (Dali::Vector4 *)jarg2;
7129   if (!arg2) {
7130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7131     return 0;
7132   }
7133   {
7134     try {
7135       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7136     } catch (std::out_of_range& e) {
7137       {
7138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7139       };
7140     } catch (std::exception& e) {
7141       {
7142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7143       };
7144     } catch (...) {
7145       {
7146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7147       };
7148     }
7149   }
7150   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7151   return jresult;
7152 }
7153
7154
7155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7156   void * jresult ;
7157   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7158   float arg2 ;
7159   Dali::Vector4 result;
7160
7161   arg1 = (Dali::Vector4 *)jarg1;
7162   arg2 = (float)jarg2;
7163   {
7164     try {
7165       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7166     } catch (std::out_of_range& e) {
7167       {
7168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7169       };
7170     } catch (std::exception& e) {
7171       {
7172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7173       };
7174     } catch (...) {
7175       {
7176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7177       };
7178     }
7179   }
7180   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7181   return jresult;
7182 }
7183
7184
7185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7186   void * jresult ;
7187   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7188   Dali::Vector4 *arg2 = 0 ;
7189   Dali::Vector4 *result = 0 ;
7190
7191   arg1 = (Dali::Vector4 *)jarg1;
7192   arg2 = (Dali::Vector4 *)jarg2;
7193   if (!arg2) {
7194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7195     return 0;
7196   }
7197   {
7198     try {
7199       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7200     } catch (std::out_of_range& e) {
7201       {
7202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7203       };
7204     } catch (std::exception& e) {
7205       {
7206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7207       };
7208     } catch (...) {
7209       {
7210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7211       };
7212     }
7213   }
7214   jresult = (void *)result;
7215   return jresult;
7216 }
7217
7218
7219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7220   void * jresult ;
7221   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7222   float arg2 ;
7223   Dali::Vector4 *result = 0 ;
7224
7225   arg1 = (Dali::Vector4 *)jarg1;
7226   arg2 = (float)jarg2;
7227   {
7228     try {
7229       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7230     } catch (std::out_of_range& e) {
7231       {
7232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7233       };
7234     } catch (std::exception& e) {
7235       {
7236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7237       };
7238     } catch (...) {
7239       {
7240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7241       };
7242     }
7243   }
7244   jresult = (void *)result;
7245   return jresult;
7246 }
7247
7248
7249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7250   void * jresult ;
7251   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7252   Dali::Vector4 result;
7253
7254   arg1 = (Dali::Vector4 *)jarg1;
7255   {
7256     try {
7257       result = ((Dali::Vector4 const *)arg1)->operator -();
7258     } catch (std::out_of_range& e) {
7259       {
7260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7261       };
7262     } catch (std::exception& e) {
7263       {
7264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7265       };
7266     } catch (...) {
7267       {
7268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7269       };
7270     }
7271   }
7272   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7273   return jresult;
7274 }
7275
7276
7277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7278   unsigned int jresult ;
7279   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7280   Dali::Vector4 *arg2 = 0 ;
7281   bool result;
7282
7283   arg1 = (Dali::Vector4 *)jarg1;
7284   arg2 = (Dali::Vector4 *)jarg2;
7285   if (!arg2) {
7286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7287     return 0;
7288   }
7289   {
7290     try {
7291       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7292     } catch (std::out_of_range& e) {
7293       {
7294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7295       };
7296     } catch (std::exception& e) {
7297       {
7298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7299       };
7300     } catch (...) {
7301       {
7302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7303       };
7304     }
7305   }
7306   jresult = result;
7307   return jresult;
7308 }
7309
7310
7311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7312   unsigned int jresult ;
7313   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7314   Dali::Vector4 *arg2 = 0 ;
7315   bool result;
7316
7317   arg1 = (Dali::Vector4 *)jarg1;
7318   arg2 = (Dali::Vector4 *)jarg2;
7319   if (!arg2) {
7320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7321     return 0;
7322   }
7323   {
7324     try {
7325       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7326     } catch (std::out_of_range& e) {
7327       {
7328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7329       };
7330     } catch (std::exception& e) {
7331       {
7332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7333       };
7334     } catch (...) {
7335       {
7336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7337       };
7338     }
7339   }
7340   jresult = result;
7341   return jresult;
7342 }
7343
7344
7345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7346   float jresult ;
7347   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7348   unsigned int arg2 ;
7349   float *result = 0 ;
7350
7351   arg1 = (Dali::Vector4 *)jarg1;
7352   arg2 = (unsigned int)jarg2;
7353   {
7354     try {
7355       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7356     } catch (std::out_of_range& e) {
7357       {
7358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7359       };
7360     } catch (std::exception& e) {
7361       {
7362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7363       };
7364     } catch (...) {
7365       {
7366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7367       };
7368     }
7369   }
7370   jresult = *result;
7371   return jresult;
7372 }
7373
7374
7375 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7376   float jresult ;
7377   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7378   Dali::Vector3 *arg2 = 0 ;
7379   float result;
7380
7381   arg1 = (Dali::Vector4 *)jarg1;
7382   arg2 = (Dali::Vector3 *)jarg2;
7383   if (!arg2) {
7384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7385     return 0;
7386   }
7387   {
7388     try {
7389       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7390     } catch (std::out_of_range& e) {
7391       {
7392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7393       };
7394     } catch (std::exception& e) {
7395       {
7396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7397       };
7398     } catch (...) {
7399       {
7400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7401       };
7402     }
7403   }
7404   jresult = result;
7405   return jresult;
7406 }
7407
7408
7409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7410   float jresult ;
7411   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7412   Dali::Vector4 *arg2 = 0 ;
7413   float result;
7414
7415   arg1 = (Dali::Vector4 *)jarg1;
7416   arg2 = (Dali::Vector4 *)jarg2;
7417   if (!arg2) {
7418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7419     return 0;
7420   }
7421   {
7422     try {
7423       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7424     } catch (std::out_of_range& e) {
7425       {
7426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7427       };
7428     } catch (std::exception& e) {
7429       {
7430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7431       };
7432     } catch (...) {
7433       {
7434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7435       };
7436     }
7437   }
7438   jresult = result;
7439   return jresult;
7440 }
7441
7442
7443 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7444   float jresult ;
7445   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7446   Dali::Vector4 *arg2 = 0 ;
7447   float result;
7448
7449   arg1 = (Dali::Vector4 *)jarg1;
7450   arg2 = (Dali::Vector4 *)jarg2;
7451   if (!arg2) {
7452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7453     return 0;
7454   }
7455   {
7456     try {
7457       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7458     } catch (std::out_of_range& e) {
7459       {
7460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7461       };
7462     } catch (std::exception& e) {
7463       {
7464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7465       };
7466     } catch (...) {
7467       {
7468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7469       };
7470     }
7471   }
7472   jresult = result;
7473   return jresult;
7474 }
7475
7476
7477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7478   void * jresult ;
7479   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7480   Dali::Vector4 *arg2 = 0 ;
7481   Dali::Vector4 result;
7482
7483   arg1 = (Dali::Vector4 *)jarg1;
7484   arg2 = (Dali::Vector4 *)jarg2;
7485   if (!arg2) {
7486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7487     return 0;
7488   }
7489   {
7490     try {
7491       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7492     } catch (std::out_of_range& e) {
7493       {
7494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7495       };
7496     } catch (std::exception& e) {
7497       {
7498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7499       };
7500     } catch (...) {
7501       {
7502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7503       };
7504     }
7505   }
7506   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7507   return jresult;
7508 }
7509
7510
7511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7512   float jresult ;
7513   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7514   float result;
7515
7516   arg1 = (Dali::Vector4 *)jarg1;
7517   {
7518     try {
7519       result = (float)((Dali::Vector4 const *)arg1)->Length();
7520     } catch (std::out_of_range& e) {
7521       {
7522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7523       };
7524     } catch (std::exception& e) {
7525       {
7526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7527       };
7528     } catch (...) {
7529       {
7530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7531       };
7532     }
7533   }
7534   jresult = result;
7535   return jresult;
7536 }
7537
7538
7539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7540   float jresult ;
7541   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7542   float result;
7543
7544   arg1 = (Dali::Vector4 *)jarg1;
7545   {
7546     try {
7547       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7548     } catch (std::out_of_range& e) {
7549       {
7550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7551       };
7552     } catch (std::exception& e) {
7553       {
7554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7555       };
7556     } catch (...) {
7557       {
7558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7559       };
7560     }
7561   }
7562   jresult = result;
7563   return jresult;
7564 }
7565
7566
7567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7568   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7569
7570   arg1 = (Dali::Vector4 *)jarg1;
7571   {
7572     try {
7573       (arg1)->Normalize();
7574     } catch (std::out_of_range& e) {
7575       {
7576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7577       };
7578     } catch (std::exception& e) {
7579       {
7580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7581       };
7582     } catch (...) {
7583       {
7584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7585       };
7586     }
7587   }
7588 }
7589
7590
7591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7592   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7593   Dali::Vector4 *arg2 = 0 ;
7594   Dali::Vector4 *arg3 = 0 ;
7595
7596   arg1 = (Dali::Vector4 *)jarg1;
7597   arg2 = (Dali::Vector4 *)jarg2;
7598   if (!arg2) {
7599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7600     return ;
7601   }
7602   arg3 = (Dali::Vector4 *)jarg3;
7603   if (!arg3) {
7604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7605     return ;
7606   }
7607   {
7608     try {
7609       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7610     } catch (std::out_of_range& e) {
7611       {
7612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7613       };
7614     } catch (std::exception& e) {
7615       {
7616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7617       };
7618     } catch (...) {
7619       {
7620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7621       };
7622     }
7623   }
7624 }
7625
7626
7627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7628   void * jresult ;
7629   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7630   float *result = 0 ;
7631
7632   arg1 = (Dali::Vector4 *)jarg1;
7633   {
7634     try {
7635       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7636     } catch (std::out_of_range& e) {
7637       {
7638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7639       };
7640     } catch (std::exception& e) {
7641       {
7642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7643       };
7644     } catch (...) {
7645       {
7646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7647       };
7648     }
7649   }
7650   jresult = (void *)result;
7651   return jresult;
7652 }
7653
7654
7655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7656   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7657   float arg2 ;
7658
7659   arg1 = (Dali::Vector4 *)jarg1;
7660   arg2 = (float)jarg2;
7661   if (arg1) (arg1)->x = arg2;
7662 }
7663
7664
7665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7666   float jresult ;
7667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7668   float result;
7669
7670   arg1 = (Dali::Vector4 *)jarg1;
7671   result = (float) ((arg1)->x);
7672   jresult = result;
7673   return jresult;
7674 }
7675
7676
7677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7678   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7679   float arg2 ;
7680
7681   arg1 = (Dali::Vector4 *)jarg1;
7682   arg2 = (float)jarg2;
7683   if (arg1) (arg1)->r = arg2;
7684 }
7685
7686
7687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7688   float jresult ;
7689   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7690   float result;
7691
7692   arg1 = (Dali::Vector4 *)jarg1;
7693   result = (float) ((arg1)->r);
7694   jresult = result;
7695   return jresult;
7696 }
7697
7698
7699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7701   float arg2 ;
7702
7703   arg1 = (Dali::Vector4 *)jarg1;
7704   arg2 = (float)jarg2;
7705   if (arg1) (arg1)->s = arg2;
7706 }
7707
7708
7709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7710   float jresult ;
7711   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7712   float result;
7713
7714   arg1 = (Dali::Vector4 *)jarg1;
7715   result = (float) ((arg1)->s);
7716   jresult = result;
7717   return jresult;
7718 }
7719
7720
7721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7723   float arg2 ;
7724
7725   arg1 = (Dali::Vector4 *)jarg1;
7726   arg2 = (float)jarg2;
7727   if (arg1) (arg1)->y = arg2;
7728 }
7729
7730
7731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7732   float jresult ;
7733   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7734   float result;
7735
7736   arg1 = (Dali::Vector4 *)jarg1;
7737   result = (float) ((arg1)->y);
7738   jresult = result;
7739   return jresult;
7740 }
7741
7742
7743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7744   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7745   float arg2 ;
7746
7747   arg1 = (Dali::Vector4 *)jarg1;
7748   arg2 = (float)jarg2;
7749   if (arg1) (arg1)->g = arg2;
7750 }
7751
7752
7753 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7754   float jresult ;
7755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7756   float result;
7757
7758   arg1 = (Dali::Vector4 *)jarg1;
7759   result = (float) ((arg1)->g);
7760   jresult = result;
7761   return jresult;
7762 }
7763
7764
7765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7767   float arg2 ;
7768
7769   arg1 = (Dali::Vector4 *)jarg1;
7770   arg2 = (float)jarg2;
7771   if (arg1) (arg1)->t = arg2;
7772 }
7773
7774
7775 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7776   float jresult ;
7777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7778   float result;
7779
7780   arg1 = (Dali::Vector4 *)jarg1;
7781   result = (float) ((arg1)->t);
7782   jresult = result;
7783   return jresult;
7784 }
7785
7786
7787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7788   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7789   float arg2 ;
7790
7791   arg1 = (Dali::Vector4 *)jarg1;
7792   arg2 = (float)jarg2;
7793   if (arg1) (arg1)->z = arg2;
7794 }
7795
7796
7797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7798   float jresult ;
7799   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7800   float result;
7801
7802   arg1 = (Dali::Vector4 *)jarg1;
7803   result = (float) ((arg1)->z);
7804   jresult = result;
7805   return jresult;
7806 }
7807
7808
7809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7810   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7811   float arg2 ;
7812
7813   arg1 = (Dali::Vector4 *)jarg1;
7814   arg2 = (float)jarg2;
7815   if (arg1) (arg1)->b = arg2;
7816 }
7817
7818
7819 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7820   float jresult ;
7821   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7822   float result;
7823
7824   arg1 = (Dali::Vector4 *)jarg1;
7825   result = (float) ((arg1)->b);
7826   jresult = result;
7827   return jresult;
7828 }
7829
7830
7831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7832   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7833   float arg2 ;
7834
7835   arg1 = (Dali::Vector4 *)jarg1;
7836   arg2 = (float)jarg2;
7837   if (arg1) (arg1)->p = arg2;
7838 }
7839
7840
7841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7842   float jresult ;
7843   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7844   float result;
7845
7846   arg1 = (Dali::Vector4 *)jarg1;
7847   result = (float) ((arg1)->p);
7848   jresult = result;
7849   return jresult;
7850 }
7851
7852
7853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7854   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7855   float arg2 ;
7856
7857   arg1 = (Dali::Vector4 *)jarg1;
7858   arg2 = (float)jarg2;
7859   if (arg1) (arg1)->w = arg2;
7860 }
7861
7862
7863 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7864   float jresult ;
7865   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7866   float result;
7867
7868   arg1 = (Dali::Vector4 *)jarg1;
7869   result = (float) ((arg1)->w);
7870   jresult = result;
7871   return jresult;
7872 }
7873
7874
7875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7876   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7877   float arg2 ;
7878
7879   arg1 = (Dali::Vector4 *)jarg1;
7880   arg2 = (float)jarg2;
7881   if (arg1) (arg1)->a = arg2;
7882 }
7883
7884
7885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7886   float jresult ;
7887   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7888   float result;
7889
7890   arg1 = (Dali::Vector4 *)jarg1;
7891   result = (float) ((arg1)->a);
7892   jresult = result;
7893   return jresult;
7894 }
7895
7896
7897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7898   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7899   float arg2 ;
7900
7901   arg1 = (Dali::Vector4 *)jarg1;
7902   arg2 = (float)jarg2;
7903   if (arg1) (arg1)->q = arg2;
7904 }
7905
7906
7907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7908   float jresult ;
7909   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7910   float result;
7911
7912   arg1 = (Dali::Vector4 *)jarg1;
7913   result = (float) ((arg1)->q);
7914   jresult = result;
7915   return jresult;
7916 }
7917
7918
7919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7920   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7921
7922   arg1 = (Dali::Vector4 *)jarg1;
7923   {
7924     try {
7925       delete arg1;
7926     } catch (std::out_of_range& e) {
7927       {
7928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7929       };
7930     } catch (std::exception& e) {
7931       {
7932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7933       };
7934     } catch (...) {
7935       {
7936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7937       };
7938     }
7939   }
7940 }
7941
7942
7943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7944   void * jresult ;
7945   Dali::Vector4 *arg1 = 0 ;
7946   Dali::Vector4 *arg2 = 0 ;
7947   Dali::Vector4 result;
7948
7949   arg1 = (Dali::Vector4 *)jarg1;
7950   if (!arg1) {
7951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7952     return 0;
7953   }
7954   arg2 = (Dali::Vector4 *)jarg2;
7955   if (!arg2) {
7956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7957     return 0;
7958   }
7959   {
7960     try {
7961       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7962     } catch (std::out_of_range& e) {
7963       {
7964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7965       };
7966     } catch (std::exception& e) {
7967       {
7968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7969       };
7970     } catch (...) {
7971       {
7972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7973       };
7974     }
7975   }
7976   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7977   return jresult;
7978 }
7979
7980
7981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7982   void * jresult ;
7983   Dali::Vector4 *arg1 = 0 ;
7984   Dali::Vector4 *arg2 = 0 ;
7985   Dali::Vector4 result;
7986
7987   arg1 = (Dali::Vector4 *)jarg1;
7988   if (!arg1) {
7989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7990     return 0;
7991   }
7992   arg2 = (Dali::Vector4 *)jarg2;
7993   if (!arg2) {
7994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7995     return 0;
7996   }
7997   {
7998     try {
7999       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8000     } catch (std::out_of_range& e) {
8001       {
8002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8003       };
8004     } catch (std::exception& e) {
8005       {
8006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8007       };
8008     } catch (...) {
8009       {
8010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8011       };
8012     }
8013   }
8014   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8015   return jresult;
8016 }
8017
8018
8019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8020   void * jresult ;
8021   Dali::Vector4 *arg1 = 0 ;
8022   float *arg2 = 0 ;
8023   float *arg3 = 0 ;
8024   float temp2 ;
8025   float temp3 ;
8026   Dali::Vector4 result;
8027
8028   arg1 = (Dali::Vector4 *)jarg1;
8029   if (!arg1) {
8030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8031     return 0;
8032   }
8033   temp2 = (float)jarg2;
8034   arg2 = &temp2;
8035   temp3 = (float)jarg3;
8036   arg3 = &temp3;
8037   {
8038     try {
8039       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8040     } catch (std::out_of_range& e) {
8041       {
8042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8043       };
8044     } catch (std::exception& e) {
8045       {
8046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8047       };
8048     } catch (...) {
8049       {
8050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8051       };
8052     }
8053   }
8054   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8055   return jresult;
8056 }
8057
8058
8059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8060   void * jresult ;
8061   Dali::Uint16Pair *result = 0 ;
8062
8063   {
8064     try {
8065       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8066     } catch (std::out_of_range& e) {
8067       {
8068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8069       };
8070     } catch (std::exception& e) {
8071       {
8072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8073       };
8074     } catch (...) {
8075       {
8076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8077       };
8078     }
8079   }
8080   jresult = (void *)result;
8081   return jresult;
8082 }
8083
8084
8085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8086   void * jresult ;
8087   uint32_t arg1 ;
8088   uint32_t arg2 ;
8089   Dali::Uint16Pair *result = 0 ;
8090
8091   arg1 = (uint32_t)jarg1;
8092   arg2 = (uint32_t)jarg2;
8093   {
8094     try {
8095       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8096     } catch (std::out_of_range& e) {
8097       {
8098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8099       };
8100     } catch (std::exception& e) {
8101       {
8102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8103       };
8104     } catch (...) {
8105       {
8106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8107       };
8108     }
8109   }
8110   jresult = (void *)result;
8111   return jresult;
8112 }
8113
8114
8115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8116   void * jresult ;
8117   Dali::Uint16Pair *arg1 = 0 ;
8118   Dali::Uint16Pair *result = 0 ;
8119
8120   arg1 = (Dali::Uint16Pair *)jarg1;
8121   if (!arg1) {
8122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8123     return 0;
8124   }
8125   {
8126     try {
8127       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8128     } catch (std::out_of_range& e) {
8129       {
8130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8131       };
8132     } catch (std::exception& e) {
8133       {
8134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8135       };
8136     } catch (...) {
8137       {
8138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8139       };
8140     }
8141   }
8142   jresult = (void *)result;
8143   return jresult;
8144 }
8145
8146
8147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8148   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8149   uint16_t arg2 ;
8150
8151   arg1 = (Dali::Uint16Pair *)jarg1;
8152   arg2 = (uint16_t)jarg2;
8153   {
8154     try {
8155       (arg1)->SetWidth(arg2);
8156     } catch (std::out_of_range& e) {
8157       {
8158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8159       };
8160     } catch (std::exception& e) {
8161       {
8162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8163       };
8164     } catch (...) {
8165       {
8166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8167       };
8168     }
8169   }
8170 }
8171
8172
8173 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8174   unsigned short jresult ;
8175   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8176   uint16_t result;
8177
8178   arg1 = (Dali::Uint16Pair *)jarg1;
8179   {
8180     try {
8181       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8182     } catch (std::out_of_range& e) {
8183       {
8184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8185       };
8186     } catch (std::exception& e) {
8187       {
8188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8189       };
8190     } catch (...) {
8191       {
8192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8193       };
8194     }
8195   }
8196   jresult = result;
8197   return jresult;
8198 }
8199
8200
8201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8202   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8203   uint16_t arg2 ;
8204
8205   arg1 = (Dali::Uint16Pair *)jarg1;
8206   arg2 = (uint16_t)jarg2;
8207   {
8208     try {
8209       (arg1)->SetHeight(arg2);
8210     } catch (std::out_of_range& e) {
8211       {
8212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8213       };
8214     } catch (std::exception& e) {
8215       {
8216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8217       };
8218     } catch (...) {
8219       {
8220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8221       };
8222     }
8223   }
8224 }
8225
8226
8227 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8228   unsigned short jresult ;
8229   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8230   uint16_t result;
8231
8232   arg1 = (Dali::Uint16Pair *)jarg1;
8233   {
8234     try {
8235       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8236     } catch (std::out_of_range& e) {
8237       {
8238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8239       };
8240     } catch (std::exception& e) {
8241       {
8242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8243       };
8244     } catch (...) {
8245       {
8246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8247       };
8248     }
8249   }
8250   jresult = result;
8251   return jresult;
8252 }
8253
8254
8255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8256   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8257   uint16_t arg2 ;
8258
8259   arg1 = (Dali::Uint16Pair *)jarg1;
8260   arg2 = (uint16_t)jarg2;
8261   {
8262     try {
8263       (arg1)->SetX(arg2);
8264     } catch (std::out_of_range& e) {
8265       {
8266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8267       };
8268     } catch (std::exception& e) {
8269       {
8270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8271       };
8272     } catch (...) {
8273       {
8274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8275       };
8276     }
8277   }
8278 }
8279
8280
8281 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8282   unsigned short jresult ;
8283   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8284   uint16_t result;
8285
8286   arg1 = (Dali::Uint16Pair *)jarg1;
8287   {
8288     try {
8289       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8290     } catch (std::out_of_range& e) {
8291       {
8292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8293       };
8294     } catch (std::exception& e) {
8295       {
8296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8297       };
8298     } catch (...) {
8299       {
8300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8301       };
8302     }
8303   }
8304   jresult = result;
8305   return jresult;
8306 }
8307
8308
8309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8310   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8311   uint16_t arg2 ;
8312
8313   arg1 = (Dali::Uint16Pair *)jarg1;
8314   arg2 = (uint16_t)jarg2;
8315   {
8316     try {
8317       (arg1)->SetY(arg2);
8318     } catch (std::out_of_range& e) {
8319       {
8320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8321       };
8322     } catch (std::exception& e) {
8323       {
8324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8325       };
8326     } catch (...) {
8327       {
8328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8329       };
8330     }
8331   }
8332 }
8333
8334
8335 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8336   unsigned short jresult ;
8337   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8338   uint16_t result;
8339
8340   arg1 = (Dali::Uint16Pair *)jarg1;
8341   {
8342     try {
8343       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8344     } catch (std::out_of_range& e) {
8345       {
8346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8347       };
8348     } catch (std::exception& e) {
8349       {
8350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8351       };
8352     } catch (...) {
8353       {
8354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8355       };
8356     }
8357   }
8358   jresult = result;
8359   return jresult;
8360 }
8361
8362
8363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8364   void * jresult ;
8365   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8366   Dali::Uint16Pair *arg2 = 0 ;
8367   Dali::Uint16Pair *result = 0 ;
8368
8369   arg1 = (Dali::Uint16Pair *)jarg1;
8370   arg2 = (Dali::Uint16Pair *)jarg2;
8371   if (!arg2) {
8372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8373     return 0;
8374   }
8375   {
8376     try {
8377       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8378     } catch (std::out_of_range& e) {
8379       {
8380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8381       };
8382     } catch (std::exception& e) {
8383       {
8384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8385       };
8386     } catch (...) {
8387       {
8388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8389       };
8390     }
8391   }
8392   jresult = (void *)result;
8393   return jresult;
8394 }
8395
8396
8397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8398   unsigned int jresult ;
8399   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8400   Dali::Uint16Pair *arg2 = 0 ;
8401   bool result;
8402
8403   arg1 = (Dali::Uint16Pair *)jarg1;
8404   arg2 = (Dali::Uint16Pair *)jarg2;
8405   if (!arg2) {
8406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8407     return 0;
8408   }
8409   {
8410     try {
8411       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8412     } catch (std::out_of_range& e) {
8413       {
8414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8415       };
8416     } catch (std::exception& e) {
8417       {
8418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8419       };
8420     } catch (...) {
8421       {
8422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8423       };
8424     }
8425   }
8426   jresult = result;
8427   return jresult;
8428 }
8429
8430
8431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8432   unsigned int jresult ;
8433   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8434   Dali::Uint16Pair *arg2 = 0 ;
8435   bool result;
8436
8437   arg1 = (Dali::Uint16Pair *)jarg1;
8438   arg2 = (Dali::Uint16Pair *)jarg2;
8439   if (!arg2) {
8440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8441     return 0;
8442   }
8443   {
8444     try {
8445       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8446     } catch (std::out_of_range& e) {
8447       {
8448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8449       };
8450     } catch (std::exception& e) {
8451       {
8452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8453       };
8454     } catch (...) {
8455       {
8456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8457       };
8458     }
8459   }
8460   jresult = result;
8461   return jresult;
8462 }
8463
8464
8465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8466   unsigned int jresult ;
8467   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8468   Dali::Uint16Pair *arg2 = 0 ;
8469   bool result;
8470
8471   arg1 = (Dali::Uint16Pair *)jarg1;
8472   arg2 = (Dali::Uint16Pair *)jarg2;
8473   if (!arg2) {
8474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8475     return 0;
8476   }
8477   {
8478     try {
8479       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8480     } catch (std::out_of_range& e) {
8481       {
8482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8483       };
8484     } catch (std::exception& e) {
8485       {
8486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8487       };
8488     } catch (...) {
8489       {
8490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8491       };
8492     }
8493   }
8494   jresult = result;
8495   return jresult;
8496 }
8497
8498
8499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8500   unsigned int jresult ;
8501   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8502   Dali::Uint16Pair *arg2 = 0 ;
8503   bool result;
8504
8505   arg1 = (Dali::Uint16Pair *)jarg1;
8506   arg2 = (Dali::Uint16Pair *)jarg2;
8507   if (!arg2) {
8508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8509     return 0;
8510   }
8511   {
8512     try {
8513       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8514     } catch (std::out_of_range& e) {
8515       {
8516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8517       };
8518     } catch (std::exception& e) {
8519       {
8520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8521       };
8522     } catch (...) {
8523       {
8524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8525       };
8526     }
8527   }
8528   jresult = result;
8529   return jresult;
8530 }
8531
8532
8533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8534   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8535
8536   arg1 = (Dali::Uint16Pair *)jarg1;
8537   {
8538     try {
8539       delete arg1;
8540     } catch (std::out_of_range& e) {
8541       {
8542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8543       };
8544     } catch (std::exception& e) {
8545       {
8546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8547       };
8548     } catch (...) {
8549       {
8550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8551       };
8552     }
8553   }
8554 }
8555
8556
8557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8558   void * jresult ;
8559   Dali::Degree *result = 0 ;
8560
8561   {
8562     try {
8563       result = (Dali::Degree *)new Dali::Degree();
8564     } catch (std::out_of_range& e) {
8565       {
8566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8567       };
8568     } catch (std::exception& e) {
8569       {
8570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8571       };
8572     } catch (...) {
8573       {
8574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8575       };
8576     }
8577   }
8578   jresult = (void *)result;
8579   return jresult;
8580 }
8581
8582
8583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8584   void * jresult ;
8585   float arg1 ;
8586   Dali::Degree *result = 0 ;
8587
8588   arg1 = (float)jarg1;
8589   {
8590     try {
8591       result = (Dali::Degree *)new Dali::Degree(arg1);
8592     } catch (std::out_of_range& e) {
8593       {
8594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8595       };
8596     } catch (std::exception& e) {
8597       {
8598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8599       };
8600     } catch (...) {
8601       {
8602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8603       };
8604     }
8605   }
8606   jresult = (void *)result;
8607   return jresult;
8608 }
8609
8610
8611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8612   void * jresult ;
8613   Dali::Radian arg1 ;
8614   Dali::Radian *argp1 ;
8615   Dali::Degree *result = 0 ;
8616
8617   argp1 = (Dali::Radian *)jarg1;
8618   if (!argp1) {
8619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8620     return 0;
8621   }
8622   arg1 = *argp1;
8623   {
8624     try {
8625       result = (Dali::Degree *)new Dali::Degree(arg1);
8626     } catch (std::out_of_range& e) {
8627       {
8628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8629       };
8630     } catch (std::exception& e) {
8631       {
8632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8633       };
8634     } catch (...) {
8635       {
8636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8637       };
8638     }
8639   }
8640   jresult = (void *)result;
8641   return jresult;
8642 }
8643
8644
8645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8646   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8647   float arg2 ;
8648
8649   arg1 = (Dali::Degree *)jarg1;
8650   arg2 = (float)jarg2;
8651   if (arg1) (arg1)->degree = arg2;
8652 }
8653
8654
8655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8656   float jresult ;
8657   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8658   float result;
8659
8660   arg1 = (Dali::Degree *)jarg1;
8661   result = (float) ((arg1)->degree);
8662   jresult = result;
8663   return jresult;
8664 }
8665
8666
8667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8668   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8669
8670   arg1 = (Dali::Degree *)jarg1;
8671   {
8672     try {
8673       delete arg1;
8674     } catch (std::out_of_range& e) {
8675       {
8676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8677       };
8678     } catch (std::exception& e) {
8679       {
8680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8681       };
8682     } catch (...) {
8683       {
8684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8685       };
8686     }
8687   }
8688 }
8689
8690
8691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8692   void * jresult ;
8693   Dali::Radian *result = 0 ;
8694
8695   result = (Dali::Radian *)&Dali::ANGLE_360;
8696   jresult = (void *)result;
8697   return jresult;
8698 }
8699
8700
8701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8702   void * jresult ;
8703   Dali::Radian *result = 0 ;
8704
8705   result = (Dali::Radian *)&Dali::ANGLE_315;
8706   jresult = (void *)result;
8707   return jresult;
8708 }
8709
8710
8711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8712   void * jresult ;
8713   Dali::Radian *result = 0 ;
8714
8715   result = (Dali::Radian *)&Dali::ANGLE_270;
8716   jresult = (void *)result;
8717   return jresult;
8718 }
8719
8720
8721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8722   void * jresult ;
8723   Dali::Radian *result = 0 ;
8724
8725   result = (Dali::Radian *)&Dali::ANGLE_225;
8726   jresult = (void *)result;
8727   return jresult;
8728 }
8729
8730
8731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8732   void * jresult ;
8733   Dali::Radian *result = 0 ;
8734
8735   result = (Dali::Radian *)&Dali::ANGLE_180;
8736   jresult = (void *)result;
8737   return jresult;
8738 }
8739
8740
8741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8742   void * jresult ;
8743   Dali::Radian *result = 0 ;
8744
8745   result = (Dali::Radian *)&Dali::ANGLE_135;
8746   jresult = (void *)result;
8747   return jresult;
8748 }
8749
8750
8751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8752   void * jresult ;
8753   Dali::Radian *result = 0 ;
8754
8755   result = (Dali::Radian *)&Dali::ANGLE_120;
8756   jresult = (void *)result;
8757   return jresult;
8758 }
8759
8760
8761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8762   void * jresult ;
8763   Dali::Radian *result = 0 ;
8764
8765   result = (Dali::Radian *)&Dali::ANGLE_90;
8766   jresult = (void *)result;
8767   return jresult;
8768 }
8769
8770
8771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8772   void * jresult ;
8773   Dali::Radian *result = 0 ;
8774
8775   result = (Dali::Radian *)&Dali::ANGLE_60;
8776   jresult = (void *)result;
8777   return jresult;
8778 }
8779
8780
8781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8782   void * jresult ;
8783   Dali::Radian *result = 0 ;
8784
8785   result = (Dali::Radian *)&Dali::ANGLE_45;
8786   jresult = (void *)result;
8787   return jresult;
8788 }
8789
8790
8791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8792   void * jresult ;
8793   Dali::Radian *result = 0 ;
8794
8795   result = (Dali::Radian *)&Dali::ANGLE_30;
8796   jresult = (void *)result;
8797   return jresult;
8798 }
8799
8800
8801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8802   void * jresult ;
8803   Dali::Radian *result = 0 ;
8804
8805   result = (Dali::Radian *)&Dali::ANGLE_0;
8806   jresult = (void *)result;
8807   return jresult;
8808 }
8809
8810
8811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8812   unsigned int jresult ;
8813   Dali::Degree *arg1 = 0 ;
8814   Dali::Degree *arg2 = 0 ;
8815   bool result;
8816
8817   arg1 = (Dali::Degree *)jarg1;
8818   if (!arg1) {
8819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8820     return 0;
8821   }
8822   arg2 = (Dali::Degree *)jarg2;
8823   if (!arg2) {
8824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8825     return 0;
8826   }
8827   {
8828     try {
8829       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8830     } catch (std::out_of_range& e) {
8831       {
8832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8833       };
8834     } catch (std::exception& e) {
8835       {
8836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8837       };
8838     } catch (...) {
8839       {
8840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8841       };
8842     }
8843   }
8844   jresult = result;
8845   return jresult;
8846 }
8847
8848
8849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8850   unsigned int jresult ;
8851   Dali::Degree *arg1 = 0 ;
8852   Dali::Degree *arg2 = 0 ;
8853   bool result;
8854
8855   arg1 = (Dali::Degree *)jarg1;
8856   if (!arg1) {
8857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8858     return 0;
8859   }
8860   arg2 = (Dali::Degree *)jarg2;
8861   if (!arg2) {
8862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8863     return 0;
8864   }
8865   {
8866     try {
8867       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8868     } catch (std::out_of_range& e) {
8869       {
8870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8871       };
8872     } catch (std::exception& e) {
8873       {
8874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8875       };
8876     } catch (...) {
8877       {
8878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8879       };
8880     }
8881   }
8882   jresult = result;
8883   return jresult;
8884 }
8885
8886
8887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8888   void * jresult ;
8889   Dali::Degree arg1 ;
8890   float arg2 ;
8891   float arg3 ;
8892   Dali::Degree *argp1 ;
8893   Dali::Degree result;
8894
8895   argp1 = (Dali::Degree *)jarg1;
8896   if (!argp1) {
8897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8898     return 0;
8899   }
8900   arg1 = *argp1;
8901   arg2 = (float)jarg2;
8902   arg3 = (float)jarg3;
8903   {
8904     try {
8905       result = Dali::Clamp(arg1,arg2,arg3);
8906     } catch (std::out_of_range& e) {
8907       {
8908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8909       };
8910     } catch (std::exception& e) {
8911       {
8912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8913       };
8914     } catch (...) {
8915       {
8916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8917       };
8918     }
8919   }
8920   jresult = new Dali::Degree((const Dali::Degree &)result);
8921   return jresult;
8922 }
8923
8924
8925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8926   void * jresult ;
8927   Dali::Radian *result = 0 ;
8928
8929   {
8930     try {
8931       result = (Dali::Radian *)new Dali::Radian();
8932     } catch (std::out_of_range& e) {
8933       {
8934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8935       };
8936     } catch (std::exception& e) {
8937       {
8938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8939       };
8940     } catch (...) {
8941       {
8942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8943       };
8944     }
8945   }
8946   jresult = (void *)result;
8947   return jresult;
8948 }
8949
8950
8951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8952   void * jresult ;
8953   float arg1 ;
8954   Dali::Radian *result = 0 ;
8955
8956   arg1 = (float)jarg1;
8957   {
8958     try {
8959       result = (Dali::Radian *)new Dali::Radian(arg1);
8960     } catch (std::out_of_range& e) {
8961       {
8962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8963       };
8964     } catch (std::exception& e) {
8965       {
8966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8967       };
8968     } catch (...) {
8969       {
8970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8971       };
8972     }
8973   }
8974   jresult = (void *)result;
8975   return jresult;
8976 }
8977
8978
8979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8980   void * jresult ;
8981   Dali::Degree arg1 ;
8982   Dali::Degree *argp1 ;
8983   Dali::Radian *result = 0 ;
8984
8985   argp1 = (Dali::Degree *)jarg1;
8986   if (!argp1) {
8987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8988     return 0;
8989   }
8990   arg1 = *argp1;
8991   {
8992     try {
8993       result = (Dali::Radian *)new Dali::Radian(arg1);
8994     } catch (std::out_of_range& e) {
8995       {
8996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8997       };
8998     } catch (std::exception& e) {
8999       {
9000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9001       };
9002     } catch (...) {
9003       {
9004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9005       };
9006     }
9007   }
9008   jresult = (void *)result;
9009   return jresult;
9010 }
9011
9012
9013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9014   void * jresult ;
9015   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9016   float arg2 ;
9017   Dali::Radian *result = 0 ;
9018
9019   arg1 = (Dali::Radian *)jarg1;
9020   arg2 = (float)jarg2;
9021   {
9022     try {
9023       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9024     } catch (std::out_of_range& e) {
9025       {
9026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9027       };
9028     } catch (std::exception& e) {
9029       {
9030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9031       };
9032     } catch (...) {
9033       {
9034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9035       };
9036     }
9037   }
9038   jresult = (void *)result;
9039   return jresult;
9040 }
9041
9042
9043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9044   void * jresult ;
9045   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9046   Dali::Degree arg2 ;
9047   Dali::Degree *argp2 ;
9048   Dali::Radian *result = 0 ;
9049
9050   arg1 = (Dali::Radian *)jarg1;
9051   argp2 = (Dali::Degree *)jarg2;
9052   if (!argp2) {
9053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9054     return 0;
9055   }
9056   arg2 = *argp2;
9057   {
9058     try {
9059       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9060     } catch (std::out_of_range& e) {
9061       {
9062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9063       };
9064     } catch (std::exception& e) {
9065       {
9066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9067       };
9068     } catch (...) {
9069       {
9070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9071       };
9072     }
9073   }
9074   jresult = (void *)result;
9075   return jresult;
9076 }
9077
9078
9079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9080   float jresult ;
9081   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9082   float result;
9083
9084   arg1 = (Dali::Radian *)jarg1;
9085   {
9086     try {
9087       result = (float)((Dali::Radian const *)arg1)->operator float();
9088     } catch (std::out_of_range& e) {
9089       {
9090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9091       };
9092     } catch (std::exception& e) {
9093       {
9094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9095       };
9096     } catch (...) {
9097       {
9098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9099       };
9100     }
9101   }
9102   jresult = result;
9103   return jresult;
9104 }
9105
9106
9107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9108   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9109   float arg2 ;
9110
9111   arg1 = (Dali::Radian *)jarg1;
9112   arg2 = (float)jarg2;
9113   if (arg1) (arg1)->radian = arg2;
9114 }
9115
9116
9117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9118   float jresult ;
9119   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9120   float result;
9121
9122   arg1 = (Dali::Radian *)jarg1;
9123   result = (float) ((arg1)->radian);
9124   jresult = result;
9125   return jresult;
9126 }
9127
9128
9129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9130   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9131
9132   arg1 = (Dali::Radian *)jarg1;
9133   {
9134     try {
9135       delete arg1;
9136     } catch (std::out_of_range& e) {
9137       {
9138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9139       };
9140     } catch (std::exception& e) {
9141       {
9142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9143       };
9144     } catch (...) {
9145       {
9146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9147       };
9148     }
9149   }
9150 }
9151
9152
9153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9154   unsigned int jresult ;
9155   Dali::Radian arg1 ;
9156   Dali::Radian arg2 ;
9157   Dali::Radian *argp1 ;
9158   Dali::Radian *argp2 ;
9159   bool result;
9160
9161   argp1 = (Dali::Radian *)jarg1;
9162   if (!argp1) {
9163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9164     return 0;
9165   }
9166   arg1 = *argp1;
9167   argp2 = (Dali::Radian *)jarg2;
9168   if (!argp2) {
9169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9170     return 0;
9171   }
9172   arg2 = *argp2;
9173   {
9174     try {
9175       result = (bool)Dali::operator ==(arg1,arg2);
9176     } catch (std::out_of_range& e) {
9177       {
9178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9179       };
9180     } catch (std::exception& e) {
9181       {
9182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9183       };
9184     } catch (...) {
9185       {
9186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9187       };
9188     }
9189   }
9190   jresult = result;
9191   return jresult;
9192 }
9193
9194
9195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9196   unsigned int jresult ;
9197   Dali::Radian arg1 ;
9198   Dali::Radian arg2 ;
9199   Dali::Radian *argp1 ;
9200   Dali::Radian *argp2 ;
9201   bool result;
9202
9203   argp1 = (Dali::Radian *)jarg1;
9204   if (!argp1) {
9205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9206     return 0;
9207   }
9208   arg1 = *argp1;
9209   argp2 = (Dali::Radian *)jarg2;
9210   if (!argp2) {
9211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9212     return 0;
9213   }
9214   arg2 = *argp2;
9215   {
9216     try {
9217       result = (bool)Dali::operator !=(arg1,arg2);
9218     } catch (std::out_of_range& e) {
9219       {
9220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9221       };
9222     } catch (std::exception& e) {
9223       {
9224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9225       };
9226     } catch (...) {
9227       {
9228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9229       };
9230     }
9231   }
9232   jresult = result;
9233   return jresult;
9234 }
9235
9236
9237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9238   unsigned int jresult ;
9239   Dali::Radian arg1 ;
9240   Dali::Degree arg2 ;
9241   Dali::Radian *argp1 ;
9242   Dali::Degree *argp2 ;
9243   bool result;
9244
9245   argp1 = (Dali::Radian *)jarg1;
9246   if (!argp1) {
9247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9248     return 0;
9249   }
9250   arg1 = *argp1;
9251   argp2 = (Dali::Degree *)jarg2;
9252   if (!argp2) {
9253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9254     return 0;
9255   }
9256   arg2 = *argp2;
9257   {
9258     try {
9259       result = (bool)Dali::operator ==(arg1,arg2);
9260     } catch (std::out_of_range& e) {
9261       {
9262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9263       };
9264     } catch (std::exception& e) {
9265       {
9266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9267       };
9268     } catch (...) {
9269       {
9270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9271       };
9272     }
9273   }
9274   jresult = result;
9275   return jresult;
9276 }
9277
9278
9279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9280   unsigned int jresult ;
9281   Dali::Radian arg1 ;
9282   Dali::Degree arg2 ;
9283   Dali::Radian *argp1 ;
9284   Dali::Degree *argp2 ;
9285   bool result;
9286
9287   argp1 = (Dali::Radian *)jarg1;
9288   if (!argp1) {
9289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9290     return 0;
9291   }
9292   arg1 = *argp1;
9293   argp2 = (Dali::Degree *)jarg2;
9294   if (!argp2) {
9295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9296     return 0;
9297   }
9298   arg2 = *argp2;
9299   {
9300     try {
9301       result = (bool)Dali::operator !=(arg1,arg2);
9302     } catch (std::out_of_range& e) {
9303       {
9304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9305       };
9306     } catch (std::exception& e) {
9307       {
9308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9309       };
9310     } catch (...) {
9311       {
9312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9313       };
9314     }
9315   }
9316   jresult = result;
9317   return jresult;
9318 }
9319
9320
9321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9322   unsigned int jresult ;
9323   Dali::Degree arg1 ;
9324   Dali::Radian arg2 ;
9325   Dali::Degree *argp1 ;
9326   Dali::Radian *argp2 ;
9327   bool result;
9328
9329   argp1 = (Dali::Degree *)jarg1;
9330   if (!argp1) {
9331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9332     return 0;
9333   }
9334   arg1 = *argp1;
9335   argp2 = (Dali::Radian *)jarg2;
9336   if (!argp2) {
9337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9338     return 0;
9339   }
9340   arg2 = *argp2;
9341   {
9342     try {
9343       result = (bool)Dali::operator ==(arg1,arg2);
9344     } catch (std::out_of_range& e) {
9345       {
9346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9347       };
9348     } catch (std::exception& e) {
9349       {
9350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9351       };
9352     } catch (...) {
9353       {
9354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9355       };
9356     }
9357   }
9358   jresult = result;
9359   return jresult;
9360 }
9361
9362
9363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9364   unsigned int jresult ;
9365   Dali::Degree arg1 ;
9366   Dali::Radian arg2 ;
9367   Dali::Degree *argp1 ;
9368   Dali::Radian *argp2 ;
9369   bool result;
9370
9371   argp1 = (Dali::Degree *)jarg1;
9372   if (!argp1) {
9373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9374     return 0;
9375   }
9376   arg1 = *argp1;
9377   argp2 = (Dali::Radian *)jarg2;
9378   if (!argp2) {
9379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9380     return 0;
9381   }
9382   arg2 = *argp2;
9383   {
9384     try {
9385       result = (bool)Dali::operator !=(arg1,arg2);
9386     } catch (std::out_of_range& e) {
9387       {
9388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9389       };
9390     } catch (std::exception& e) {
9391       {
9392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9393       };
9394     } catch (...) {
9395       {
9396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9397       };
9398     }
9399   }
9400   jresult = result;
9401   return jresult;
9402 }
9403
9404
9405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9406   unsigned int jresult ;
9407   Dali::Radian arg1 ;
9408   Dali::Radian arg2 ;
9409   Dali::Radian *argp1 ;
9410   Dali::Radian *argp2 ;
9411   bool result;
9412
9413   argp1 = (Dali::Radian *)jarg1;
9414   if (!argp1) {
9415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9416     return 0;
9417   }
9418   arg1 = *argp1;
9419   argp2 = (Dali::Radian *)jarg2;
9420   if (!argp2) {
9421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9422     return 0;
9423   }
9424   arg2 = *argp2;
9425   {
9426     try {
9427       result = (bool)Dali::operator >(arg1,arg2);
9428     } catch (std::out_of_range& e) {
9429       {
9430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9431       };
9432     } catch (std::exception& e) {
9433       {
9434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9435       };
9436     } catch (...) {
9437       {
9438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9439       };
9440     }
9441   }
9442   jresult = result;
9443   return jresult;
9444 }
9445
9446
9447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9448   unsigned int jresult ;
9449   Dali::Radian arg1 ;
9450   Dali::Degree arg2 ;
9451   Dali::Radian *argp1 ;
9452   Dali::Degree *argp2 ;
9453   bool result;
9454
9455   argp1 = (Dali::Radian *)jarg1;
9456   if (!argp1) {
9457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9458     return 0;
9459   }
9460   arg1 = *argp1;
9461   argp2 = (Dali::Degree *)jarg2;
9462   if (!argp2) {
9463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9464     return 0;
9465   }
9466   arg2 = *argp2;
9467   {
9468     try {
9469       result = (bool)Dali::operator >(arg1,arg2);
9470     } catch (std::out_of_range& e) {
9471       {
9472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9473       };
9474     } catch (std::exception& e) {
9475       {
9476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9477       };
9478     } catch (...) {
9479       {
9480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9481       };
9482     }
9483   }
9484   jresult = result;
9485   return jresult;
9486 }
9487
9488
9489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9490   unsigned int jresult ;
9491   Dali::Degree arg1 ;
9492   Dali::Radian arg2 ;
9493   Dali::Degree *argp1 ;
9494   Dali::Radian *argp2 ;
9495   bool result;
9496
9497   argp1 = (Dali::Degree *)jarg1;
9498   if (!argp1) {
9499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9500     return 0;
9501   }
9502   arg1 = *argp1;
9503   argp2 = (Dali::Radian *)jarg2;
9504   if (!argp2) {
9505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9506     return 0;
9507   }
9508   arg2 = *argp2;
9509   {
9510     try {
9511       result = (bool)Dali::operator >(arg1,arg2);
9512     } catch (std::out_of_range& e) {
9513       {
9514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9515       };
9516     } catch (std::exception& e) {
9517       {
9518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9519       };
9520     } catch (...) {
9521       {
9522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9523       };
9524     }
9525   }
9526   jresult = result;
9527   return jresult;
9528 }
9529
9530
9531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9532   unsigned int jresult ;
9533   Dali::Radian arg1 ;
9534   Dali::Radian arg2 ;
9535   Dali::Radian *argp1 ;
9536   Dali::Radian *argp2 ;
9537   bool result;
9538
9539   argp1 = (Dali::Radian *)jarg1;
9540   if (!argp1) {
9541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9542     return 0;
9543   }
9544   arg1 = *argp1;
9545   argp2 = (Dali::Radian *)jarg2;
9546   if (!argp2) {
9547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9548     return 0;
9549   }
9550   arg2 = *argp2;
9551   {
9552     try {
9553       result = (bool)Dali::operator <(arg1,arg2);
9554     } catch (std::out_of_range& e) {
9555       {
9556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9557       };
9558     } catch (std::exception& e) {
9559       {
9560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9561       };
9562     } catch (...) {
9563       {
9564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9565       };
9566     }
9567   }
9568   jresult = result;
9569   return jresult;
9570 }
9571
9572
9573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9574   unsigned int jresult ;
9575   Dali::Radian arg1 ;
9576   Dali::Degree arg2 ;
9577   Dali::Radian *argp1 ;
9578   Dali::Degree *argp2 ;
9579   bool result;
9580
9581   argp1 = (Dali::Radian *)jarg1;
9582   if (!argp1) {
9583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9584     return 0;
9585   }
9586   arg1 = *argp1;
9587   argp2 = (Dali::Degree *)jarg2;
9588   if (!argp2) {
9589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9590     return 0;
9591   }
9592   arg2 = *argp2;
9593   {
9594     try {
9595       result = (bool)Dali::operator <(arg1,arg2);
9596     } catch (std::out_of_range& e) {
9597       {
9598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9599       };
9600     } catch (std::exception& e) {
9601       {
9602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9603       };
9604     } catch (...) {
9605       {
9606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9607       };
9608     }
9609   }
9610   jresult = result;
9611   return jresult;
9612 }
9613
9614
9615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9616   unsigned int jresult ;
9617   Dali::Degree arg1 ;
9618   Dali::Radian arg2 ;
9619   Dali::Degree *argp1 ;
9620   Dali::Radian *argp2 ;
9621   bool result;
9622
9623   argp1 = (Dali::Degree *)jarg1;
9624   if (!argp1) {
9625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9626     return 0;
9627   }
9628   arg1 = *argp1;
9629   argp2 = (Dali::Radian *)jarg2;
9630   if (!argp2) {
9631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9632     return 0;
9633   }
9634   arg2 = *argp2;
9635   {
9636     try {
9637       result = (bool)Dali::operator <(arg1,arg2);
9638     } catch (std::out_of_range& e) {
9639       {
9640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9641       };
9642     } catch (std::exception& e) {
9643       {
9644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9645       };
9646     } catch (...) {
9647       {
9648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9649       };
9650     }
9651   }
9652   jresult = result;
9653   return jresult;
9654 }
9655
9656
9657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9658   void * jresult ;
9659   Dali::Radian arg1 ;
9660   float arg2 ;
9661   Dali::Radian *argp1 ;
9662   Dali::Radian result;
9663
9664   argp1 = (Dali::Radian *)jarg1;
9665   if (!argp1) {
9666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9667     return 0;
9668   }
9669   arg1 = *argp1;
9670   arg2 = (float)jarg2;
9671   {
9672     try {
9673       result = Dali::operator *(arg1,arg2);
9674     } catch (std::out_of_range& e) {
9675       {
9676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9677       };
9678     } catch (std::exception& e) {
9679       {
9680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9681       };
9682     } catch (...) {
9683       {
9684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9685       };
9686     }
9687   }
9688   jresult = new Dali::Radian((const Dali::Radian &)result);
9689   return jresult;
9690 }
9691
9692
9693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9694   void * jresult ;
9695   Dali::Radian arg1 ;
9696   Dali::Radian *argp1 ;
9697   Dali::Radian result;
9698
9699   argp1 = (Dali::Radian *)jarg1;
9700   if (!argp1) {
9701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9702     return 0;
9703   }
9704   arg1 = *argp1;
9705   {
9706     try {
9707       result = Dali::operator -(arg1);
9708     } catch (std::out_of_range& e) {
9709       {
9710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9711       };
9712     } catch (std::exception& e) {
9713       {
9714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9715       };
9716     } catch (...) {
9717       {
9718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9719       };
9720     }
9721   }
9722   jresult = new Dali::Radian((const Dali::Radian &)result);
9723   return jresult;
9724 }
9725
9726
9727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9728   void * jresult ;
9729   Dali::Radian arg1 ;
9730   float arg2 ;
9731   float arg3 ;
9732   Dali::Radian *argp1 ;
9733   Dali::Radian result;
9734
9735   argp1 = (Dali::Radian *)jarg1;
9736   if (!argp1) {
9737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9738     return 0;
9739   }
9740   arg1 = *argp1;
9741   arg2 = (float)jarg2;
9742   arg3 = (float)jarg3;
9743   {
9744     try {
9745       result = Dali::Clamp(arg1,arg2,arg3);
9746     } catch (std::out_of_range& e) {
9747       {
9748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9749       };
9750     } catch (std::exception& e) {
9751       {
9752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9753       };
9754     } catch (...) {
9755       {
9756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9757       };
9758     }
9759   }
9760   jresult = new Dali::Radian((const Dali::Radian &)result);
9761   return jresult;
9762 }
9763
9764
9765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9766   void * jresult ;
9767   Dali::Quaternion *result = 0 ;
9768
9769   {
9770     try {
9771       result = (Dali::Quaternion *)new Dali::Quaternion();
9772     } catch (std::out_of_range& e) {
9773       {
9774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9775       };
9776     } catch (std::exception& e) {
9777       {
9778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9779       };
9780     } catch (...) {
9781       {
9782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9783       };
9784     }
9785   }
9786   jresult = (void *)result;
9787   return jresult;
9788 }
9789
9790
9791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9792   void * jresult ;
9793   Dali::Radian arg1 ;
9794   Dali::Vector3 *arg2 = 0 ;
9795   Dali::Radian *argp1 ;
9796   Dali::Quaternion *result = 0 ;
9797
9798   argp1 = (Dali::Radian *)jarg1;
9799   if (!argp1) {
9800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9801     return 0;
9802   }
9803   arg1 = *argp1;
9804   arg2 = (Dali::Vector3 *)jarg2;
9805   if (!arg2) {
9806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9807     return 0;
9808   }
9809   {
9810     try {
9811       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9812     } catch (std::out_of_range& e) {
9813       {
9814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9815       };
9816     } catch (std::exception& e) {
9817       {
9818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9819       };
9820     } catch (...) {
9821       {
9822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9823       };
9824     }
9825   }
9826   jresult = (void *)result;
9827   return jresult;
9828 }
9829
9830
9831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9832   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9833
9834   arg1 = (Dali::Quaternion *)jarg1;
9835   {
9836     try {
9837       delete arg1;
9838     } catch (std::out_of_range& e) {
9839       {
9840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9841       };
9842     } catch (std::exception& e) {
9843       {
9844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9845       };
9846     } catch (...) {
9847       {
9848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9849       };
9850     }
9851   }
9852 }
9853
9854
9855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9856   void * jresult ;
9857   Dali::Quaternion *result = 0 ;
9858
9859   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9860   jresult = (void *)result;
9861   return jresult;
9862 }
9863
9864
9865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9866   unsigned int jresult ;
9867   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9868   bool result;
9869
9870   arg1 = (Dali::Quaternion *)jarg1;
9871   {
9872     try {
9873       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9874     } catch (std::out_of_range& e) {
9875       {
9876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9877       };
9878     } catch (std::exception& e) {
9879       {
9880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9881       };
9882     } catch (...) {
9883       {
9884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9885       };
9886     }
9887   }
9888   jresult = result;
9889   return jresult;
9890 }
9891
9892
9893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9894   unsigned int jresult ;
9895   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9896   Dali::Vector3 *arg2 = 0 ;
9897   Dali::Radian *arg3 = 0 ;
9898   bool result;
9899
9900   arg1 = (Dali::Quaternion *)jarg1;
9901   arg2 = (Dali::Vector3 *)jarg2;
9902   if (!arg2) {
9903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9904     return 0;
9905   }
9906   arg3 = (Dali::Radian *)jarg3;
9907   if (!arg3) {
9908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9909     return 0;
9910   }
9911   {
9912     try {
9913       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9914     } catch (std::out_of_range& e) {
9915       {
9916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9917       };
9918     } catch (std::exception& e) {
9919       {
9920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9921       };
9922     } catch (...) {
9923       {
9924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9925       };
9926     }
9927   }
9928   jresult = result;
9929   return jresult;
9930 }
9931
9932
9933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9934   void * jresult ;
9935   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9936   Dali::Quaternion *arg2 = 0 ;
9937   Dali::Quaternion result;
9938
9939   arg1 = (Dali::Quaternion *)jarg1;
9940   arg2 = (Dali::Quaternion *)jarg2;
9941   if (!arg2) {
9942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9943     return 0;
9944   }
9945   {
9946     try {
9947       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9948     } catch (std::out_of_range& e) {
9949       {
9950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9951       };
9952     } catch (std::exception& e) {
9953       {
9954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9955       };
9956     } catch (...) {
9957       {
9958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9959       };
9960     }
9961   }
9962   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9963   return jresult;
9964 }
9965
9966
9967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9968   void * jresult ;
9969   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9970   Dali::Quaternion *arg2 = 0 ;
9971   Dali::Quaternion result;
9972
9973   arg1 = (Dali::Quaternion *)jarg1;
9974   arg2 = (Dali::Quaternion *)jarg2;
9975   if (!arg2) {
9976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9977     return 0;
9978   }
9979   {
9980     try {
9981       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9982     } catch (std::out_of_range& e) {
9983       {
9984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9985       };
9986     } catch (std::exception& e) {
9987       {
9988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9989       };
9990     } catch (...) {
9991       {
9992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9993       };
9994     }
9995   }
9996   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9997   return jresult;
9998 }
9999
10000
10001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10002   void * jresult ;
10003   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10004   Dali::Quaternion *arg2 = 0 ;
10005   Dali::Quaternion result;
10006
10007   arg1 = (Dali::Quaternion *)jarg1;
10008   arg2 = (Dali::Quaternion *)jarg2;
10009   if (!arg2) {
10010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10011     return 0;
10012   }
10013   {
10014     try {
10015       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10016     } catch (std::out_of_range& e) {
10017       {
10018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10019       };
10020     } catch (std::exception& e) {
10021       {
10022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10023       };
10024     } catch (...) {
10025       {
10026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10027       };
10028     }
10029   }
10030   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10031   return jresult;
10032 }
10033
10034
10035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10036   void * jresult ;
10037   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10038   Dali::Vector3 *arg2 = 0 ;
10039   Dali::Vector3 result;
10040
10041   arg1 = (Dali::Quaternion *)jarg1;
10042   arg2 = (Dali::Vector3 *)jarg2;
10043   if (!arg2) {
10044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10045     return 0;
10046   }
10047   {
10048     try {
10049       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10050     } catch (std::out_of_range& e) {
10051       {
10052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10053       };
10054     } catch (std::exception& e) {
10055       {
10056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10057       };
10058     } catch (...) {
10059       {
10060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10061       };
10062     }
10063   }
10064   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10065   return jresult;
10066 }
10067
10068
10069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10070   void * jresult ;
10071   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10072   Dali::Quaternion *arg2 = 0 ;
10073   Dali::Quaternion result;
10074
10075   arg1 = (Dali::Quaternion *)jarg1;
10076   arg2 = (Dali::Quaternion *)jarg2;
10077   if (!arg2) {
10078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10079     return 0;
10080   }
10081   {
10082     try {
10083       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10084     } catch (std::out_of_range& e) {
10085       {
10086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10087       };
10088     } catch (std::exception& e) {
10089       {
10090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10091       };
10092     } catch (...) {
10093       {
10094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10095       };
10096     }
10097   }
10098   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10099   return jresult;
10100 }
10101
10102
10103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10104   void * jresult ;
10105   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10106   float arg2 ;
10107   Dali::Quaternion result;
10108
10109   arg1 = (Dali::Quaternion *)jarg1;
10110   arg2 = (float)jarg2;
10111   {
10112     try {
10113       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10114     } catch (std::out_of_range& e) {
10115       {
10116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10117       };
10118     } catch (std::exception& e) {
10119       {
10120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10121       };
10122     } catch (...) {
10123       {
10124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10125       };
10126     }
10127   }
10128   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10129   return jresult;
10130 }
10131
10132
10133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10134   void * jresult ;
10135   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10136   float arg2 ;
10137   Dali::Quaternion result;
10138
10139   arg1 = (Dali::Quaternion *)jarg1;
10140   arg2 = (float)jarg2;
10141   {
10142     try {
10143       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10144     } catch (std::out_of_range& e) {
10145       {
10146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10147       };
10148     } catch (std::exception& e) {
10149       {
10150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10151       };
10152     } catch (...) {
10153       {
10154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10155       };
10156     }
10157   }
10158   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10159   return jresult;
10160 }
10161
10162
10163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10164   void * jresult ;
10165   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10166   Dali::Quaternion result;
10167
10168   arg1 = (Dali::Quaternion *)jarg1;
10169   {
10170     try {
10171       result = ((Dali::Quaternion const *)arg1)->operator -();
10172     } catch (std::out_of_range& e) {
10173       {
10174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10175       };
10176     } catch (std::exception& e) {
10177       {
10178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10179       };
10180     } catch (...) {
10181       {
10182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10183       };
10184     }
10185   }
10186   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10187   return jresult;
10188 }
10189
10190
10191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10192   void * jresult ;
10193   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10194   Dali::Quaternion *arg2 = 0 ;
10195   Dali::Quaternion *result = 0 ;
10196
10197   arg1 = (Dali::Quaternion *)jarg1;
10198   arg2 = (Dali::Quaternion *)jarg2;
10199   if (!arg2) {
10200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10201     return 0;
10202   }
10203   {
10204     try {
10205       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10206     } catch (std::out_of_range& e) {
10207       {
10208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10209       };
10210     } catch (std::exception& e) {
10211       {
10212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10213       };
10214     } catch (...) {
10215       {
10216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10217       };
10218     }
10219   }
10220   jresult = (void *)result;
10221   return jresult;
10222 }
10223
10224
10225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10226   void * jresult ;
10227   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10228   Dali::Quaternion *arg2 = 0 ;
10229   Dali::Quaternion *result = 0 ;
10230
10231   arg1 = (Dali::Quaternion *)jarg1;
10232   arg2 = (Dali::Quaternion *)jarg2;
10233   if (!arg2) {
10234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10235     return 0;
10236   }
10237   {
10238     try {
10239       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10240     } catch (std::out_of_range& e) {
10241       {
10242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10243       };
10244     } catch (std::exception& e) {
10245       {
10246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10247       };
10248     } catch (...) {
10249       {
10250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10251       };
10252     }
10253   }
10254   jresult = (void *)result;
10255   return jresult;
10256 }
10257
10258
10259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10260   void * jresult ;
10261   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10262   Dali::Quaternion *arg2 = 0 ;
10263   Dali::Quaternion *result = 0 ;
10264
10265   arg1 = (Dali::Quaternion *)jarg1;
10266   arg2 = (Dali::Quaternion *)jarg2;
10267   if (!arg2) {
10268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10269     return 0;
10270   }
10271   {
10272     try {
10273       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10274     } catch (std::out_of_range& e) {
10275       {
10276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10277       };
10278     } catch (std::exception& e) {
10279       {
10280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10281       };
10282     } catch (...) {
10283       {
10284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10285       };
10286     }
10287   }
10288   jresult = (void *)result;
10289   return jresult;
10290 }
10291
10292
10293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10294   void * jresult ;
10295   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10296   float arg2 ;
10297   Dali::Quaternion *result = 0 ;
10298
10299   arg1 = (Dali::Quaternion *)jarg1;
10300   arg2 = (float)jarg2;
10301   {
10302     try {
10303       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10304     } catch (std::out_of_range& e) {
10305       {
10306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10307       };
10308     } catch (std::exception& e) {
10309       {
10310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10311       };
10312     } catch (...) {
10313       {
10314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10315       };
10316     }
10317   }
10318   jresult = (void *)result;
10319   return jresult;
10320 }
10321
10322
10323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10324   void * jresult ;
10325   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10326   float arg2 ;
10327   Dali::Quaternion *result = 0 ;
10328
10329   arg1 = (Dali::Quaternion *)jarg1;
10330   arg2 = (float)jarg2;
10331   {
10332     try {
10333       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10334     } catch (std::out_of_range& e) {
10335       {
10336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10337       };
10338     } catch (std::exception& e) {
10339       {
10340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10341       };
10342     } catch (...) {
10343       {
10344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10345       };
10346     }
10347   }
10348   jresult = (void *)result;
10349   return jresult;
10350 }
10351
10352
10353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10354   unsigned int jresult ;
10355   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10356   Dali::Quaternion *arg2 = 0 ;
10357   bool result;
10358
10359   arg1 = (Dali::Quaternion *)jarg1;
10360   arg2 = (Dali::Quaternion *)jarg2;
10361   if (!arg2) {
10362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10363     return 0;
10364   }
10365   {
10366     try {
10367       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10368     } catch (std::out_of_range& e) {
10369       {
10370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10371       };
10372     } catch (std::exception& e) {
10373       {
10374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10375       };
10376     } catch (...) {
10377       {
10378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10379       };
10380     }
10381   }
10382   jresult = result;
10383   return jresult;
10384 }
10385
10386
10387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10388   unsigned int jresult ;
10389   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10390   Dali::Quaternion *arg2 = 0 ;
10391   bool result;
10392
10393   arg1 = (Dali::Quaternion *)jarg1;
10394   arg2 = (Dali::Quaternion *)jarg2;
10395   if (!arg2) {
10396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10397     return 0;
10398   }
10399   {
10400     try {
10401       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10402     } catch (std::out_of_range& e) {
10403       {
10404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10405       };
10406     } catch (std::exception& e) {
10407       {
10408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10409       };
10410     } catch (...) {
10411       {
10412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10413       };
10414     }
10415   }
10416   jresult = result;
10417   return jresult;
10418 }
10419
10420
10421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10422   float jresult ;
10423   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10424   float result;
10425
10426   arg1 = (Dali::Quaternion *)jarg1;
10427   {
10428     try {
10429       result = (float)((Dali::Quaternion const *)arg1)->Length();
10430     } catch (std::out_of_range& e) {
10431       {
10432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10433       };
10434     } catch (std::exception& e) {
10435       {
10436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10437       };
10438     } catch (...) {
10439       {
10440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10441       };
10442     }
10443   }
10444   jresult = result;
10445   return jresult;
10446 }
10447
10448
10449 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10450   float jresult ;
10451   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10452   float result;
10453
10454   arg1 = (Dali::Quaternion *)jarg1;
10455   {
10456     try {
10457       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10458     } catch (std::out_of_range& e) {
10459       {
10460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10461       };
10462     } catch (std::exception& e) {
10463       {
10464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10465       };
10466     } catch (...) {
10467       {
10468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10469       };
10470     }
10471   }
10472   jresult = result;
10473   return jresult;
10474 }
10475
10476
10477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10478   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10479
10480   arg1 = (Dali::Quaternion *)jarg1;
10481   {
10482     try {
10483       (arg1)->Normalize();
10484     } catch (std::out_of_range& e) {
10485       {
10486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10487       };
10488     } catch (std::exception& e) {
10489       {
10490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10491       };
10492     } catch (...) {
10493       {
10494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10495       };
10496     }
10497   }
10498 }
10499
10500
10501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10502   void * jresult ;
10503   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10504   Dali::Quaternion result;
10505
10506   arg1 = (Dali::Quaternion *)jarg1;
10507   {
10508     try {
10509       result = ((Dali::Quaternion const *)arg1)->Normalized();
10510     } catch (std::out_of_range& e) {
10511       {
10512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10513       };
10514     } catch (std::exception& e) {
10515       {
10516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (...) {
10519       {
10520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10521       };
10522     }
10523   }
10524   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10525   return jresult;
10526 }
10527
10528
10529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10530   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10531
10532   arg1 = (Dali::Quaternion *)jarg1;
10533   {
10534     try {
10535       (arg1)->Conjugate();
10536     } catch (std::out_of_range& e) {
10537       {
10538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10539       };
10540     } catch (std::exception& e) {
10541       {
10542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10543       };
10544     } catch (...) {
10545       {
10546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10547       };
10548     }
10549   }
10550 }
10551
10552
10553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10554   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10555
10556   arg1 = (Dali::Quaternion *)jarg1;
10557   {
10558     try {
10559       (arg1)->Invert();
10560     } catch (std::out_of_range& e) {
10561       {
10562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10563       };
10564     } catch (std::exception& e) {
10565       {
10566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10567       };
10568     } catch (...) {
10569       {
10570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10571       };
10572     }
10573   }
10574 }
10575
10576
10577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10578   void * jresult ;
10579   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10580   Dali::Quaternion result;
10581
10582   arg1 = (Dali::Quaternion *)jarg1;
10583   {
10584     try {
10585       result = ((Dali::Quaternion const *)arg1)->Log();
10586     } catch (std::out_of_range& e) {
10587       {
10588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10589       };
10590     } catch (std::exception& e) {
10591       {
10592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10593       };
10594     } catch (...) {
10595       {
10596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10597       };
10598     }
10599   }
10600   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10601   return jresult;
10602 }
10603
10604
10605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10606   void * jresult ;
10607   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10608   Dali::Quaternion result;
10609
10610   arg1 = (Dali::Quaternion *)jarg1;
10611   {
10612     try {
10613       result = ((Dali::Quaternion const *)arg1)->Exp();
10614     } catch (std::out_of_range& e) {
10615       {
10616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10617       };
10618     } catch (std::exception& e) {
10619       {
10620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10621       };
10622     } catch (...) {
10623       {
10624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10625       };
10626     }
10627   }
10628   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10629   return jresult;
10630 }
10631
10632
10633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10634   float jresult ;
10635   Dali::Quaternion *arg1 = 0 ;
10636   Dali::Quaternion *arg2 = 0 ;
10637   float result;
10638
10639   arg1 = (Dali::Quaternion *)jarg1;
10640   if (!arg1) {
10641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10642     return 0;
10643   }
10644   arg2 = (Dali::Quaternion *)jarg2;
10645   if (!arg2) {
10646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10647     return 0;
10648   }
10649   {
10650     try {
10651       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10652     } catch (std::out_of_range& e) {
10653       {
10654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10655       };
10656     } catch (std::exception& e) {
10657       {
10658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10659       };
10660     } catch (...) {
10661       {
10662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10663       };
10664     }
10665   }
10666   jresult = result;
10667   return jresult;
10668 }
10669
10670
10671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10672   void * jresult ;
10673   Dali::Quaternion *arg1 = 0 ;
10674   Dali::Quaternion *arg2 = 0 ;
10675   float arg3 ;
10676   Dali::Quaternion result;
10677
10678   arg1 = (Dali::Quaternion *)jarg1;
10679   if (!arg1) {
10680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10681     return 0;
10682   }
10683   arg2 = (Dali::Quaternion *)jarg2;
10684   if (!arg2) {
10685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10686     return 0;
10687   }
10688   arg3 = (float)jarg3;
10689   {
10690     try {
10691       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10692     } catch (std::out_of_range& e) {
10693       {
10694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10695       };
10696     } catch (std::exception& e) {
10697       {
10698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10699       };
10700     } catch (...) {
10701       {
10702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10703       };
10704     }
10705   }
10706   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10707   return jresult;
10708 }
10709
10710
10711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10712   void * jresult ;
10713   Dali::Quaternion *arg1 = 0 ;
10714   Dali::Quaternion *arg2 = 0 ;
10715   float arg3 ;
10716   Dali::Quaternion result;
10717
10718   arg1 = (Dali::Quaternion *)jarg1;
10719   if (!arg1) {
10720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10721     return 0;
10722   }
10723   arg2 = (Dali::Quaternion *)jarg2;
10724   if (!arg2) {
10725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10726     return 0;
10727   }
10728   arg3 = (float)jarg3;
10729   {
10730     try {
10731       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10732     } catch (std::out_of_range& e) {
10733       {
10734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10735       };
10736     } catch (std::exception& e) {
10737       {
10738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10739       };
10740     } catch (...) {
10741       {
10742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10743       };
10744     }
10745   }
10746   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10747   return jresult;
10748 }
10749
10750
10751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10752   void * jresult ;
10753   Dali::Quaternion *arg1 = 0 ;
10754   Dali::Quaternion *arg2 = 0 ;
10755   float arg3 ;
10756   Dali::Quaternion result;
10757
10758   arg1 = (Dali::Quaternion *)jarg1;
10759   if (!arg1) {
10760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10761     return 0;
10762   }
10763   arg2 = (Dali::Quaternion *)jarg2;
10764   if (!arg2) {
10765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10766     return 0;
10767   }
10768   arg3 = (float)jarg3;
10769   {
10770     try {
10771       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10772     } catch (std::out_of_range& e) {
10773       {
10774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10775       };
10776     } catch (std::exception& e) {
10777       {
10778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10779       };
10780     } catch (...) {
10781       {
10782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10783       };
10784     }
10785   }
10786   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10787   return jresult;
10788 }
10789
10790
10791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10792   void * jresult ;
10793   Dali::Quaternion *arg1 = 0 ;
10794   Dali::Quaternion *arg2 = 0 ;
10795   Dali::Quaternion *arg3 = 0 ;
10796   Dali::Quaternion *arg4 = 0 ;
10797   float arg5 ;
10798   Dali::Quaternion result;
10799
10800   arg1 = (Dali::Quaternion *)jarg1;
10801   if (!arg1) {
10802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10803     return 0;
10804   }
10805   arg2 = (Dali::Quaternion *)jarg2;
10806   if (!arg2) {
10807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10808     return 0;
10809   }
10810   arg3 = (Dali::Quaternion *)jarg3;
10811   if (!arg3) {
10812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10813     return 0;
10814   }
10815   arg4 = (Dali::Quaternion *)jarg4;
10816   if (!arg4) {
10817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10818     return 0;
10819   }
10820   arg5 = (float)jarg5;
10821   {
10822     try {
10823       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10824     } catch (std::out_of_range& e) {
10825       {
10826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10827       };
10828     } catch (std::exception& e) {
10829       {
10830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10831       };
10832     } catch (...) {
10833       {
10834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10835       };
10836     }
10837   }
10838   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10839   return jresult;
10840 }
10841
10842
10843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10844   float jresult ;
10845   Dali::Quaternion *arg1 = 0 ;
10846   Dali::Quaternion *arg2 = 0 ;
10847   float result;
10848
10849   arg1 = (Dali::Quaternion *)jarg1;
10850   if (!arg1) {
10851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10852     return 0;
10853   }
10854   arg2 = (Dali::Quaternion *)jarg2;
10855   if (!arg2) {
10856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10857     return 0;
10858   }
10859   {
10860     try {
10861       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10862     } catch (std::out_of_range& e) {
10863       {
10864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10865       };
10866     } catch (std::exception& e) {
10867       {
10868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10869       };
10870     } catch (...) {
10871       {
10872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10873       };
10874     }
10875   }
10876   jresult = result;
10877   return jresult;
10878 }
10879
10880
10881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10882   void * jresult ;
10883   Dali::Matrix *result = 0 ;
10884
10885   {
10886     try {
10887       result = (Dali::Matrix *)new Dali::Matrix();
10888     } catch (std::out_of_range& e) {
10889       {
10890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10891       };
10892     } catch (std::exception& e) {
10893       {
10894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10895       };
10896     } catch (...) {
10897       {
10898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10899       };
10900     }
10901   }
10902   jresult = (void *)result;
10903   return jresult;
10904 }
10905
10906
10907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10908   void * jresult ;
10909   bool arg1 ;
10910   Dali::Matrix *result = 0 ;
10911
10912   arg1 = jarg1 ? true : false;
10913   {
10914     try {
10915       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10916     } catch (std::out_of_range& e) {
10917       {
10918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10919       };
10920     } catch (std::exception& e) {
10921       {
10922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10923       };
10924     } catch (...) {
10925       {
10926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10927       };
10928     }
10929   }
10930   jresult = (void *)result;
10931   return jresult;
10932 }
10933
10934
10935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10936   void * jresult ;
10937   float *arg1 = (float *) 0 ;
10938   Dali::Matrix *result = 0 ;
10939
10940   arg1 = jarg1;
10941   {
10942     try {
10943       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10944     } catch (std::out_of_range& e) {
10945       {
10946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10947       };
10948     } catch (std::exception& e) {
10949       {
10950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10951       };
10952     } catch (...) {
10953       {
10954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10955       };
10956     }
10957   }
10958   jresult = (void *)result;
10959
10960
10961   return jresult;
10962 }
10963
10964
10965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10966   void * jresult ;
10967   Dali::Quaternion *arg1 = 0 ;
10968   Dali::Matrix *result = 0 ;
10969
10970   arg1 = (Dali::Quaternion *)jarg1;
10971   if (!arg1) {
10972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10973     return 0;
10974   }
10975   {
10976     try {
10977       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10978     } catch (std::out_of_range& e) {
10979       {
10980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10981       };
10982     } catch (std::exception& e) {
10983       {
10984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10985       };
10986     } catch (...) {
10987       {
10988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10989       };
10990     }
10991   }
10992   jresult = (void *)result;
10993   return jresult;
10994 }
10995
10996
10997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10998   void * jresult ;
10999   Dali::Matrix *arg1 = 0 ;
11000   Dali::Matrix *result = 0 ;
11001
11002   arg1 = (Dali::Matrix *)jarg1;
11003   if (!arg1) {
11004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11005     return 0;
11006   }
11007   {
11008     try {
11009       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11010     } catch (std::out_of_range& e) {
11011       {
11012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11013       };
11014     } catch (std::exception& e) {
11015       {
11016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11017       };
11018     } catch (...) {
11019       {
11020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11021       };
11022     }
11023   }
11024   jresult = (void *)result;
11025   return jresult;
11026 }
11027
11028
11029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
11030   void * jresult ;
11031   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11032   Dali::Matrix *arg2 = 0 ;
11033   Dali::Matrix *result = 0 ;
11034
11035   arg1 = (Dali::Matrix *)jarg1;
11036   arg2 = (Dali::Matrix *)jarg2;
11037   if (!arg2) {
11038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11039     return 0;
11040   }
11041   {
11042     try {
11043       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11044     } catch (std::out_of_range& e) {
11045       {
11046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11047       };
11048     } catch (std::exception& e) {
11049       {
11050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11051       };
11052     } catch (...) {
11053       {
11054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11055       };
11056     }
11057   }
11058   jresult = (void *)result;
11059   return jresult;
11060 }
11061
11062
11063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11064   void * jresult ;
11065   Dali::Matrix *result = 0 ;
11066
11067   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11068   jresult = (void *)result;
11069   return jresult;
11070 }
11071
11072
11073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11074   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11075
11076   arg1 = (Dali::Matrix *)jarg1;
11077   {
11078     try {
11079       (arg1)->SetIdentity();
11080     } catch (std::out_of_range& e) {
11081       {
11082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11083       };
11084     } catch (std::exception& e) {
11085       {
11086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11087       };
11088     } catch (...) {
11089       {
11090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11091       };
11092     }
11093   }
11094 }
11095
11096
11097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11098   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11099   Dali::Vector3 *arg2 = 0 ;
11100
11101   arg1 = (Dali::Matrix *)jarg1;
11102   arg2 = (Dali::Vector3 *)jarg2;
11103   if (!arg2) {
11104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11105     return ;
11106   }
11107   {
11108     try {
11109       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11110     } catch (std::out_of_range& e) {
11111       {
11112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11113       };
11114     } catch (std::exception& e) {
11115       {
11116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11117       };
11118     } catch (...) {
11119       {
11120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11121       };
11122     }
11123   }
11124 }
11125
11126
11127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11128   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11129   Dali::Matrix *arg2 = 0 ;
11130
11131   arg1 = (Dali::Matrix *)jarg1;
11132   arg2 = (Dali::Matrix *)jarg2;
11133   if (!arg2) {
11134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11135     return ;
11136   }
11137   {
11138     try {
11139       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11140     } catch (std::out_of_range& e) {
11141       {
11142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11143       };
11144     } catch (std::exception& e) {
11145       {
11146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11147       };
11148     } catch (...) {
11149       {
11150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11151       };
11152     }
11153   }
11154 }
11155
11156
11157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11158   unsigned int jresult ;
11159   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11160   bool result;
11161
11162   arg1 = (Dali::Matrix *)jarg1;
11163   {
11164     try {
11165       result = (bool)(arg1)->Invert();
11166     } catch (std::out_of_range& e) {
11167       {
11168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11169       };
11170     } catch (std::exception& e) {
11171       {
11172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11173       };
11174     } catch (...) {
11175       {
11176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11177       };
11178     }
11179   }
11180   jresult = result;
11181   return jresult;
11182 }
11183
11184
11185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11186   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11187
11188   arg1 = (Dali::Matrix *)jarg1;
11189   {
11190     try {
11191       (arg1)->Transpose();
11192     } catch (std::out_of_range& e) {
11193       {
11194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11195       };
11196     } catch (std::exception& e) {
11197       {
11198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11199       };
11200     } catch (...) {
11201       {
11202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11203       };
11204     }
11205   }
11206 }
11207
11208
11209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11210   void * jresult ;
11211   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11212   Dali::Vector3 result;
11213
11214   arg1 = (Dali::Matrix *)jarg1;
11215   {
11216     try {
11217       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11218     } catch (std::out_of_range& e) {
11219       {
11220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11221       };
11222     } catch (std::exception& e) {
11223       {
11224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11225       };
11226     } catch (...) {
11227       {
11228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11229       };
11230     }
11231   }
11232   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11233   return jresult;
11234 }
11235
11236
11237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11238   void * jresult ;
11239   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11240   Dali::Vector3 result;
11241
11242   arg1 = (Dali::Matrix *)jarg1;
11243   {
11244     try {
11245       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11246     } catch (std::out_of_range& e) {
11247       {
11248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11249       };
11250     } catch (std::exception& e) {
11251       {
11252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11253       };
11254     } catch (...) {
11255       {
11256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11257       };
11258     }
11259   }
11260   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11261   return jresult;
11262 }
11263
11264
11265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11266   void * jresult ;
11267   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11268   Dali::Vector3 result;
11269
11270   arg1 = (Dali::Matrix *)jarg1;
11271   {
11272     try {
11273       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11274     } catch (std::out_of_range& e) {
11275       {
11276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11277       };
11278     } catch (std::exception& e) {
11279       {
11280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11281       };
11282     } catch (...) {
11283       {
11284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11285       };
11286     }
11287   }
11288   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11289   return jresult;
11290 }
11291
11292
11293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11294   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11295   Dali::Vector3 *arg2 = 0 ;
11296
11297   arg1 = (Dali::Matrix *)jarg1;
11298   arg2 = (Dali::Vector3 *)jarg2;
11299   if (!arg2) {
11300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11301     return ;
11302   }
11303   {
11304     try {
11305       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11306     } catch (std::out_of_range& e) {
11307       {
11308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11309       };
11310     } catch (std::exception& e) {
11311       {
11312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11313       };
11314     } catch (...) {
11315       {
11316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11317       };
11318     }
11319   }
11320 }
11321
11322
11323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11324   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11325   Dali::Vector3 *arg2 = 0 ;
11326
11327   arg1 = (Dali::Matrix *)jarg1;
11328   arg2 = (Dali::Vector3 *)jarg2;
11329   if (!arg2) {
11330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11331     return ;
11332   }
11333   {
11334     try {
11335       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11336     } catch (std::out_of_range& e) {
11337       {
11338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11339       };
11340     } catch (std::exception& e) {
11341       {
11342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11343       };
11344     } catch (...) {
11345       {
11346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11347       };
11348     }
11349   }
11350 }
11351
11352
11353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11354   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11355   Dali::Vector3 *arg2 = 0 ;
11356
11357   arg1 = (Dali::Matrix *)jarg1;
11358   arg2 = (Dali::Vector3 *)jarg2;
11359   if (!arg2) {
11360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11361     return ;
11362   }
11363   {
11364     try {
11365       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11366     } catch (std::out_of_range& e) {
11367       {
11368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11369       };
11370     } catch (std::exception& e) {
11371       {
11372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11373       };
11374     } catch (...) {
11375       {
11376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11377       };
11378     }
11379   }
11380 }
11381
11382
11383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11384   void * jresult ;
11385   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11386   Dali::Vector4 *result = 0 ;
11387
11388   arg1 = (Dali::Matrix *)jarg1;
11389   {
11390     try {
11391       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11392     } catch (std::out_of_range& e) {
11393       {
11394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11395       };
11396     } catch (std::exception& e) {
11397       {
11398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11399       };
11400     } catch (...) {
11401       {
11402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11403       };
11404     }
11405   }
11406   jresult = (void *)result;
11407   return jresult;
11408 }
11409
11410
11411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11412   void * jresult ;
11413   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11414   Dali::Vector3 *result = 0 ;
11415
11416   arg1 = (Dali::Matrix *)jarg1;
11417   {
11418     try {
11419       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11420     } catch (std::out_of_range& e) {
11421       {
11422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11423       };
11424     } catch (std::exception& e) {
11425       {
11426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11427       };
11428     } catch (...) {
11429       {
11430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11431       };
11432     }
11433   }
11434   jresult = (void *)result;
11435   return jresult;
11436 }
11437
11438
11439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11440   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11441   Dali::Vector4 *arg2 = 0 ;
11442
11443   arg1 = (Dali::Matrix *)jarg1;
11444   arg2 = (Dali::Vector4 *)jarg2;
11445   if (!arg2) {
11446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11447     return ;
11448   }
11449   {
11450     try {
11451       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11452     } catch (std::out_of_range& e) {
11453       {
11454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11455       };
11456     } catch (std::exception& e) {
11457       {
11458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11459       };
11460     } catch (...) {
11461       {
11462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11463       };
11464     }
11465   }
11466 }
11467
11468
11469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11470   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11471   Dali::Vector3 *arg2 = 0 ;
11472
11473   arg1 = (Dali::Matrix *)jarg1;
11474   arg2 = (Dali::Vector3 *)jarg2;
11475   if (!arg2) {
11476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11477     return ;
11478   }
11479   {
11480     try {
11481       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11482     } catch (std::out_of_range& e) {
11483       {
11484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11485       };
11486     } catch (std::exception& e) {
11487       {
11488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11489       };
11490     } catch (...) {
11491       {
11492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11493       };
11494     }
11495   }
11496 }
11497
11498
11499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11500   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11501
11502   arg1 = (Dali::Matrix *)jarg1;
11503   {
11504     try {
11505       (arg1)->OrthoNormalize();
11506     } catch (std::out_of_range& e) {
11507       {
11508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11509       };
11510     } catch (std::exception& e) {
11511       {
11512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11513       };
11514     } catch (...) {
11515       {
11516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11517       };
11518     }
11519   }
11520 }
11521
11522
11523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11524   void * jresult ;
11525   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11526   float *result = 0 ;
11527
11528   arg1 = (Dali::Matrix *)jarg1;
11529   {
11530     try {
11531       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11532     } catch (std::out_of_range& e) {
11533       {
11534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11535       };
11536     } catch (std::exception& e) {
11537       {
11538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11539       };
11540     } catch (...) {
11541       {
11542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11543       };
11544     }
11545   }
11546   jresult = (void *)result;
11547   return jresult;
11548 }
11549
11550
11551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11552   Dali::Matrix *arg1 = 0 ;
11553   Dali::Matrix *arg2 = 0 ;
11554   Dali::Matrix *arg3 = 0 ;
11555
11556   arg1 = (Dali::Matrix *)jarg1;
11557   if (!arg1) {
11558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11559     return ;
11560   }
11561   arg2 = (Dali::Matrix *)jarg2;
11562   if (!arg2) {
11563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11564     return ;
11565   }
11566   arg3 = (Dali::Matrix *)jarg3;
11567   if (!arg3) {
11568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11569     return ;
11570   }
11571   {
11572     try {
11573       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11574     } catch (std::out_of_range& e) {
11575       {
11576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11577       };
11578     } catch (std::exception& e) {
11579       {
11580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11581       };
11582     } catch (...) {
11583       {
11584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11585       };
11586     }
11587   }
11588 }
11589
11590
11591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11592   Dali::Matrix *arg1 = 0 ;
11593   Dali::Matrix *arg2 = 0 ;
11594   Dali::Quaternion *arg3 = 0 ;
11595
11596   arg1 = (Dali::Matrix *)jarg1;
11597   if (!arg1) {
11598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11599     return ;
11600   }
11601   arg2 = (Dali::Matrix *)jarg2;
11602   if (!arg2) {
11603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11604     return ;
11605   }
11606   arg3 = (Dali::Quaternion *)jarg3;
11607   if (!arg3) {
11608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11609     return ;
11610   }
11611   {
11612     try {
11613       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11614     } catch (std::out_of_range& e) {
11615       {
11616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11617       };
11618     } catch (std::exception& e) {
11619       {
11620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11621       };
11622     } catch (...) {
11623       {
11624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11625       };
11626     }
11627   }
11628 }
11629
11630
11631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11632   void * jresult ;
11633   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11634   Dali::Vector4 *arg2 = 0 ;
11635   Dali::Vector4 result;
11636
11637   arg1 = (Dali::Matrix *)jarg1;
11638   arg2 = (Dali::Vector4 *)jarg2;
11639   if (!arg2) {
11640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11641     return 0;
11642   }
11643   {
11644     try {
11645       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11646     } catch (std::out_of_range& e) {
11647       {
11648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11649       };
11650     } catch (std::exception& e) {
11651       {
11652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11653       };
11654     } catch (...) {
11655       {
11656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11657       };
11658     }
11659   }
11660   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11661   return jresult;
11662 }
11663
11664
11665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11666   unsigned int jresult ;
11667   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11668   Dali::Matrix *arg2 = 0 ;
11669   bool result;
11670
11671   arg1 = (Dali::Matrix *)jarg1;
11672   arg2 = (Dali::Matrix *)jarg2;
11673   if (!arg2) {
11674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11675     return 0;
11676   }
11677   {
11678     try {
11679       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11680     } catch (std::out_of_range& e) {
11681       {
11682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11683       };
11684     } catch (std::exception& e) {
11685       {
11686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11687       };
11688     } catch (...) {
11689       {
11690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11691       };
11692     }
11693   }
11694   jresult = result;
11695   return jresult;
11696 }
11697
11698
11699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11700   unsigned int jresult ;
11701   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11702   Dali::Matrix *arg2 = 0 ;
11703   bool result;
11704
11705   arg1 = (Dali::Matrix *)jarg1;
11706   arg2 = (Dali::Matrix *)jarg2;
11707   if (!arg2) {
11708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11709     return 0;
11710   }
11711   {
11712     try {
11713       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11714     } catch (std::out_of_range& e) {
11715       {
11716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11717       };
11718     } catch (std::exception& e) {
11719       {
11720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11721       };
11722     } catch (...) {
11723       {
11724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11725       };
11726     }
11727   }
11728   jresult = result;
11729   return jresult;
11730 }
11731
11732
11733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11734   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11735   Dali::Vector3 *arg2 = 0 ;
11736   Dali::Quaternion *arg3 = 0 ;
11737   Dali::Vector3 *arg4 = 0 ;
11738
11739   arg1 = (Dali::Matrix *)jarg1;
11740   arg2 = (Dali::Vector3 *)jarg2;
11741   if (!arg2) {
11742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11743     return ;
11744   }
11745   arg3 = (Dali::Quaternion *)jarg3;
11746   if (!arg3) {
11747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11748     return ;
11749   }
11750   arg4 = (Dali::Vector3 *)jarg4;
11751   if (!arg4) {
11752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11753     return ;
11754   }
11755   {
11756     try {
11757       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11758     } catch (std::out_of_range& e) {
11759       {
11760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11761       };
11762     } catch (std::exception& e) {
11763       {
11764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11765       };
11766     } catch (...) {
11767       {
11768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11769       };
11770     }
11771   }
11772 }
11773
11774
11775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11776   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11777   Dali::Vector3 *arg2 = 0 ;
11778   Dali::Quaternion *arg3 = 0 ;
11779   Dali::Vector3 *arg4 = 0 ;
11780
11781   arg1 = (Dali::Matrix *)jarg1;
11782   arg2 = (Dali::Vector3 *)jarg2;
11783   if (!arg2) {
11784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11785     return ;
11786   }
11787   arg3 = (Dali::Quaternion *)jarg3;
11788   if (!arg3) {
11789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11790     return ;
11791   }
11792   arg4 = (Dali::Vector3 *)jarg4;
11793   if (!arg4) {
11794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11795     return ;
11796   }
11797   {
11798     try {
11799       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11800     } catch (std::out_of_range& e) {
11801       {
11802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11803       };
11804     } catch (std::exception& e) {
11805       {
11806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11807       };
11808     } catch (...) {
11809       {
11810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11811       };
11812     }
11813   }
11814 }
11815
11816
11817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11818   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11819   Dali::Vector3 *arg2 = 0 ;
11820   Dali::Vector3 *arg3 = 0 ;
11821   Dali::Vector3 *arg4 = 0 ;
11822   Dali::Vector3 *arg5 = 0 ;
11823
11824   arg1 = (Dali::Matrix *)jarg1;
11825   arg2 = (Dali::Vector3 *)jarg2;
11826   if (!arg2) {
11827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11828     return ;
11829   }
11830   arg3 = (Dali::Vector3 *)jarg3;
11831   if (!arg3) {
11832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11833     return ;
11834   }
11835   arg4 = (Dali::Vector3 *)jarg4;
11836   if (!arg4) {
11837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11838     return ;
11839   }
11840   arg5 = (Dali::Vector3 *)jarg5;
11841   if (!arg5) {
11842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11843     return ;
11844   }
11845   {
11846     try {
11847       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11848     } catch (std::out_of_range& e) {
11849       {
11850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11851       };
11852     } catch (std::exception& e) {
11853       {
11854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11855       };
11856     } catch (...) {
11857       {
11858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11859       };
11860     }
11861   }
11862 }
11863
11864
11865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11866   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11867   Dali::Vector3 *arg2 = 0 ;
11868   Dali::Quaternion *arg3 = 0 ;
11869   Dali::Vector3 *arg4 = 0 ;
11870
11871   arg1 = (Dali::Matrix *)jarg1;
11872   arg2 = (Dali::Vector3 *)jarg2;
11873   if (!arg2) {
11874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11875     return ;
11876   }
11877   arg3 = (Dali::Quaternion *)jarg3;
11878   if (!arg3) {
11879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11880     return ;
11881   }
11882   arg4 = (Dali::Vector3 *)jarg4;
11883   if (!arg4) {
11884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11885     return ;
11886   }
11887   {
11888     try {
11889       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11890     } catch (std::out_of_range& e) {
11891       {
11892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11893       };
11894     } catch (std::exception& e) {
11895       {
11896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11897       };
11898     } catch (...) {
11899       {
11900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11901       };
11902     }
11903   }
11904 }
11905
11906
11907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11908   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11909
11910   arg1 = (Dali::Matrix *)jarg1;
11911   {
11912     try {
11913       delete arg1;
11914     } catch (std::out_of_range& e) {
11915       {
11916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11917       };
11918     } catch (std::exception& e) {
11919       {
11920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11921       };
11922     } catch (...) {
11923       {
11924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11925       };
11926     }
11927   }
11928 }
11929
11930
11931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11932   void * jresult ;
11933   Dali::Matrix3 *result = 0 ;
11934
11935   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11936   jresult = (void *)result;
11937   return jresult;
11938 }
11939
11940
11941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11942   void * jresult ;
11943   Dali::Matrix3 *result = 0 ;
11944
11945   {
11946     try {
11947       result = (Dali::Matrix3 *)new Dali::Matrix3();
11948     } catch (std::out_of_range& e) {
11949       {
11950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11951       };
11952     } catch (std::exception& e) {
11953       {
11954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11955       };
11956     } catch (...) {
11957       {
11958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11959       };
11960     }
11961   }
11962   jresult = (void *)result;
11963   return jresult;
11964 }
11965
11966
11967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11968   void * jresult ;
11969   Dali::Matrix3 *arg1 = 0 ;
11970   Dali::Matrix3 *result = 0 ;
11971
11972   arg1 = (Dali::Matrix3 *)jarg1;
11973   if (!arg1) {
11974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11975     return 0;
11976   }
11977   {
11978     try {
11979       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11980     } catch (std::out_of_range& e) {
11981       {
11982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11983       };
11984     } catch (std::exception& e) {
11985       {
11986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11987       };
11988     } catch (...) {
11989       {
11990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11991       };
11992     }
11993   }
11994   jresult = (void *)result;
11995   return jresult;
11996 }
11997
11998
11999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
12000   void * jresult ;
12001   Dali::Matrix *arg1 = 0 ;
12002   Dali::Matrix3 *result = 0 ;
12003
12004   arg1 = (Dali::Matrix *)jarg1;
12005   if (!arg1) {
12006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12007     return 0;
12008   }
12009   {
12010     try {
12011       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12012     } catch (std::out_of_range& e) {
12013       {
12014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12015       };
12016     } catch (std::exception& e) {
12017       {
12018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12019       };
12020     } catch (...) {
12021       {
12022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12023       };
12024     }
12025   }
12026   jresult = (void *)result;
12027   return jresult;
12028 }
12029
12030
12031 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) {
12032   void * jresult ;
12033   float arg1 ;
12034   float arg2 ;
12035   float arg3 ;
12036   float arg4 ;
12037   float arg5 ;
12038   float arg6 ;
12039   float arg7 ;
12040   float arg8 ;
12041   float arg9 ;
12042   Dali::Matrix3 *result = 0 ;
12043
12044   arg1 = (float)jarg1;
12045   arg2 = (float)jarg2;
12046   arg3 = (float)jarg3;
12047   arg4 = (float)jarg4;
12048   arg5 = (float)jarg5;
12049   arg6 = (float)jarg6;
12050   arg7 = (float)jarg7;
12051   arg8 = (float)jarg8;
12052   arg9 = (float)jarg9;
12053   {
12054     try {
12055       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12056     } catch (std::out_of_range& e) {
12057       {
12058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12059       };
12060     } catch (std::exception& e) {
12061       {
12062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12063       };
12064     } catch (...) {
12065       {
12066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12067       };
12068     }
12069   }
12070   jresult = (void *)result;
12071   return jresult;
12072 }
12073
12074
12075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12076   void * jresult ;
12077   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12078   Dali::Matrix3 *arg2 = 0 ;
12079   Dali::Matrix3 *result = 0 ;
12080
12081   arg1 = (Dali::Matrix3 *)jarg1;
12082   arg2 = (Dali::Matrix3 *)jarg2;
12083   if (!arg2) {
12084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12085     return 0;
12086   }
12087   {
12088     try {
12089       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12090     } catch (std::out_of_range& e) {
12091       {
12092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12093       };
12094     } catch (std::exception& e) {
12095       {
12096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12097       };
12098     } catch (...) {
12099       {
12100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12101       };
12102     }
12103   }
12104   jresult = (void *)result;
12105   return jresult;
12106 }
12107
12108
12109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12110   void * jresult ;
12111   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12112   Dali::Matrix *arg2 = 0 ;
12113   Dali::Matrix3 *result = 0 ;
12114
12115   arg1 = (Dali::Matrix3 *)jarg1;
12116   arg2 = (Dali::Matrix *)jarg2;
12117   if (!arg2) {
12118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12119     return 0;
12120   }
12121   {
12122     try {
12123       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12124     } catch (std::out_of_range& e) {
12125       {
12126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12127       };
12128     } catch (std::exception& e) {
12129       {
12130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12131       };
12132     } catch (...) {
12133       {
12134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12135       };
12136     }
12137   }
12138   jresult = (void *)result;
12139   return jresult;
12140 }
12141
12142
12143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12144   unsigned int jresult ;
12145   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12146   Dali::Matrix3 *arg2 = 0 ;
12147   bool result;
12148
12149   arg1 = (Dali::Matrix3 *)jarg1;
12150   arg2 = (Dali::Matrix3 *)jarg2;
12151   if (!arg2) {
12152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12153     return 0;
12154   }
12155   {
12156     try {
12157       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12158     } catch (std::out_of_range& e) {
12159       {
12160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12161       };
12162     } catch (std::exception& e) {
12163       {
12164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12165       };
12166     } catch (...) {
12167       {
12168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12169       };
12170     }
12171   }
12172   jresult = result;
12173   return jresult;
12174 }
12175
12176
12177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12178   unsigned int jresult ;
12179   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12180   Dali::Matrix3 *arg2 = 0 ;
12181   bool result;
12182
12183   arg1 = (Dali::Matrix3 *)jarg1;
12184   arg2 = (Dali::Matrix3 *)jarg2;
12185   if (!arg2) {
12186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12187     return 0;
12188   }
12189   {
12190     try {
12191       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12192     } catch (std::out_of_range& e) {
12193       {
12194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12195       };
12196     } catch (std::exception& e) {
12197       {
12198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12199       };
12200     } catch (...) {
12201       {
12202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12203       };
12204     }
12205   }
12206   jresult = result;
12207   return jresult;
12208 }
12209
12210
12211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12212   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12213
12214   arg1 = (Dali::Matrix3 *)jarg1;
12215   {
12216     try {
12217       delete arg1;
12218     } catch (std::out_of_range& e) {
12219       {
12220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12221       };
12222     } catch (std::exception& e) {
12223       {
12224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12225       };
12226     } catch (...) {
12227       {
12228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12229       };
12230     }
12231   }
12232 }
12233
12234
12235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12236   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12237
12238   arg1 = (Dali::Matrix3 *)jarg1;
12239   {
12240     try {
12241       (arg1)->SetIdentity();
12242     } catch (std::out_of_range& e) {
12243       {
12244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12245       };
12246     } catch (std::exception& e) {
12247       {
12248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12249       };
12250     } catch (...) {
12251       {
12252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12253       };
12254     }
12255   }
12256 }
12257
12258
12259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12260   void * jresult ;
12261   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12262   float *result = 0 ;
12263
12264   arg1 = (Dali::Matrix3 *)jarg1;
12265   {
12266     try {
12267       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12268     } catch (std::out_of_range& e) {
12269       {
12270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12271       };
12272     } catch (std::exception& e) {
12273       {
12274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12275       };
12276     } catch (...) {
12277       {
12278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12279       };
12280     }
12281   }
12282   jresult = (void *)result;
12283   return jresult;
12284 }
12285
12286
12287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12288   unsigned int jresult ;
12289   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12290   bool result;
12291
12292   arg1 = (Dali::Matrix3 *)jarg1;
12293   {
12294     try {
12295       result = (bool)(arg1)->Invert();
12296     } catch (std::out_of_range& e) {
12297       {
12298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12299       };
12300     } catch (std::exception& e) {
12301       {
12302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12303       };
12304     } catch (...) {
12305       {
12306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12307       };
12308     }
12309   }
12310   jresult = result;
12311   return jresult;
12312 }
12313
12314
12315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12316   unsigned int jresult ;
12317   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12318   bool result;
12319
12320   arg1 = (Dali::Matrix3 *)jarg1;
12321   {
12322     try {
12323       result = (bool)(arg1)->Transpose();
12324     } catch (std::out_of_range& e) {
12325       {
12326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12327       };
12328     } catch (std::exception& e) {
12329       {
12330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12331       };
12332     } catch (...) {
12333       {
12334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12335       };
12336     }
12337   }
12338   jresult = result;
12339   return jresult;
12340 }
12341
12342
12343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12344   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12345   float arg2 ;
12346
12347   arg1 = (Dali::Matrix3 *)jarg1;
12348   arg2 = (float)jarg2;
12349   {
12350     try {
12351       (arg1)->Scale(arg2);
12352     } catch (std::out_of_range& e) {
12353       {
12354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12355       };
12356     } catch (std::exception& e) {
12357       {
12358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12359       };
12360     } catch (...) {
12361       {
12362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12363       };
12364     }
12365   }
12366 }
12367
12368
12369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12370   float jresult ;
12371   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12372   float result;
12373
12374   arg1 = (Dali::Matrix3 *)jarg1;
12375   {
12376     try {
12377       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12378     } catch (std::out_of_range& e) {
12379       {
12380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12381       };
12382     } catch (std::exception& e) {
12383       {
12384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12385       };
12386     } catch (...) {
12387       {
12388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12389       };
12390     }
12391   }
12392   jresult = result;
12393   return jresult;
12394 }
12395
12396
12397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12398   unsigned int jresult ;
12399   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12400   bool result;
12401
12402   arg1 = (Dali::Matrix3 *)jarg1;
12403   {
12404     try {
12405       result = (bool)(arg1)->ScaledInverseTranspose();
12406     } catch (std::out_of_range& e) {
12407       {
12408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12409       };
12410     } catch (std::exception& e) {
12411       {
12412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12413       };
12414     } catch (...) {
12415       {
12416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12417       };
12418     }
12419   }
12420   jresult = result;
12421   return jresult;
12422 }
12423
12424
12425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12426   Dali::Matrix3 *arg1 = 0 ;
12427   Dali::Matrix3 *arg2 = 0 ;
12428   Dali::Matrix3 *arg3 = 0 ;
12429
12430   arg1 = (Dali::Matrix3 *)jarg1;
12431   if (!arg1) {
12432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12433     return ;
12434   }
12435   arg2 = (Dali::Matrix3 *)jarg2;
12436   if (!arg2) {
12437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12438     return ;
12439   }
12440   arg3 = (Dali::Matrix3 *)jarg3;
12441   if (!arg3) {
12442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12443     return ;
12444   }
12445   {
12446     try {
12447       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12448     } catch (std::out_of_range& e) {
12449       {
12450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12451       };
12452     } catch (std::exception& e) {
12453       {
12454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12455       };
12456     } catch (...) {
12457       {
12458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12459       };
12460     }
12461   }
12462 }
12463
12464
12465 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12466   float jresult ;
12467   float arg1 ;
12468   float arg2 ;
12469   float result;
12470
12471   arg1 = (float)jarg1;
12472   arg2 = (float)jarg2;
12473   {
12474     try {
12475       result = (float)Dali::Random::Range(arg1,arg2);
12476     } catch (std::out_of_range& e) {
12477       {
12478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12479       };
12480     } catch (std::exception& e) {
12481       {
12482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12483       };
12484     } catch (...) {
12485       {
12486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12487       };
12488     }
12489   }
12490   jresult = result;
12491   return jresult;
12492 }
12493
12494
12495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12496   void * jresult ;
12497   Dali::Vector4 result;
12498
12499   {
12500     try {
12501       result = Dali::Random::Axis();
12502     } catch (std::out_of_range& e) {
12503       {
12504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12505       };
12506     } catch (std::exception& e) {
12507       {
12508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12509       };
12510     } catch (...) {
12511       {
12512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12513       };
12514     }
12515   }
12516   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12517   return jresult;
12518 }
12519
12520
12521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12522   void * jresult ;
12523   Dali::AngleAxis *result = 0 ;
12524
12525   {
12526     try {
12527       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12528     } catch (std::out_of_range& e) {
12529       {
12530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12531       };
12532     } catch (std::exception& e) {
12533       {
12534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12535       };
12536     } catch (...) {
12537       {
12538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12539       };
12540     }
12541   }
12542   jresult = (void *)result;
12543   return jresult;
12544 }
12545
12546
12547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12548   void * jresult ;
12549   Dali::Radian arg1 ;
12550   Dali::Vector3 *arg2 = 0 ;
12551   Dali::Radian *argp1 ;
12552   Dali::AngleAxis *result = 0 ;
12553
12554   argp1 = (Dali::Radian *)jarg1;
12555   if (!argp1) {
12556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12557     return 0;
12558   }
12559   arg1 = *argp1;
12560   arg2 = (Dali::Vector3 *)jarg2;
12561   if (!arg2) {
12562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12563     return 0;
12564   }
12565   {
12566     try {
12567       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12568     } catch (std::out_of_range& e) {
12569       {
12570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12571       };
12572     } catch (std::exception& e) {
12573       {
12574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12575       };
12576     } catch (...) {
12577       {
12578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12579       };
12580     }
12581   }
12582   jresult = (void *)result;
12583   return jresult;
12584 }
12585
12586
12587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12588   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12589   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12590
12591   arg1 = (Dali::AngleAxis *)jarg1;
12592   arg2 = (Dali::Radian *)jarg2;
12593   if (arg1) (arg1)->angle = *arg2;
12594 }
12595
12596
12597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12598   void * jresult ;
12599   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12600   Dali::Radian *result = 0 ;
12601
12602   arg1 = (Dali::AngleAxis *)jarg1;
12603   result = (Dali::Radian *)& ((arg1)->angle);
12604   jresult = (void *)result;
12605   return jresult;
12606 }
12607
12608
12609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12610   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12611   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12612
12613   arg1 = (Dali::AngleAxis *)jarg1;
12614   arg2 = (Dali::Vector3 *)jarg2;
12615   if (arg1) (arg1)->axis = *arg2;
12616 }
12617
12618
12619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12620   void * jresult ;
12621   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12622   Dali::Vector3 *result = 0 ;
12623
12624   arg1 = (Dali::AngleAxis *)jarg1;
12625   result = (Dali::Vector3 *)& ((arg1)->axis);
12626   jresult = (void *)result;
12627   return jresult;
12628 }
12629
12630
12631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12632   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12633
12634   arg1 = (Dali::AngleAxis *)jarg1;
12635   {
12636     try {
12637       delete arg1;
12638     } catch (std::out_of_range& e) {
12639       {
12640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12641       };
12642     } catch (std::exception& e) {
12643       {
12644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12645       };
12646     } catch (...) {
12647       {
12648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12649       };
12650     }
12651   }
12652 }
12653
12654
12655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12656   unsigned int jresult ;
12657   Dali::AngleAxis *arg1 = 0 ;
12658   Dali::AngleAxis *arg2 = 0 ;
12659   bool result;
12660
12661   arg1 = (Dali::AngleAxis *)jarg1;
12662   if (!arg1) {
12663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12664     return 0;
12665   }
12666   arg2 = (Dali::AngleAxis *)jarg2;
12667   if (!arg2) {
12668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12669     return 0;
12670   }
12671   {
12672     try {
12673       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12674     } catch (std::out_of_range& e) {
12675       {
12676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12677       };
12678     } catch (std::exception& e) {
12679       {
12680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12681       };
12682     } catch (...) {
12683       {
12684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12685       };
12686     }
12687   }
12688   jresult = result;
12689   return jresult;
12690 }
12691
12692
12693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12694   unsigned int jresult ;
12695   unsigned int arg1 ;
12696   unsigned int result;
12697
12698   arg1 = (unsigned int)jarg1;
12699   {
12700     try {
12701       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12702     } catch (std::out_of_range& e) {
12703       {
12704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12705       };
12706     } catch (std::exception& e) {
12707       {
12708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12709       };
12710     } catch (...) {
12711       {
12712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12713       };
12714     }
12715   }
12716   jresult = result;
12717   return jresult;
12718 }
12719
12720
12721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12722   unsigned int jresult ;
12723   unsigned int arg1 ;
12724   bool result;
12725
12726   arg1 = (unsigned int)jarg1;
12727   {
12728     try {
12729       result = (bool)Dali::IsPowerOfTwo(arg1);
12730     } catch (std::out_of_range& e) {
12731       {
12732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12733       };
12734     } catch (std::exception& e) {
12735       {
12736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12737       };
12738     } catch (...) {
12739       {
12740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12741       };
12742     }
12743   }
12744   jresult = result;
12745   return jresult;
12746 }
12747
12748
12749 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12750   float jresult ;
12751   float arg1 ;
12752   float arg2 ;
12753   float result;
12754
12755   arg1 = (float)jarg1;
12756   arg2 = (float)jarg2;
12757   {
12758     try {
12759       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12760     } catch (std::out_of_range& e) {
12761       {
12762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12763       };
12764     } catch (std::exception& e) {
12765       {
12766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12767       };
12768     } catch (...) {
12769       {
12770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12771       };
12772     }
12773   }
12774   jresult = result;
12775   return jresult;
12776 }
12777
12778
12779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12780   unsigned int jresult ;
12781   float arg1 ;
12782   bool result;
12783
12784   arg1 = (float)jarg1;
12785   {
12786     try {
12787       result = (bool)Dali::EqualsZero(arg1);
12788     } catch (std::out_of_range& e) {
12789       {
12790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12791       };
12792     } catch (std::exception& e) {
12793       {
12794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12795       };
12796     } catch (...) {
12797       {
12798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12799       };
12800     }
12801   }
12802   jresult = result;
12803   return jresult;
12804 }
12805
12806
12807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12808   unsigned int jresult ;
12809   float arg1 ;
12810   float arg2 ;
12811   bool result;
12812
12813   arg1 = (float)jarg1;
12814   arg2 = (float)jarg2;
12815   {
12816     try {
12817       result = (bool)Dali::Equals(arg1,arg2);
12818     } catch (std::out_of_range& e) {
12819       {
12820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12821       };
12822     } catch (std::exception& e) {
12823       {
12824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12825       };
12826     } catch (...) {
12827       {
12828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12829       };
12830     }
12831   }
12832   jresult = result;
12833   return jresult;
12834 }
12835
12836
12837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12838   unsigned int jresult ;
12839   float arg1 ;
12840   float arg2 ;
12841   float arg3 ;
12842   bool result;
12843
12844   arg1 = (float)jarg1;
12845   arg2 = (float)jarg2;
12846   arg3 = (float)jarg3;
12847   {
12848     try {
12849       result = (bool)Dali::Equals(arg1,arg2,arg3);
12850     } catch (std::out_of_range& e) {
12851       {
12852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12853       };
12854     } catch (std::exception& e) {
12855       {
12856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12857       };
12858     } catch (...) {
12859       {
12860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12861       };
12862     }
12863   }
12864   jresult = result;
12865   return jresult;
12866 }
12867
12868
12869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12870   float jresult ;
12871   float arg1 ;
12872   int arg2 ;
12873   float result;
12874
12875   arg1 = (float)jarg1;
12876   arg2 = (int)jarg2;
12877   {
12878     try {
12879       result = (float)Dali::Round(arg1,arg2);
12880     } catch (std::out_of_range& e) {
12881       {
12882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12883       };
12884     } catch (std::exception& e) {
12885       {
12886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12887       };
12888     } catch (...) {
12889       {
12890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12891       };
12892     }
12893   }
12894   jresult = result;
12895   return jresult;
12896 }
12897
12898
12899 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12900   float jresult ;
12901   float arg1 ;
12902   float arg2 ;
12903   float arg3 ;
12904   float result;
12905
12906   arg1 = (float)jarg1;
12907   arg2 = (float)jarg2;
12908   arg3 = (float)jarg3;
12909   {
12910     try {
12911       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12912     } catch (std::out_of_range& e) {
12913       {
12914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12915       };
12916     } catch (std::exception& e) {
12917       {
12918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12919       };
12920     } catch (...) {
12921       {
12922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12923       };
12924     }
12925   }
12926   jresult = result;
12927   return jresult;
12928 }
12929
12930
12931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12932   float jresult ;
12933   float arg1 ;
12934   float arg2 ;
12935   float arg3 ;
12936   float arg4 ;
12937   float result;
12938
12939   arg1 = (float)jarg1;
12940   arg2 = (float)jarg2;
12941   arg3 = (float)jarg3;
12942   arg4 = (float)jarg4;
12943   {
12944     try {
12945       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12946     } catch (std::out_of_range& e) {
12947       {
12948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12949       };
12950     } catch (std::exception& e) {
12951       {
12952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12953       };
12954     } catch (...) {
12955       {
12956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12957       };
12958     }
12959   }
12960   jresult = result;
12961   return jresult;
12962 }
12963
12964
12965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12966   int jresult ;
12967   int result;
12968
12969   result = (int)(int)Dali::Property::INVALID_INDEX;
12970   jresult = result;
12971   return jresult;
12972 }
12973
12974
12975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12976   int jresult ;
12977   int result;
12978
12979   result = (int)(int)Dali::Property::INVALID_KEY;
12980   jresult = result;
12981   return jresult;
12982 }
12983
12984
12985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12986   int jresult ;
12987   int result;
12988
12989   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12990   jresult = result;
12991   return jresult;
12992 }
12993
12994
12995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12996   void * jresult ;
12997   Dali::Handle *arg1 = 0 ;
12998   Dali::Property::Index arg2 ;
12999   Dali::Property *result = 0 ;
13000
13001   arg1 = (Dali::Handle *)jarg1;
13002   if (!arg1) {
13003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13004     return 0;
13005   }
13006   arg2 = (Dali::Property::Index)jarg2;
13007   {
13008     try {
13009       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
13010     } catch (std::out_of_range& e) {
13011       {
13012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13013       };
13014     } catch (std::exception& e) {
13015       {
13016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13017       };
13018     } catch (...) {
13019       {
13020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13021       };
13022     }
13023   }
13024   jresult = (void *)result;
13025   return jresult;
13026 }
13027
13028
13029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13030   void * jresult ;
13031   Dali::Handle *arg1 = 0 ;
13032   Dali::Property::Index arg2 ;
13033   int arg3 ;
13034   Dali::Property *result = 0 ;
13035
13036   arg1 = (Dali::Handle *)jarg1;
13037   if (!arg1) {
13038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13039     return 0;
13040   }
13041   arg2 = (Dali::Property::Index)jarg2;
13042   arg3 = (int)jarg3;
13043   {
13044     try {
13045       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13046     } catch (std::out_of_range& e) {
13047       {
13048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13049       };
13050     } catch (std::exception& e) {
13051       {
13052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13053       };
13054     } catch (...) {
13055       {
13056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13057       };
13058     }
13059   }
13060   jresult = (void *)result;
13061   return jresult;
13062 }
13063
13064
13065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13066   void * jresult ;
13067   Dali::Handle *arg1 = 0 ;
13068   std::string *arg2 = 0 ;
13069   Dali::Property *result = 0 ;
13070
13071   arg1 = (Dali::Handle *)jarg1;
13072   if (!arg1) {
13073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13074     return 0;
13075   }
13076   if (!jarg2) {
13077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13078     return 0;
13079   }
13080   std::string arg2_str(jarg2);
13081   arg2 = &arg2_str;
13082   {
13083     try {
13084       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13085     } catch (std::out_of_range& e) {
13086       {
13087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13088       };
13089     } catch (std::exception& e) {
13090       {
13091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13092       };
13093     } catch (...) {
13094       {
13095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13096       };
13097     }
13098   }
13099   jresult = (void *)result;
13100
13101   //argout typemap for const std::string&
13102
13103   return jresult;
13104 }
13105
13106
13107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13108   void * jresult ;
13109   Dali::Handle *arg1 = 0 ;
13110   std::string *arg2 = 0 ;
13111   int arg3 ;
13112   Dali::Property *result = 0 ;
13113
13114   arg1 = (Dali::Handle *)jarg1;
13115   if (!arg1) {
13116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13117     return 0;
13118   }
13119   if (!jarg2) {
13120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13121     return 0;
13122   }
13123   std::string arg2_str(jarg2);
13124   arg2 = &arg2_str;
13125   arg3 = (int)jarg3;
13126   {
13127     try {
13128       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13129     } catch (std::out_of_range& e) {
13130       {
13131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13132       };
13133     } catch (std::exception& e) {
13134       {
13135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13136       };
13137     } catch (...) {
13138       {
13139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13140       };
13141     }
13142   }
13143   jresult = (void *)result;
13144
13145   //argout typemap for const std::string&
13146
13147   return jresult;
13148 }
13149
13150
13151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13152   Dali::Property *arg1 = (Dali::Property *) 0 ;
13153
13154   arg1 = (Dali::Property *)jarg1;
13155   {
13156     try {
13157       delete arg1;
13158     } catch (std::out_of_range& e) {
13159       {
13160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13161       };
13162     } catch (std::exception& e) {
13163       {
13164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13165       };
13166     } catch (...) {
13167       {
13168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13169       };
13170     }
13171   }
13172 }
13173
13174
13175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13176   Dali::Property *arg1 = (Dali::Property *) 0 ;
13177   Dali::Handle *arg2 = 0 ;
13178
13179   arg1 = (Dali::Property *)jarg1;
13180   arg2 = (Dali::Handle *)jarg2;
13181   if (!arg2) {
13182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13183     return ;
13184   }
13185   if (arg1) (arg1)->object = *arg2;
13186 }
13187
13188
13189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13190   void * jresult ;
13191   Dali::Property *arg1 = (Dali::Property *) 0 ;
13192   Dali::Handle *result = 0 ;
13193
13194   arg1 = (Dali::Property *)jarg1;
13195   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13196   jresult = (void *)result;
13197   return jresult;
13198 }
13199
13200
13201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13202   Dali::Property *arg1 = (Dali::Property *) 0 ;
13203   Dali::Property::Index arg2 ;
13204
13205   arg1 = (Dali::Property *)jarg1;
13206   arg2 = (Dali::Property::Index)jarg2;
13207   if (arg1) (arg1)->propertyIndex = arg2;
13208 }
13209
13210
13211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13212   int jresult ;
13213   Dali::Property *arg1 = (Dali::Property *) 0 ;
13214   Dali::Property::Index result;
13215
13216   arg1 = (Dali::Property *)jarg1;
13217   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13218   jresult = result;
13219   return jresult;
13220 }
13221
13222
13223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13224   Dali::Property *arg1 = (Dali::Property *) 0 ;
13225   int arg2 ;
13226
13227   arg1 = (Dali::Property *)jarg1;
13228   arg2 = (int)jarg2;
13229   if (arg1) (arg1)->componentIndex = arg2;
13230 }
13231
13232
13233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13234   int jresult ;
13235   Dali::Property *arg1 = (Dali::Property *) 0 ;
13236   int result;
13237
13238   arg1 = (Dali::Property *)jarg1;
13239   result = (int) ((arg1)->componentIndex);
13240   jresult = result;
13241   return jresult;
13242 }
13243
13244
13245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13246   void * jresult ;
13247   Dali::Property::Array *result = 0 ;
13248
13249   {
13250     try {
13251       result = (Dali::Property::Array *)new Dali::Property::Array();
13252     } catch (std::out_of_range& e) {
13253       {
13254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13255       };
13256     } catch (std::exception& e) {
13257       {
13258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13259       };
13260     } catch (...) {
13261       {
13262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13263       };
13264     }
13265   }
13266   jresult = (void *)result;
13267   return jresult;
13268 }
13269
13270
13271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13272   void * jresult ;
13273   Dali::Property::Array *arg1 = 0 ;
13274   Dali::Property::Array *result = 0 ;
13275
13276   arg1 = (Dali::Property::Array *)jarg1;
13277   if (!arg1) {
13278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13279     return 0;
13280   }
13281   {
13282     try {
13283       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13284     } catch (std::out_of_range& e) {
13285       {
13286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13287       };
13288     } catch (std::exception& e) {
13289       {
13290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13291       };
13292     } catch (...) {
13293       {
13294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13295       };
13296     }
13297   }
13298   jresult = (void *)result;
13299   return jresult;
13300 }
13301
13302
13303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13304   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13305
13306   arg1 = (Dali::Property::Array *)jarg1;
13307   {
13308     try {
13309       delete arg1;
13310     } catch (std::out_of_range& e) {
13311       {
13312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13313       };
13314     } catch (std::exception& e) {
13315       {
13316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13317       };
13318     } catch (...) {
13319       {
13320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13321       };
13322     }
13323   }
13324 }
13325
13326
13327 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13328   unsigned long jresult ;
13329   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13330   Dali::Property::Array::SizeType result;
13331
13332   arg1 = (Dali::Property::Array *)jarg1;
13333   {
13334     try {
13335       result = ((Dali::Property::Array const *)arg1)->Size();
13336     } catch (std::out_of_range& e) {
13337       {
13338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13339       };
13340     } catch (std::exception& e) {
13341       {
13342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13343       };
13344     } catch (...) {
13345       {
13346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13347       };
13348     }
13349   }
13350   jresult = (unsigned long)result;
13351   return jresult;
13352 }
13353
13354
13355 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13356   unsigned long jresult ;
13357   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13358   Dali::Property::Array::SizeType result;
13359
13360   arg1 = (Dali::Property::Array *)jarg1;
13361   {
13362     try {
13363       result = ((Dali::Property::Array const *)arg1)->Count();
13364     } catch (std::out_of_range& e) {
13365       {
13366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13367       };
13368     } catch (std::exception& e) {
13369       {
13370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13371       };
13372     } catch (...) {
13373       {
13374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13375       };
13376     }
13377   }
13378   jresult = (unsigned long)result;
13379   return jresult;
13380 }
13381
13382
13383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13384   unsigned int jresult ;
13385   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13386   bool result;
13387
13388   arg1 = (Dali::Property::Array *)jarg1;
13389   {
13390     try {
13391       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13392     } catch (std::out_of_range& e) {
13393       {
13394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13395       };
13396     } catch (std::exception& e) {
13397       {
13398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13399       };
13400     } catch (...) {
13401       {
13402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13403       };
13404     }
13405   }
13406   jresult = result;
13407   return jresult;
13408 }
13409
13410
13411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13412   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13413
13414   arg1 = (Dali::Property::Array *)jarg1;
13415   {
13416     try {
13417       (arg1)->Clear();
13418     } catch (std::out_of_range& e) {
13419       {
13420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13421       };
13422     } catch (std::exception& e) {
13423       {
13424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13425       };
13426     } catch (...) {
13427       {
13428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13429       };
13430     }
13431   }
13432 }
13433
13434
13435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13436   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13437   Dali::Property::Array::SizeType arg2 ;
13438
13439   arg1 = (Dali::Property::Array *)jarg1;
13440   arg2 = (Dali::Property::Array::SizeType)jarg2;
13441   {
13442     try {
13443       (arg1)->Reserve(arg2);
13444     } catch (std::out_of_range& e) {
13445       {
13446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13447       };
13448     } catch (std::exception& e) {
13449       {
13450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13451       };
13452     } catch (...) {
13453       {
13454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13455       };
13456     }
13457   }
13458 }
13459
13460
13461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13462   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13463   Dali::Property::Array::SizeType arg2 ;
13464
13465   arg1 = (Dali::Property::Array *)jarg1;
13466   arg2 = (Dali::Property::Array::SizeType)jarg2;
13467   {
13468     try {
13469       (arg1)->Resize(arg2);
13470     } catch (std::out_of_range& e) {
13471       {
13472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13473       };
13474     } catch (std::exception& e) {
13475       {
13476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13477       };
13478     } catch (...) {
13479       {
13480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13481       };
13482     }
13483   }
13484 }
13485
13486
13487 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13488   unsigned long jresult ;
13489   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13490   Dali::Property::Array::SizeType result;
13491
13492   arg1 = (Dali::Property::Array *)jarg1;
13493   {
13494     try {
13495       result = (arg1)->Capacity();
13496     } catch (std::out_of_range& e) {
13497       {
13498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13499       };
13500     } catch (std::exception& e) {
13501       {
13502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13503       };
13504     } catch (...) {
13505       {
13506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13507       };
13508     }
13509   }
13510   jresult = (unsigned long)result;
13511   return jresult;
13512 }
13513
13514
13515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13516   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13517   Dali::Property::Value *arg2 = 0 ;
13518
13519   arg1 = (Dali::Property::Array *)jarg1;
13520   arg2 = (Dali::Property::Value *)jarg2;
13521   if (!arg2) {
13522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13523     return ;
13524   }
13525   {
13526     try {
13527       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13528     } catch (std::out_of_range& e) {
13529       {
13530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13531       };
13532     } catch (std::exception& e) {
13533       {
13534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13535       };
13536     } catch (...) {
13537       {
13538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13539       };
13540     }
13541   }
13542 }
13543
13544
13545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13546   void * jresult ;
13547   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13548   Dali::Property::Value *arg2 = 0 ;
13549   Dali::Property::Array *result = 0 ;
13550
13551   arg1 = (Dali::Property::Array *)jarg1;
13552   arg2 = (Dali::Property::Value *)jarg2;
13553   if (!arg2) {
13554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13555     return 0;
13556   }
13557   {
13558     try {
13559       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13560     } catch (std::out_of_range& e) {
13561       {
13562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13563       };
13564     } catch (std::exception& e) {
13565       {
13566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13567       };
13568     } catch (...) {
13569       {
13570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13571       };
13572     }
13573   }
13574   jresult = (void *)result;
13575   return jresult;
13576 }
13577
13578
13579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13580   void * jresult ;
13581   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13582   Dali::Property::Array::SizeType arg2 ;
13583   Dali::Property::Value *result = 0 ;
13584
13585   arg1 = (Dali::Property::Array *)jarg1;
13586   arg2 = (Dali::Property::Array::SizeType)jarg2;
13587   {
13588     try {
13589       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13590     } catch (std::out_of_range& e) {
13591       {
13592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13593       };
13594     } catch (std::exception& e) {
13595       {
13596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13597       };
13598     } catch (...) {
13599       {
13600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13601       };
13602     }
13603   }
13604   jresult = (void *)result;
13605   return jresult;
13606 }
13607
13608
13609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13610   void * jresult ;
13611   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13612   Dali::Property::Array::SizeType arg2 ;
13613   Dali::Property::Value *result = 0 ;
13614
13615   arg1 = (Dali::Property::Array *)jarg1;
13616   arg2 = (Dali::Property::Array::SizeType)jarg2;
13617   {
13618     try {
13619       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13620     } catch (std::out_of_range& e) {
13621       {
13622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13623       };
13624     } catch (std::exception& e) {
13625       {
13626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13627       };
13628     } catch (...) {
13629       {
13630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13631       };
13632     }
13633   }
13634   jresult = (void *)result;
13635   return jresult;
13636 }
13637
13638
13639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13640   void * jresult ;
13641   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13642   Dali::Property::Array *arg2 = 0 ;
13643   Dali::Property::Array *result = 0 ;
13644
13645   arg1 = (Dali::Property::Array *)jarg1;
13646   arg2 = (Dali::Property::Array *)jarg2;
13647   if (!arg2) {
13648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13649     return 0;
13650   }
13651   {
13652     try {
13653       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13654     } catch (std::out_of_range& e) {
13655       {
13656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13657       };
13658     } catch (std::exception& e) {
13659       {
13660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13661       };
13662     } catch (...) {
13663       {
13664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13665       };
13666     }
13667   }
13668   jresult = (void *)result;
13669   return jresult;
13670 }
13671
13672
13673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13674   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13675   enum Dali::Property::Key::Type arg2 ;
13676
13677   arg1 = (Dali::Property::Key *)jarg1;
13678   arg2 = (enum Dali::Property::Key::Type)jarg2;
13679   if (arg1) (arg1)->type = arg2;
13680 }
13681
13682
13683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13684   int jresult ;
13685   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13686   enum Dali::Property::Key::Type result;
13687
13688   arg1 = (Dali::Property::Key *)jarg1;
13689   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13690   jresult = (int)result;
13691   return jresult;
13692 }
13693
13694
13695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13696   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13697   Dali::Property::Index arg2 ;
13698
13699   arg1 = (Dali::Property::Key *)jarg1;
13700   arg2 = (Dali::Property::Index)jarg2;
13701   if (arg1) (arg1)->indexKey = arg2;
13702 }
13703
13704
13705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13706   int jresult ;
13707   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13708   Dali::Property::Index result;
13709
13710   arg1 = (Dali::Property::Key *)jarg1;
13711   result = (Dali::Property::Index) ((arg1)->indexKey);
13712   jresult = result;
13713   return jresult;
13714 }
13715
13716
13717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13718   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13719   std::string *arg2 = 0 ;
13720
13721   arg1 = (Dali::Property::Key *)jarg1;
13722   if (!jarg2) {
13723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13724     return ;
13725   }
13726   std::string arg2_str(jarg2);
13727   arg2 = &arg2_str;
13728   if (arg1) (arg1)->stringKey = *arg2;
13729
13730   //argout typemap for const std::string&
13731
13732 }
13733
13734
13735 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13736   char * jresult ;
13737   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13738   std::string *result = 0 ;
13739
13740   arg1 = (Dali::Property::Key *)jarg1;
13741   result = (std::string *) & ((arg1)->stringKey);
13742   jresult = SWIG_csharp_string_callback(result->c_str());
13743   return jresult;
13744 }
13745
13746
13747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13748   void * jresult ;
13749   std::string *arg1 = 0 ;
13750   Dali::Property::Key *result = 0 ;
13751
13752   if (!jarg1) {
13753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13754     return 0;
13755   }
13756   std::string arg1_str(jarg1);
13757   arg1 = &arg1_str;
13758   {
13759     try {
13760       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13761     } catch (std::out_of_range& e) {
13762       {
13763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13764       };
13765     } catch (std::exception& e) {
13766       {
13767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13768       };
13769     } catch (...) {
13770       {
13771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13772       };
13773     }
13774   }
13775   jresult = (void *)result;
13776
13777   //argout typemap for const std::string&
13778
13779   return jresult;
13780 }
13781
13782
13783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13784   void * jresult ;
13785   Dali::Property::Index arg1 ;
13786   Dali::Property::Key *result = 0 ;
13787
13788   arg1 = (Dali::Property::Index)jarg1;
13789   {
13790     try {
13791       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13792     } catch (std::out_of_range& e) {
13793       {
13794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13795       };
13796     } catch (std::exception& e) {
13797       {
13798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13799       };
13800     } catch (...) {
13801       {
13802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13803       };
13804     }
13805   }
13806   jresult = (void *)result;
13807   return jresult;
13808 }
13809
13810
13811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13812   unsigned int jresult ;
13813   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13814   std::string *arg2 = 0 ;
13815   bool result;
13816
13817   arg1 = (Dali::Property::Key *)jarg1;
13818   if (!jarg2) {
13819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13820     return 0;
13821   }
13822   std::string arg2_str(jarg2);
13823   arg2 = &arg2_str;
13824   {
13825     try {
13826       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13827     } catch (std::out_of_range& e) {
13828       {
13829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13830       };
13831     } catch (std::exception& e) {
13832       {
13833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13834       };
13835     } catch (...) {
13836       {
13837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13838       };
13839     }
13840   }
13841   jresult = result;
13842
13843   //argout typemap for const std::string&
13844
13845   return jresult;
13846 }
13847
13848
13849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13850   unsigned int jresult ;
13851   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13852   Dali::Property::Index arg2 ;
13853   bool result;
13854
13855   arg1 = (Dali::Property::Key *)jarg1;
13856   arg2 = (Dali::Property::Index)jarg2;
13857   {
13858     try {
13859       result = (bool)(arg1)->operator ==(arg2);
13860     } catch (std::out_of_range& e) {
13861       {
13862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13863       };
13864     } catch (std::exception& e) {
13865       {
13866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13867       };
13868     } catch (...) {
13869       {
13870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13871       };
13872     }
13873   }
13874   jresult = result;
13875   return jresult;
13876 }
13877
13878
13879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13880   unsigned int jresult ;
13881   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13882   Dali::Property::Key *arg2 = 0 ;
13883   bool result;
13884
13885   arg1 = (Dali::Property::Key *)jarg1;
13886   arg2 = (Dali::Property::Key *)jarg2;
13887   if (!arg2) {
13888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13889     return 0;
13890   }
13891   {
13892     try {
13893       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13894     } catch (std::out_of_range& e) {
13895       {
13896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13897       };
13898     } catch (std::exception& e) {
13899       {
13900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13901       };
13902     } catch (...) {
13903       {
13904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13905       };
13906     }
13907   }
13908   jresult = result;
13909   return jresult;
13910 }
13911
13912
13913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13914   unsigned int jresult ;
13915   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13916   std::string *arg2 = 0 ;
13917   bool result;
13918
13919   arg1 = (Dali::Property::Key *)jarg1;
13920   if (!jarg2) {
13921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13922     return 0;
13923   }
13924   std::string arg2_str(jarg2);
13925   arg2 = &arg2_str;
13926   {
13927     try {
13928       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13929     } catch (std::out_of_range& e) {
13930       {
13931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13932       };
13933     } catch (std::exception& e) {
13934       {
13935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13936       };
13937     } catch (...) {
13938       {
13939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13940       };
13941     }
13942   }
13943   jresult = result;
13944
13945   //argout typemap for const std::string&
13946
13947   return jresult;
13948 }
13949
13950
13951 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13952   unsigned int jresult ;
13953   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13954   Dali::Property::Index arg2 ;
13955   bool result;
13956
13957   arg1 = (Dali::Property::Key *)jarg1;
13958   arg2 = (Dali::Property::Index)jarg2;
13959   {
13960     try {
13961       result = (bool)(arg1)->operator !=(arg2);
13962     } catch (std::out_of_range& e) {
13963       {
13964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13965       };
13966     } catch (std::exception& e) {
13967       {
13968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13969       };
13970     } catch (...) {
13971       {
13972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13973       };
13974     }
13975   }
13976   jresult = result;
13977   return jresult;
13978 }
13979
13980
13981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13982   unsigned int jresult ;
13983   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13984   Dali::Property::Key *arg2 = 0 ;
13985   bool result;
13986
13987   arg1 = (Dali::Property::Key *)jarg1;
13988   arg2 = (Dali::Property::Key *)jarg2;
13989   if (!arg2) {
13990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13991     return 0;
13992   }
13993   {
13994     try {
13995       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13996     } catch (std::out_of_range& e) {
13997       {
13998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13999       };
14000     } catch (std::exception& e) {
14001       {
14002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14003       };
14004     } catch (...) {
14005       {
14006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14007       };
14008     }
14009   }
14010   jresult = result;
14011   return jresult;
14012 }
14013
14014
14015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
14016   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14017
14018   arg1 = (Dali::Property::Key *)jarg1;
14019   {
14020     try {
14021       delete arg1;
14022     } catch (std::out_of_range& e) {
14023       {
14024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14025       };
14026     } catch (std::exception& e) {
14027       {
14028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14029       };
14030     } catch (...) {
14031       {
14032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14033       };
14034     }
14035   }
14036 }
14037
14038
14039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
14040   void * jresult ;
14041   Dali::Property::Map *result = 0 ;
14042
14043   {
14044     try {
14045       result = (Dali::Property::Map *)new Dali::Property::Map();
14046     } catch (std::out_of_range& e) {
14047       {
14048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14049       };
14050     } catch (std::exception& e) {
14051       {
14052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14053       };
14054     } catch (...) {
14055       {
14056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14057       };
14058     }
14059   }
14060   jresult = (void *)result;
14061   return jresult;
14062 }
14063
14064
14065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14066   void * jresult ;
14067   Dali::Property::Map *arg1 = 0 ;
14068   Dali::Property::Map *result = 0 ;
14069
14070   arg1 = (Dali::Property::Map *)jarg1;
14071   if (!arg1) {
14072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14073     return 0;
14074   }
14075   {
14076     try {
14077       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14078     } catch (std::out_of_range& e) {
14079       {
14080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14081       };
14082     } catch (std::exception& e) {
14083       {
14084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14085       };
14086     } catch (...) {
14087       {
14088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14089       };
14090     }
14091   }
14092   jresult = (void *)result;
14093   return jresult;
14094 }
14095
14096
14097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14098   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14099
14100   arg1 = (Dali::Property::Map *)jarg1;
14101   {
14102     try {
14103       delete arg1;
14104     } catch (std::out_of_range& e) {
14105       {
14106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14107       };
14108     } catch (std::exception& e) {
14109       {
14110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14111       };
14112     } catch (...) {
14113       {
14114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14115       };
14116     }
14117   }
14118 }
14119
14120
14121 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14122   unsigned long jresult ;
14123   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14124   Dali::Property::Map::SizeType result;
14125
14126   arg1 = (Dali::Property::Map *)jarg1;
14127   {
14128     try {
14129       result = ((Dali::Property::Map const *)arg1)->Count();
14130     } catch (std::out_of_range& e) {
14131       {
14132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14133       };
14134     } catch (std::exception& e) {
14135       {
14136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14137       };
14138     } catch (...) {
14139       {
14140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14141       };
14142     }
14143   }
14144   jresult = (unsigned long)result;
14145   return jresult;
14146 }
14147
14148
14149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14150   unsigned int jresult ;
14151   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14152   bool result;
14153
14154   arg1 = (Dali::Property::Map *)jarg1;
14155   {
14156     try {
14157       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14158     } catch (std::out_of_range& e) {
14159       {
14160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14161       };
14162     } catch (std::exception& e) {
14163       {
14164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14165       };
14166     } catch (...) {
14167       {
14168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14169       };
14170     }
14171   }
14172   jresult = result;
14173   return jresult;
14174 }
14175
14176
14177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14178   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14179   char *arg2 = (char *) 0 ;
14180   Dali::Property::Value *arg3 = 0 ;
14181
14182   arg1 = (Dali::Property::Map *)jarg1;
14183   arg2 = (char *)jarg2;
14184   arg3 = (Dali::Property::Value *)jarg3;
14185   if (!arg3) {
14186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14187     return ;
14188   }
14189   {
14190     try {
14191       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14192     } catch (std::out_of_range& e) {
14193       {
14194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14195       };
14196     } catch (std::exception& e) {
14197       {
14198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14199       };
14200     } catch (...) {
14201       {
14202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14203       };
14204     }
14205   }
14206 }
14207
14208
14209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14210   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14211   Dali::Property::Index arg2 ;
14212   Dali::Property::Value *arg3 = 0 ;
14213
14214   arg1 = (Dali::Property::Map *)jarg1;
14215   arg2 = (Dali::Property::Index)jarg2;
14216   arg3 = (Dali::Property::Value *)jarg3;
14217   if (!arg3) {
14218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14219     return ;
14220   }
14221   {
14222     try {
14223       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14224     } catch (std::out_of_range& e) {
14225       {
14226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14227       };
14228     } catch (std::exception& e) {
14229       {
14230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14231       };
14232     } catch (...) {
14233       {
14234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14235       };
14236     }
14237   }
14238 }
14239
14240
14241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14242   void * jresult ;
14243   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14244   char *arg2 = (char *) 0 ;
14245   Dali::Property::Value *arg3 = 0 ;
14246   Dali::Property::Map *result = 0 ;
14247
14248   arg1 = (Dali::Property::Map *)jarg1;
14249   arg2 = (char *)jarg2;
14250   arg3 = (Dali::Property::Value *)jarg3;
14251   if (!arg3) {
14252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14253     return 0;
14254   }
14255   {
14256     try {
14257       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14258     } catch (std::out_of_range& e) {
14259       {
14260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14261       };
14262     } catch (std::exception& e) {
14263       {
14264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14265       };
14266     } catch (...) {
14267       {
14268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14269       };
14270     }
14271   }
14272   jresult = (void *)result;
14273   return jresult;
14274 }
14275
14276
14277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14278   void * jresult ;
14279   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14280   Dali::Property::Index arg2 ;
14281   Dali::Property::Value *arg3 = 0 ;
14282   Dali::Property::Map *result = 0 ;
14283
14284   arg1 = (Dali::Property::Map *)jarg1;
14285   arg2 = (Dali::Property::Index)jarg2;
14286   arg3 = (Dali::Property::Value *)jarg3;
14287   if (!arg3) {
14288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14289     return 0;
14290   }
14291   {
14292     try {
14293       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14294     } catch (std::out_of_range& e) {
14295       {
14296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14297       };
14298     } catch (std::exception& e) {
14299       {
14300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14301       };
14302     } catch (...) {
14303       {
14304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14305       };
14306     }
14307   }
14308   jresult = (void *)result;
14309   return jresult;
14310 }
14311
14312
14313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14314   void * jresult ;
14315   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14316   Dali::Property::Map::SizeType arg2 ;
14317   Dali::Property::Value *result = 0 ;
14318
14319   arg1 = (Dali::Property::Map *)jarg1;
14320   arg2 = (Dali::Property::Map::SizeType)jarg2;
14321   {
14322     try {
14323       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14324     } catch (std::out_of_range& e) {
14325       {
14326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14327       };
14328     } catch (std::exception& e) {
14329       {
14330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14331       };
14332     } catch (...) {
14333       {
14334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14335       };
14336     }
14337   }
14338   jresult = (void *)result;
14339   return jresult;
14340 }
14341
14342
14343 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14344   char * jresult ;
14345   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14346   Dali::Property::Map::SizeType arg2 ;
14347   std::string *result = 0 ;
14348
14349   arg1 = (Dali::Property::Map *)jarg1;
14350   arg2 = (Dali::Property::Map::SizeType)jarg2;
14351   {
14352     try {
14353       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14354     } catch (std::out_of_range& e) {
14355       {
14356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14357       };
14358     } catch (std::exception& e) {
14359       {
14360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14361       };
14362     } catch (...) {
14363       {
14364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14365       };
14366     }
14367   }
14368   jresult = SWIG_csharp_string_callback(result->c_str());
14369   return jresult;
14370 }
14371
14372
14373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14374   void * jresult ;
14375   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14376   Dali::Property::Map::SizeType arg2 ;
14377   SwigValueWrapper< Dali::Property::Key > result;
14378
14379   arg1 = (Dali::Property::Map *)jarg1;
14380   arg2 = (Dali::Property::Map::SizeType)jarg2;
14381   {
14382     try {
14383       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14384     } catch (std::out_of_range& e) {
14385       {
14386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14387       };
14388     } catch (std::exception& e) {
14389       {
14390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14391       };
14392     } catch (...) {
14393       {
14394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14395       };
14396     }
14397   }
14398   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14399   return jresult;
14400 }
14401
14402
14403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14404   void * jresult ;
14405   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14406   Dali::Property::Map::SizeType arg2 ;
14407   StringValuePair *result = 0 ;
14408
14409   arg1 = (Dali::Property::Map *)jarg1;
14410   arg2 = (Dali::Property::Map::SizeType)jarg2;
14411   {
14412     try {
14413       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14414     } catch (std::out_of_range& e) {
14415       {
14416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14417       };
14418     } catch (std::exception& e) {
14419       {
14420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14421       };
14422     } catch (...) {
14423       {
14424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14425       };
14426     }
14427   }
14428   jresult = (void *)result;
14429   return jresult;
14430 }
14431
14432
14433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14434   void * jresult ;
14435   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14436   char *arg2 = (char *) 0 ;
14437   Dali::Property::Value *result = 0 ;
14438
14439   arg1 = (Dali::Property::Map *)jarg1;
14440   arg2 = (char *)jarg2;
14441   {
14442     try {
14443       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14444     } catch (std::out_of_range& e) {
14445       {
14446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14447       };
14448     } catch (std::exception& e) {
14449       {
14450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14451       };
14452     } catch (...) {
14453       {
14454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14455       };
14456     }
14457   }
14458   jresult = (void *)result;
14459   return jresult;
14460 }
14461
14462
14463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14464   void * jresult ;
14465   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14466   Dali::Property::Index arg2 ;
14467   Dali::Property::Value *result = 0 ;
14468
14469   arg1 = (Dali::Property::Map *)jarg1;
14470   arg2 = (Dali::Property::Index)jarg2;
14471   {
14472     try {
14473       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14474     } catch (std::out_of_range& e) {
14475       {
14476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14477       };
14478     } catch (std::exception& e) {
14479       {
14480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14481       };
14482     } catch (...) {
14483       {
14484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14485       };
14486     }
14487   }
14488   jresult = (void *)result;
14489   return jresult;
14490 }
14491
14492
14493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14494   void * jresult ;
14495   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14496   Dali::Property::Index arg2 ;
14497   std::string *arg3 = 0 ;
14498   Dali::Property::Value *result = 0 ;
14499
14500   arg1 = (Dali::Property::Map *)jarg1;
14501   arg2 = (Dali::Property::Index)jarg2;
14502   if (!jarg3) {
14503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14504     return 0;
14505   }
14506   std::string arg3_str(jarg3);
14507   arg3 = &arg3_str;
14508   {
14509     try {
14510       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14511     } catch (std::out_of_range& e) {
14512       {
14513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14514       };
14515     } catch (std::exception& e) {
14516       {
14517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14518       };
14519     } catch (...) {
14520       {
14521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14522       };
14523     }
14524   }
14525   jresult = (void *)result;
14526
14527   //argout typemap for const std::string&
14528
14529   return jresult;
14530 }
14531
14532
14533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14534   void * jresult ;
14535   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14536   std::string *arg2 = 0 ;
14537   Dali::Property::Type arg3 ;
14538   Dali::Property::Value *result = 0 ;
14539
14540   arg1 = (Dali::Property::Map *)jarg1;
14541   if (!jarg2) {
14542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14543     return 0;
14544   }
14545   std::string arg2_str(jarg2);
14546   arg2 = &arg2_str;
14547   arg3 = (Dali::Property::Type)jarg3;
14548   {
14549     try {
14550       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14551     } catch (std::out_of_range& e) {
14552       {
14553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14554       };
14555     } catch (std::exception& e) {
14556       {
14557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14558       };
14559     } catch (...) {
14560       {
14561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14562       };
14563     }
14564   }
14565   jresult = (void *)result;
14566
14567   //argout typemap for const std::string&
14568
14569   return jresult;
14570 }
14571
14572
14573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14574   void * jresult ;
14575   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14576   Dali::Property::Index arg2 ;
14577   Dali::Property::Type arg3 ;
14578   Dali::Property::Value *result = 0 ;
14579
14580   arg1 = (Dali::Property::Map *)jarg1;
14581   arg2 = (Dali::Property::Index)jarg2;
14582   arg3 = (Dali::Property::Type)jarg3;
14583   {
14584     try {
14585       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14586     } catch (std::out_of_range& e) {
14587       {
14588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14589       };
14590     } catch (std::exception& e) {
14591       {
14592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14593       };
14594     } catch (...) {
14595       {
14596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14597       };
14598     }
14599   }
14600   jresult = (void *)result;
14601   return jresult;
14602 }
14603
14604
14605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14606   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14607
14608   arg1 = (Dali::Property::Map *)jarg1;
14609   {
14610     try {
14611       (arg1)->Clear();
14612     } catch (std::out_of_range& e) {
14613       {
14614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14615       };
14616     } catch (std::exception& e) {
14617       {
14618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14619       };
14620     } catch (...) {
14621       {
14622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14623       };
14624     }
14625   }
14626 }
14627
14628
14629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14630   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14631   Dali::Property::Map *arg2 = 0 ;
14632
14633   arg1 = (Dali::Property::Map *)jarg1;
14634   arg2 = (Dali::Property::Map *)jarg2;
14635   if (!arg2) {
14636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14637     return ;
14638   }
14639   {
14640     try {
14641       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14642     } catch (std::out_of_range& e) {
14643       {
14644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14645       };
14646     } catch (std::exception& e) {
14647       {
14648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14649       };
14650     } catch (...) {
14651       {
14652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14653       };
14654     }
14655   }
14656 }
14657
14658
14659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14660   void * jresult ;
14661   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14662   std::string *arg2 = 0 ;
14663   Dali::Property::Value *result = 0 ;
14664
14665   arg1 = (Dali::Property::Map *)jarg1;
14666   if (!jarg2) {
14667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14668     return 0;
14669   }
14670   std::string arg2_str(jarg2);
14671   arg2 = &arg2_str;
14672   {
14673     try {
14674       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14675     } catch (std::out_of_range& e) {
14676       {
14677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14678       };
14679     } catch (std::exception& e) {
14680       {
14681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14682       };
14683     } catch (...) {
14684       {
14685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14686       };
14687     }
14688   }
14689   jresult = (void *)result;
14690
14691   //argout typemap for const std::string&
14692
14693   return jresult;
14694 }
14695
14696
14697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14698   void * jresult ;
14699   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14700   Dali::Property::Index arg2 ;
14701   Dali::Property::Value *result = 0 ;
14702
14703   arg1 = (Dali::Property::Map *)jarg1;
14704   arg2 = (Dali::Property::Index)jarg2;
14705   {
14706     try {
14707       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14708     } catch (std::out_of_range& e) {
14709       {
14710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14711       };
14712     } catch (std::exception& e) {
14713       {
14714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14715       };
14716     } catch (...) {
14717       {
14718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14719       };
14720     }
14721   }
14722   jresult = (void *)result;
14723   return jresult;
14724 }
14725
14726
14727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14728   void * jresult ;
14729   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14730   Dali::Property::Map *arg2 = 0 ;
14731   Dali::Property::Map *result = 0 ;
14732
14733   arg1 = (Dali::Property::Map *)jarg1;
14734   arg2 = (Dali::Property::Map *)jarg2;
14735   if (!arg2) {
14736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14737     return 0;
14738   }
14739   {
14740     try {
14741       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14742     } catch (std::out_of_range& e) {
14743       {
14744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14745       };
14746     } catch (std::exception& e) {
14747       {
14748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14749       };
14750     } catch (...) {
14751       {
14752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14753       };
14754     }
14755   }
14756   jresult = (void *)result;
14757   return jresult;
14758 }
14759
14760
14761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14762   void * jresult ;
14763   Dali::Property::Value *result = 0 ;
14764
14765   {
14766     try {
14767       result = (Dali::Property::Value *)new Dali::Property::Value();
14768     } catch (std::out_of_range& e) {
14769       {
14770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14771       };
14772     } catch (std::exception& e) {
14773       {
14774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14775       };
14776     } catch (...) {
14777       {
14778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14779       };
14780     }
14781   }
14782   jresult = (void *)result;
14783   return jresult;
14784 }
14785
14786
14787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14788   void * jresult ;
14789   bool arg1 ;
14790   Dali::Property::Value *result = 0 ;
14791
14792   arg1 = jarg1 ? true : false;
14793   {
14794     try {
14795       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14796     } catch (std::out_of_range& e) {
14797       {
14798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14799       };
14800     } catch (std::exception& e) {
14801       {
14802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14803       };
14804     } catch (...) {
14805       {
14806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14807       };
14808     }
14809   }
14810   jresult = (void *)result;
14811   return jresult;
14812 }
14813
14814
14815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14816   void * jresult ;
14817   int arg1 ;
14818   Dali::Property::Value *result = 0 ;
14819
14820   arg1 = (int)jarg1;
14821   {
14822     try {
14823       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14824     } catch (std::out_of_range& e) {
14825       {
14826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14827       };
14828     } catch (std::exception& e) {
14829       {
14830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14831       };
14832     } catch (...) {
14833       {
14834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14835       };
14836     }
14837   }
14838   jresult = (void *)result;
14839   return jresult;
14840 }
14841
14842
14843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14844   void * jresult ;
14845   float arg1 ;
14846   Dali::Property::Value *result = 0 ;
14847
14848   arg1 = (float)jarg1;
14849   {
14850     try {
14851       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14852     } catch (std::out_of_range& e) {
14853       {
14854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14855       };
14856     } catch (std::exception& e) {
14857       {
14858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14859       };
14860     } catch (...) {
14861       {
14862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14863       };
14864     }
14865   }
14866   jresult = (void *)result;
14867   return jresult;
14868 }
14869
14870
14871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14872   void * jresult ;
14873   Dali::Vector2 *arg1 = 0 ;
14874   Dali::Property::Value *result = 0 ;
14875
14876   arg1 = (Dali::Vector2 *)jarg1;
14877   if (!arg1) {
14878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14879     return 0;
14880   }
14881   {
14882     try {
14883       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14884     } catch (std::out_of_range& e) {
14885       {
14886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14887       };
14888     } catch (std::exception& e) {
14889       {
14890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14891       };
14892     } catch (...) {
14893       {
14894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14895       };
14896     }
14897   }
14898   jresult = (void *)result;
14899   return jresult;
14900 }
14901
14902
14903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14904   void * jresult ;
14905   Dali::Vector3 *arg1 = 0 ;
14906   Dali::Property::Value *result = 0 ;
14907
14908   arg1 = (Dali::Vector3 *)jarg1;
14909   if (!arg1) {
14910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14911     return 0;
14912   }
14913   {
14914     try {
14915       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14916     } catch (std::out_of_range& e) {
14917       {
14918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14919       };
14920     } catch (std::exception& e) {
14921       {
14922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14923       };
14924     } catch (...) {
14925       {
14926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14927       };
14928     }
14929   }
14930   jresult = (void *)result;
14931   return jresult;
14932 }
14933
14934
14935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14936   void * jresult ;
14937   Dali::Vector4 *arg1 = 0 ;
14938   Dali::Property::Value *result = 0 ;
14939
14940   arg1 = (Dali::Vector4 *)jarg1;
14941   if (!arg1) {
14942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14943     return 0;
14944   }
14945   {
14946     try {
14947       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14948     } catch (std::out_of_range& e) {
14949       {
14950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14951       };
14952     } catch (std::exception& e) {
14953       {
14954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14955       };
14956     } catch (...) {
14957       {
14958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14959       };
14960     }
14961   }
14962   jresult = (void *)result;
14963   return jresult;
14964 }
14965
14966
14967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14968   void * jresult ;
14969   Dali::Matrix3 *arg1 = 0 ;
14970   Dali::Property::Value *result = 0 ;
14971
14972   arg1 = (Dali::Matrix3 *)jarg1;
14973   if (!arg1) {
14974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14975     return 0;
14976   }
14977   {
14978     try {
14979       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14980     } catch (std::out_of_range& e) {
14981       {
14982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14983       };
14984     } catch (std::exception& e) {
14985       {
14986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14987       };
14988     } catch (...) {
14989       {
14990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14991       };
14992     }
14993   }
14994   jresult = (void *)result;
14995   return jresult;
14996 }
14997
14998
14999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
15000   void * jresult ;
15001   Dali::Matrix *arg1 = 0 ;
15002   Dali::Property::Value *result = 0 ;
15003
15004   arg1 = (Dali::Matrix *)jarg1;
15005   if (!arg1) {
15006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15007     return 0;
15008   }
15009   {
15010     try {
15011       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15012     } catch (std::out_of_range& e) {
15013       {
15014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15015       };
15016     } catch (std::exception& e) {
15017       {
15018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15019       };
15020     } catch (...) {
15021       {
15022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15023       };
15024     }
15025   }
15026   jresult = (void *)result;
15027   return jresult;
15028 }
15029
15030
15031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
15032   void * jresult ;
15033   Dali::Rect< int > *arg1 = 0 ;
15034   Dali::Property::Value *result = 0 ;
15035
15036   arg1 = (Dali::Rect< int > *)jarg1;
15037   if (!arg1) {
15038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15039     return 0;
15040   }
15041   {
15042     try {
15043       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15044     } catch (std::out_of_range& e) {
15045       {
15046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15047       };
15048     } catch (std::exception& e) {
15049       {
15050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15051       };
15052     } catch (...) {
15053       {
15054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15055       };
15056     }
15057   }
15058   jresult = (void *)result;
15059   return jresult;
15060 }
15061
15062
15063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15064   void * jresult ;
15065   Dali::AngleAxis *arg1 = 0 ;
15066   Dali::Property::Value *result = 0 ;
15067
15068   arg1 = (Dali::AngleAxis *)jarg1;
15069   if (!arg1) {
15070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15071     return 0;
15072   }
15073   {
15074     try {
15075       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15076     } catch (std::out_of_range& e) {
15077       {
15078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15079       };
15080     } catch (std::exception& e) {
15081       {
15082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15083       };
15084     } catch (...) {
15085       {
15086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15087       };
15088     }
15089   }
15090   jresult = (void *)result;
15091   return jresult;
15092 }
15093
15094
15095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15096   void * jresult ;
15097   Dali::Quaternion *arg1 = 0 ;
15098   Dali::Property::Value *result = 0 ;
15099
15100   arg1 = (Dali::Quaternion *)jarg1;
15101   if (!arg1) {
15102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15103     return 0;
15104   }
15105   {
15106     try {
15107       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15108     } catch (std::out_of_range& e) {
15109       {
15110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15111       };
15112     } catch (std::exception& e) {
15113       {
15114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15115       };
15116     } catch (...) {
15117       {
15118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15119       };
15120     }
15121   }
15122   jresult = (void *)result;
15123   return jresult;
15124 }
15125
15126
15127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15128   void * jresult ;
15129   std::string *arg1 = 0 ;
15130   Dali::Property::Value *result = 0 ;
15131
15132   if (!jarg1) {
15133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15134     return 0;
15135   }
15136   std::string arg1_str(jarg1);
15137   arg1 = &arg1_str;
15138   {
15139     try {
15140       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15141     } catch (std::out_of_range& e) {
15142       {
15143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15144       };
15145     } catch (std::exception& e) {
15146       {
15147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15148       };
15149     } catch (...) {
15150       {
15151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15152       };
15153     }
15154   }
15155   jresult = (void *)result;
15156
15157   //argout typemap for const std::string&
15158
15159   return jresult;
15160 }
15161
15162
15163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15164   void * jresult ;
15165   Dali::Property::Array *arg1 = 0 ;
15166   Dali::Property::Value *result = 0 ;
15167
15168   arg1 = (Dali::Property::Array *)jarg1;
15169   if (!arg1) {
15170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15171     return 0;
15172   }
15173   {
15174     try {
15175       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15176     } catch (std::out_of_range& e) {
15177       {
15178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15179       };
15180     } catch (std::exception& e) {
15181       {
15182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15183       };
15184     } catch (...) {
15185       {
15186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15187       };
15188     }
15189   }
15190   jresult = (void *)result;
15191   return jresult;
15192 }
15193
15194
15195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15196   void * jresult ;
15197   Dali::Property::Map *arg1 = 0 ;
15198   Dali::Property::Value *result = 0 ;
15199
15200   arg1 = (Dali::Property::Map *)jarg1;
15201   if (!arg1) {
15202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15203     return 0;
15204   }
15205   {
15206     try {
15207       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15208     } catch (std::out_of_range& e) {
15209       {
15210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15211       };
15212     } catch (std::exception& e) {
15213       {
15214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15215       };
15216     } catch (...) {
15217       {
15218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15219       };
15220     }
15221   }
15222   jresult = (void *)result;
15223   return jresult;
15224 }
15225
15226
15227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15228   void * jresult ;
15229   Dali::Property::Type arg1 ;
15230   Dali::Property::Value *result = 0 ;
15231
15232   arg1 = (Dali::Property::Type)jarg1;
15233   {
15234     try {
15235       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15236     } catch (std::out_of_range& e) {
15237       {
15238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15239       };
15240     } catch (std::exception& e) {
15241       {
15242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15243       };
15244     } catch (...) {
15245       {
15246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15247       };
15248     }
15249   }
15250   jresult = (void *)result;
15251   return jresult;
15252 }
15253
15254
15255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15256   void * jresult ;
15257   Dali::Property::Value *arg1 = 0 ;
15258   Dali::Property::Value *result = 0 ;
15259
15260   arg1 = (Dali::Property::Value *)jarg1;
15261   if (!arg1) {
15262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15263     return 0;
15264   }
15265   {
15266     try {
15267       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15268     } catch (std::out_of_range& e) {
15269       {
15270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15271       };
15272     } catch (std::exception& e) {
15273       {
15274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15275       };
15276     } catch (...) {
15277       {
15278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15279       };
15280     }
15281   }
15282   jresult = (void *)result;
15283   return jresult;
15284 }
15285
15286
15287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15288   void * jresult ;
15289   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15290   Dali::Property::Value *arg2 = 0 ;
15291   Dali::Property::Value *result = 0 ;
15292
15293   arg1 = (Dali::Property::Value *)jarg1;
15294   arg2 = (Dali::Property::Value *)jarg2;
15295   if (!arg2) {
15296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15297     return 0;
15298   }
15299   {
15300     try {
15301       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15302     } catch (std::out_of_range& e) {
15303       {
15304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15305       };
15306     } catch (std::exception& e) {
15307       {
15308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15309       };
15310     } catch (...) {
15311       {
15312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15313       };
15314     }
15315   }
15316   jresult = (void *)result;
15317   return jresult;
15318 }
15319
15320
15321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15322   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15323
15324   arg1 = (Dali::Property::Value *)jarg1;
15325   {
15326     try {
15327       delete arg1;
15328     } catch (std::out_of_range& e) {
15329       {
15330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15331       };
15332     } catch (std::exception& e) {
15333       {
15334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15335       };
15336     } catch (...) {
15337       {
15338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15339       };
15340     }
15341   }
15342 }
15343
15344
15345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15346   int jresult ;
15347   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15348   Dali::Property::Type result;
15349
15350   arg1 = (Dali::Property::Value *)jarg1;
15351   {
15352     try {
15353       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15354     } catch (std::out_of_range& e) {
15355       {
15356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15357       };
15358     } catch (std::exception& e) {
15359       {
15360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15361       };
15362     } catch (...) {
15363       {
15364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15365       };
15366     }
15367   }
15368   jresult = (int)result;
15369   return jresult;
15370 }
15371
15372
15373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15374   unsigned int jresult ;
15375   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15376   bool *arg2 = 0 ;
15377   bool result;
15378
15379   arg1 = (Dali::Property::Value *)jarg1;
15380   arg2 = (bool *)jarg2;
15381   {
15382     try {
15383       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15384     } catch (std::out_of_range& e) {
15385       {
15386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15387       };
15388     } catch (std::exception& e) {
15389       {
15390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15391       };
15392     } catch (...) {
15393       {
15394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15395       };
15396     }
15397   }
15398   jresult = result;
15399   return jresult;
15400 }
15401
15402
15403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15404   unsigned int jresult ;
15405   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15406   float *arg2 = 0 ;
15407   bool result;
15408
15409   arg1 = (Dali::Property::Value *)jarg1;
15410   arg2 = (float *)jarg2;
15411   {
15412     try {
15413       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15414     } catch (std::out_of_range& e) {
15415       {
15416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15417       };
15418     } catch (std::exception& e) {
15419       {
15420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15421       };
15422     } catch (...) {
15423       {
15424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15425       };
15426     }
15427   }
15428   jresult = result;
15429   return jresult;
15430 }
15431
15432
15433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15434   unsigned int jresult ;
15435   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15436   int *arg2 = 0 ;
15437   bool result;
15438
15439   arg1 = (Dali::Property::Value *)jarg1;
15440   arg2 = (int *)jarg2;
15441   {
15442     try {
15443       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15444     } catch (std::out_of_range& e) {
15445       {
15446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15447       };
15448     } catch (std::exception& e) {
15449       {
15450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15451       };
15452     } catch (...) {
15453       {
15454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15455       };
15456     }
15457   }
15458   jresult = result;
15459   return jresult;
15460 }
15461
15462
15463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15464   unsigned int jresult ;
15465   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15466   Dali::Rect< int > *arg2 = 0 ;
15467   bool result;
15468
15469   arg1 = (Dali::Property::Value *)jarg1;
15470   arg2 = (Dali::Rect< int > *)jarg2;
15471   if (!arg2) {
15472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15473     return 0;
15474   }
15475   {
15476     try {
15477       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15478     } catch (std::out_of_range& e) {
15479       {
15480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15481       };
15482     } catch (std::exception& e) {
15483       {
15484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15485       };
15486     } catch (...) {
15487       {
15488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15489       };
15490     }
15491   }
15492   jresult = result;
15493   return jresult;
15494 }
15495
15496
15497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15498   unsigned int jresult ;
15499   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15500   Dali::Vector2 *arg2 = 0 ;
15501   bool result;
15502
15503   arg1 = (Dali::Property::Value *)jarg1;
15504   arg2 = (Dali::Vector2 *)jarg2;
15505   if (!arg2) {
15506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15507     return 0;
15508   }
15509   {
15510     try {
15511       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15512     } catch (std::out_of_range& e) {
15513       {
15514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15515       };
15516     } catch (std::exception& e) {
15517       {
15518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15519       };
15520     } catch (...) {
15521       {
15522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15523       };
15524     }
15525   }
15526   jresult = result;
15527   return jresult;
15528 }
15529
15530
15531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15532   unsigned int jresult ;
15533   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15534   Dali::Vector3 *arg2 = 0 ;
15535   bool result;
15536
15537   arg1 = (Dali::Property::Value *)jarg1;
15538   arg2 = (Dali::Vector3 *)jarg2;
15539   if (!arg2) {
15540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15541     return 0;
15542   }
15543   {
15544     try {
15545       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15546     } catch (std::out_of_range& e) {
15547       {
15548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15549       };
15550     } catch (std::exception& e) {
15551       {
15552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15553       };
15554     } catch (...) {
15555       {
15556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15557       };
15558     }
15559   }
15560   jresult = result;
15561   return jresult;
15562 }
15563
15564
15565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15566   unsigned int jresult ;
15567   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15568   Dali::Vector4 *arg2 = 0 ;
15569   bool result;
15570
15571   arg1 = (Dali::Property::Value *)jarg1;
15572   arg2 = (Dali::Vector4 *)jarg2;
15573   if (!arg2) {
15574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15575     return 0;
15576   }
15577   {
15578     try {
15579       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15580     } catch (std::out_of_range& e) {
15581       {
15582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15583       };
15584     } catch (std::exception& e) {
15585       {
15586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15587       };
15588     } catch (...) {
15589       {
15590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15591       };
15592     }
15593   }
15594   jresult = result;
15595   return jresult;
15596 }
15597
15598
15599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15600   unsigned int jresult ;
15601   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15602   Dali::Matrix3 *arg2 = 0 ;
15603   bool result;
15604
15605   arg1 = (Dali::Property::Value *)jarg1;
15606   arg2 = (Dali::Matrix3 *)jarg2;
15607   if (!arg2) {
15608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15609     return 0;
15610   }
15611   {
15612     try {
15613       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15614     } catch (std::out_of_range& e) {
15615       {
15616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15617       };
15618     } catch (std::exception& e) {
15619       {
15620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15621       };
15622     } catch (...) {
15623       {
15624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15625       };
15626     }
15627   }
15628   jresult = result;
15629   return jresult;
15630 }
15631
15632
15633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15634   unsigned int jresult ;
15635   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15636   Dali::Matrix *arg2 = 0 ;
15637   bool result;
15638
15639   arg1 = (Dali::Property::Value *)jarg1;
15640   arg2 = (Dali::Matrix *)jarg2;
15641   if (!arg2) {
15642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15643     return 0;
15644   }
15645   {
15646     try {
15647       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15648     } catch (std::out_of_range& e) {
15649       {
15650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15651       };
15652     } catch (std::exception& e) {
15653       {
15654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15655       };
15656     } catch (...) {
15657       {
15658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15659       };
15660     }
15661   }
15662   jresult = result;
15663   return jresult;
15664 }
15665
15666
15667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15668   unsigned int jresult ;
15669   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15670   Dali::AngleAxis *arg2 = 0 ;
15671   bool result;
15672
15673   arg1 = (Dali::Property::Value *)jarg1;
15674   arg2 = (Dali::AngleAxis *)jarg2;
15675   if (!arg2) {
15676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15677     return 0;
15678   }
15679   {
15680     try {
15681       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15682     } catch (std::out_of_range& e) {
15683       {
15684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15685       };
15686     } catch (std::exception& e) {
15687       {
15688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15689       };
15690     } catch (...) {
15691       {
15692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15693       };
15694     }
15695   }
15696   jresult = result;
15697   return jresult;
15698 }
15699
15700
15701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15702   unsigned int jresult ;
15703   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15704   Dali::Quaternion *arg2 = 0 ;
15705   bool result;
15706
15707   arg1 = (Dali::Property::Value *)jarg1;
15708   arg2 = (Dali::Quaternion *)jarg2;
15709   if (!arg2) {
15710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15711     return 0;
15712   }
15713   {
15714     try {
15715       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15716     } catch (std::out_of_range& e) {
15717       {
15718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15719       };
15720     } catch (std::exception& e) {
15721       {
15722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15723       };
15724     } catch (...) {
15725       {
15726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15727       };
15728     }
15729   }
15730   jresult = result;
15731   return jresult;
15732 }
15733
15734
15735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15736   unsigned int jresult ;
15737   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15738   std::string *arg2 = 0 ;
15739   bool result;
15740
15741   arg1 = (Dali::Property::Value *)jarg1;
15742
15743   //typemap in
15744   std::string temp;
15745   arg2 = &temp;
15746
15747   {
15748     try {
15749       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15750     } catch (std::out_of_range& e) {
15751       {
15752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15753       };
15754     } catch (std::exception& e) {
15755       {
15756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15757       };
15758     } catch (...) {
15759       {
15760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15761       };
15762     }
15763   }
15764   jresult = result;
15765
15766   //Typemap argout in c++ file.
15767   //This will convert c++ string to c# string
15768   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15769
15770   return jresult;
15771 }
15772
15773
15774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15775   unsigned int jresult ;
15776   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15777   Dali::Property::Array *arg2 = 0 ;
15778   bool result;
15779
15780   arg1 = (Dali::Property::Value *)jarg1;
15781   arg2 = (Dali::Property::Array *)jarg2;
15782   if (!arg2) {
15783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15784     return 0;
15785   }
15786   {
15787     try {
15788       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15789     } catch (std::out_of_range& e) {
15790       {
15791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15792       };
15793     } catch (std::exception& e) {
15794       {
15795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15796       };
15797     } catch (...) {
15798       {
15799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15800       };
15801     }
15802   }
15803   jresult = result;
15804   return jresult;
15805 }
15806
15807
15808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15809   unsigned int jresult ;
15810   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15811   Dali::Property::Map *arg2 = 0 ;
15812   bool result;
15813
15814   arg1 = (Dali::Property::Value *)jarg1;
15815   arg2 = (Dali::Property::Map *)jarg2;
15816   if (!arg2) {
15817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15818     return 0;
15819   }
15820   {
15821     try {
15822       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15823     } catch (std::out_of_range& e) {
15824       {
15825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15826       };
15827     } catch (std::exception& e) {
15828       {
15829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15830       };
15831     } catch (...) {
15832       {
15833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15834       };
15835     }
15836   }
15837   jresult = result;
15838   return jresult;
15839 }
15840
15841
15842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15843   void * jresult ;
15844   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15845   Dali::Property::Array *result = 0 ;
15846
15847   arg1 = (Dali::Property::Value *)jarg1;
15848   {
15849     try {
15850       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15851     } catch (std::out_of_range& e) {
15852       {
15853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15854       };
15855     } catch (std::exception& e) {
15856       {
15857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15858       };
15859     } catch (...) {
15860       {
15861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15862       };
15863     }
15864   }
15865   jresult = (void *)result;
15866   return jresult;
15867 }
15868
15869
15870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15871   void * jresult ;
15872   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15873   Dali::Property::Map *result = 0 ;
15874
15875   arg1 = (Dali::Property::Value *)jarg1;
15876   {
15877     try {
15878       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15879     } catch (std::out_of_range& e) {
15880       {
15881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15882       };
15883     } catch (std::exception& e) {
15884       {
15885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15886       };
15887     } catch (...) {
15888       {
15889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15890       };
15891     }
15892   }
15893   jresult = (void *)result;
15894   return jresult;
15895 }
15896
15897
15898 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15899   char * jresult ;
15900   Dali::Property::Type arg1 ;
15901   char *result = 0 ;
15902
15903   arg1 = (Dali::Property::Type)jarg1;
15904   {
15905     try {
15906       result = (char *)Dali::PropertyTypes::GetName(arg1);
15907     } catch (std::out_of_range& e) {
15908       {
15909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15910       };
15911     } catch (std::exception& e) {
15912       {
15913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15914       };
15915     } catch (...) {
15916       {
15917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15918       };
15919     }
15920   }
15921   jresult = SWIG_csharp_string_callback((const char *)result);
15922   return jresult;
15923 }
15924
15925
15926 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15927   unsigned int jresult ;
15928   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15929   std::string *arg2 = 0 ;
15930   Dali::Property::Map *arg3 = 0 ;
15931   bool result;
15932
15933   arg1 = (Dali::BaseObject *)jarg1;
15934   if (!jarg2) {
15935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15936     return 0;
15937   }
15938   std::string arg2_str(jarg2);
15939   arg2 = &arg2_str;
15940   arg3 = (Dali::Property::Map *)jarg3;
15941   if (!arg3) {
15942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15943     return 0;
15944   }
15945   {
15946     try {
15947       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15948     } catch (std::out_of_range& e) {
15949       {
15950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15951       };
15952     } catch (std::exception& e) {
15953       {
15954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15955       };
15956     } catch (...) {
15957       {
15958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15959       };
15960     }
15961   }
15962   jresult = result;
15963
15964   //argout typemap for const std::string&
15965
15966   return jresult;
15967 }
15968
15969
15970 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15971   char * jresult ;
15972   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15973   std::string *result = 0 ;
15974
15975   arg1 = (Dali::BaseObject *)jarg1;
15976   {
15977     try {
15978       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15979     } catch (std::out_of_range& e) {
15980       {
15981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15982       };
15983     } catch (std::exception& e) {
15984       {
15985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15986       };
15987     } catch (...) {
15988       {
15989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15990       };
15991     }
15992   }
15993   jresult = SWIG_csharp_string_callback(result->c_str());
15994   return jresult;
15995 }
15996
15997
15998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15999   unsigned int jresult ;
16000   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16001   Dali::TypeInfo *arg2 = 0 ;
16002   bool result;
16003
16004   arg1 = (Dali::BaseObject *)jarg1;
16005   arg2 = (Dali::TypeInfo *)jarg2;
16006   if (!arg2) {
16007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16008     return 0;
16009   }
16010   {
16011     try {
16012       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
16013     } catch (std::out_of_range& e) {
16014       {
16015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16016       };
16017     } catch (std::exception& e) {
16018       {
16019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16020       };
16021     } catch (...) {
16022       {
16023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16024       };
16025     }
16026   }
16027   jresult = result;
16028   return jresult;
16029 }
16030
16031
16032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16033   unsigned int jresult ;
16034   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16035   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16036   std::string *arg3 = 0 ;
16037   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16038   bool result;
16039
16040   arg1 = (Dali::BaseObject *)jarg1;
16041   arg2 = (ConnectionTrackerInterface *)jarg2;
16042   if (!jarg3) {
16043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16044     return 0;
16045   }
16046   std::string arg3_str(jarg3);
16047   arg3 = &arg3_str;
16048   arg4 = (FunctorDelegate *)jarg4;
16049   {
16050     try {
16051       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16052     } catch (std::out_of_range& e) {
16053       {
16054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16055       };
16056     } catch (std::exception& e) {
16057       {
16058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16059       };
16060     } catch (...) {
16061       {
16062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16063       };
16064     }
16065   }
16066   jresult = result;
16067
16068   //argout typemap for const std::string&
16069
16070   return jresult;
16071 }
16072
16073
16074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16075   void * jresult ;
16076   Dali::BaseHandle *arg1 = 0 ;
16077   Dali::BaseObject *result = 0 ;
16078
16079   arg1 = (Dali::BaseHandle *)jarg1;
16080   if (!arg1) {
16081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16082     return 0;
16083   }
16084   {
16085     try {
16086       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16087     } catch (std::out_of_range& e) {
16088       {
16089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16090       };
16091     } catch (std::exception& e) {
16092       {
16093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16094       };
16095     } catch (...) {
16096       {
16097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16098       };
16099     }
16100   }
16101   jresult = (void *)result;
16102   return jresult;
16103 }
16104
16105
16106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16107   void * jresult ;
16108   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16109   Dali::BaseHandle *result = 0 ;
16110
16111   arg1 = (Dali::BaseObject *)jarg1;
16112   {
16113     try {
16114       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16115     } catch (std::out_of_range& e) {
16116       {
16117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16118       };
16119     } catch (std::exception& e) {
16120       {
16121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16122       };
16123     } catch (...) {
16124       {
16125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16126       };
16127     }
16128   }
16129   jresult = (void *)result;
16130   return jresult;
16131 }
16132
16133
16134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16135   void * jresult ;
16136   Dali::BaseHandle *result = 0 ;
16137
16138   {
16139     try {
16140       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16141     } catch (std::out_of_range& e) {
16142       {
16143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16144       };
16145     } catch (std::exception& e) {
16146       {
16147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16148       };
16149     } catch (...) {
16150       {
16151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16152       };
16153     }
16154   }
16155   jresult = (void *)result;
16156   return jresult;
16157 }
16158
16159
16160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16161   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16162
16163   arg1 = (Dali::BaseHandle *)jarg1;
16164   {
16165     try {
16166       delete arg1;
16167     } catch (std::out_of_range& e) {
16168       {
16169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16170       };
16171     } catch (std::exception& e) {
16172       {
16173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16174       };
16175     } catch (...) {
16176       {
16177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16178       };
16179     }
16180   }
16181 }
16182
16183
16184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16185   void * jresult ;
16186   Dali::BaseHandle *arg1 = 0 ;
16187   Dali::BaseHandle *result = 0 ;
16188
16189   arg1 = (Dali::BaseHandle *)jarg1;
16190   if (!arg1) {
16191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16192     return 0;
16193   }
16194   {
16195     try {
16196       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16197     } catch (std::out_of_range& e) {
16198       {
16199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16200       };
16201     } catch (std::exception& e) {
16202       {
16203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16204       };
16205     } catch (...) {
16206       {
16207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16208       };
16209     }
16210   }
16211   jresult = (void *)result;
16212   return jresult;
16213 }
16214
16215
16216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16217   void * jresult ;
16218   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16219   Dali::BaseHandle *arg2 = 0 ;
16220   Dali::BaseHandle *result = 0 ;
16221
16222   arg1 = (Dali::BaseHandle *)jarg1;
16223   arg2 = (Dali::BaseHandle *)jarg2;
16224   if (!arg2) {
16225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16226     return 0;
16227   }
16228   {
16229     try {
16230       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16231     } catch (std::out_of_range& e) {
16232       {
16233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16234       };
16235     } catch (std::exception& e) {
16236       {
16237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16238       };
16239     } catch (...) {
16240       {
16241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16242       };
16243     }
16244   }
16245   jresult = (void *)result;
16246   return jresult;
16247 }
16248
16249
16250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16251   unsigned int jresult ;
16252   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16253   std::string *arg2 = 0 ;
16254   Dali::Property::Map *arg3 = 0 ;
16255   bool result;
16256
16257   arg1 = (Dali::BaseHandle *)jarg1;
16258   if (!jarg2) {
16259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16260     return 0;
16261   }
16262   std::string arg2_str(jarg2);
16263   arg2 = &arg2_str;
16264   arg3 = (Dali::Property::Map *)jarg3;
16265   if (!arg3) {
16266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16267     return 0;
16268   }
16269   {
16270     try {
16271       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16272     } catch (std::out_of_range& e) {
16273       {
16274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16275       };
16276     } catch (std::exception& e) {
16277       {
16278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16279       };
16280     } catch (...) {
16281       {
16282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16283       };
16284     }
16285   }
16286   jresult = result;
16287
16288   //argout typemap for const std::string&
16289
16290   return jresult;
16291 }
16292
16293
16294 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16295   char * jresult ;
16296   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16297   std::string *result = 0 ;
16298
16299   arg1 = (Dali::BaseHandle *)jarg1;
16300   {
16301     try {
16302       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16303     } catch (std::out_of_range& e) {
16304       {
16305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16306       };
16307     } catch (std::exception& e) {
16308       {
16309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16310       };
16311     } catch (...) {
16312       {
16313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16314       };
16315     }
16316   }
16317   jresult = SWIG_csharp_string_callback(result->c_str());
16318   return jresult;
16319 }
16320
16321
16322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16323   unsigned int jresult ;
16324   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16325   Dali::TypeInfo *arg2 = 0 ;
16326   bool result;
16327
16328   arg1 = (Dali::BaseHandle *)jarg1;
16329   arg2 = (Dali::TypeInfo *)jarg2;
16330   if (!arg2) {
16331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16332     return 0;
16333   }
16334   {
16335     try {
16336       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16337     } catch (std::out_of_range& e) {
16338       {
16339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16340       };
16341     } catch (std::exception& e) {
16342       {
16343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16344       };
16345     } catch (...) {
16346       {
16347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16348       };
16349     }
16350   }
16351   jresult = result;
16352   return jresult;
16353 }
16354
16355
16356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16357   void * jresult ;
16358   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16359   Dali::BaseObject *result = 0 ;
16360
16361   arg1 = (Dali::BaseHandle *)jarg1;
16362   {
16363     try {
16364       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16365     } catch (std::out_of_range& e) {
16366       {
16367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16368       };
16369     } catch (std::exception& e) {
16370       {
16371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16372       };
16373     } catch (...) {
16374       {
16375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16376       };
16377     }
16378   }
16379   jresult = (void *)result;
16380   return jresult;
16381 }
16382
16383
16384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16385   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16386
16387   arg1 = (Dali::BaseHandle *)jarg1;
16388   {
16389     try {
16390       (arg1)->Reset();
16391     } catch (std::out_of_range& e) {
16392       {
16393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16394       };
16395     } catch (std::exception& e) {
16396       {
16397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16398       };
16399     } catch (...) {
16400       {
16401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16402       };
16403     }
16404   }
16405 }
16406
16407
16408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16409   unsigned int jresult ;
16410   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16411   Dali::BaseHandle *arg2 = 0 ;
16412   bool result;
16413
16414   arg1 = (Dali::BaseHandle *)jarg1;
16415   arg2 = (Dali::BaseHandle *)jarg2;
16416   if (!arg2) {
16417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16418     return 0;
16419   }
16420   {
16421     try {
16422       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16423     } catch (std::out_of_range& e) {
16424       {
16425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16426       };
16427     } catch (std::exception& e) {
16428       {
16429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16430       };
16431     } catch (...) {
16432       {
16433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16434       };
16435     }
16436   }
16437   jresult = result;
16438   return jresult;
16439 }
16440
16441
16442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16443   unsigned int jresult ;
16444   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16445   Dali::BaseHandle *arg2 = 0 ;
16446   bool result;
16447
16448   arg1 = (Dali::BaseHandle *)jarg1;
16449   arg2 = (Dali::BaseHandle *)jarg2;
16450   if (!arg2) {
16451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16452     return 0;
16453   }
16454   {
16455     try {
16456       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16457     } catch (std::out_of_range& e) {
16458       {
16459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16460       };
16461     } catch (std::exception& e) {
16462       {
16463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16464       };
16465     } catch (...) {
16466       {
16467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16468       };
16469     }
16470   }
16471   jresult = result;
16472   return jresult;
16473 }
16474
16475
16476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16477   void * jresult ;
16478   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16479   Dali::RefObject *result = 0 ;
16480
16481   arg1 = (Dali::BaseHandle *)jarg1;
16482   {
16483     try {
16484       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16485     } catch (std::out_of_range& e) {
16486       {
16487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16488       };
16489     } catch (std::exception& e) {
16490       {
16491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16492       };
16493     } catch (...) {
16494       {
16495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16496       };
16497     }
16498   }
16499   jresult = (void *)result;
16500   return jresult;
16501 }
16502
16503
16504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16505   unsigned int jresult ;
16506   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16507   bool result;
16508
16509   arg1 = (Dali::BaseHandle *)jarg1;
16510   {
16511     try {
16512       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16513     } catch (std::out_of_range& e) {
16514       {
16515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16516       };
16517     } catch (std::exception& e) {
16518       {
16519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16520       };
16521     } catch (...) {
16522       {
16523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16524       };
16525     }
16526   }
16527   jresult = result;
16528   return jresult;
16529 }
16530
16531
16532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16533   unsigned int jresult ;
16534   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16535   Dali::BaseHandle *arg2 = 0 ;
16536   bool result;
16537
16538   arg1 = (Dali::BaseHandle *)jarg1;
16539   arg2 = (Dali::BaseHandle *)jarg2;
16540   if (!arg2) {
16541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16542     return 0;
16543   }
16544   {
16545     try {
16546       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16547     } catch (std::out_of_range& e) {
16548       {
16549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16550       };
16551     } catch (std::exception& e) {
16552       {
16553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16554       };
16555     } catch (...) {
16556       {
16557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16558       };
16559     }
16560   }
16561   jresult = result;
16562   return jresult;
16563 }
16564
16565
16566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16567   unsigned int jresult ;
16568   Dali::BaseHandle *arg1 = 0 ;
16569   Dali::BaseHandle *arg2 = 0 ;
16570   bool result;
16571
16572   arg1 = (Dali::BaseHandle *)jarg1;
16573   if (!arg1) {
16574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16575     return 0;
16576   }
16577   arg2 = (Dali::BaseHandle *)jarg2;
16578   if (!arg2) {
16579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16580     return 0;
16581   }
16582   {
16583     try {
16584       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16585     } catch (std::out_of_range& e) {
16586       {
16587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16588       };
16589     } catch (std::exception& e) {
16590       {
16591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16592       };
16593     } catch (...) {
16594       {
16595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16596       };
16597     }
16598   }
16599   jresult = result;
16600   return jresult;
16601 }
16602
16603
16604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16605   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16606
16607   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16608   {
16609     try {
16610       delete arg1;
16611     } catch (std::out_of_range& e) {
16612       {
16613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16614       };
16615     } catch (std::exception& e) {
16616       {
16617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16618       };
16619     } catch (...) {
16620       {
16621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16622       };
16623     }
16624   }
16625 }
16626
16627
16628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16629   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16630   SlotObserver *arg2 = (SlotObserver *) 0 ;
16631   CallbackBase *arg3 = (CallbackBase *) 0 ;
16632
16633   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16634   arg2 = (SlotObserver *)jarg2;
16635   arg3 = (CallbackBase *)jarg3;
16636   {
16637     try {
16638       (arg1)->SignalConnected(arg2,arg3);
16639     } catch (std::out_of_range& e) {
16640       {
16641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16642       };
16643     } catch (std::exception& e) {
16644       {
16645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16646       };
16647     } catch (...) {
16648       {
16649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16650       };
16651     }
16652   }
16653 }
16654
16655
16656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16657   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16658
16659   arg1 = (Dali::SignalObserver *)jarg1;
16660   {
16661     try {
16662       delete arg1;
16663     } catch (std::out_of_range& e) {
16664       {
16665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16666       };
16667     } catch (std::exception& e) {
16668       {
16669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16670       };
16671     } catch (...) {
16672       {
16673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16674       };
16675     }
16676   }
16677 }
16678
16679
16680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16681   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16682   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16683   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16684
16685   arg1 = (Dali::SignalObserver *)jarg1;
16686   arg2 = (Dali::SlotObserver *)jarg2;
16687   arg3 = (Dali::CallbackBase *)jarg3;
16688   {
16689     try {
16690       (arg1)->SignalDisconnected(arg2,arg3);
16691     } catch (std::out_of_range& e) {
16692       {
16693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16694       };
16695     } catch (std::exception& e) {
16696       {
16697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16698       };
16699     } catch (...) {
16700       {
16701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16702       };
16703     }
16704   }
16705 }
16706
16707
16708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16709   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16710
16711   arg1 = (Dali::SlotObserver *)jarg1;
16712   {
16713     try {
16714       delete arg1;
16715     } catch (std::out_of_range& e) {
16716       {
16717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16718       };
16719     } catch (std::exception& e) {
16720       {
16721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16722       };
16723     } catch (...) {
16724       {
16725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16726       };
16727     }
16728   }
16729 }
16730
16731
16732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16733   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16734   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16735
16736   arg1 = (Dali::SlotObserver *)jarg1;
16737   arg2 = (Dali::CallbackBase *)jarg2;
16738   {
16739     try {
16740       (arg1)->SlotDisconnected(arg2);
16741     } catch (std::out_of_range& e) {
16742       {
16743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16744       };
16745     } catch (std::exception& e) {
16746       {
16747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16748       };
16749     } catch (...) {
16750       {
16751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16752       };
16753     }
16754   }
16755 }
16756
16757
16758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16759   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16760
16761   arg1 = (Dali::ConnectionTracker *)jarg1;
16762   {
16763     try {
16764       delete arg1;
16765     } catch (std::out_of_range& e) {
16766       {
16767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16768       };
16769     } catch (std::exception& e) {
16770       {
16771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16772       };
16773     } catch (...) {
16774       {
16775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16776       };
16777     }
16778   }
16779 }
16780
16781
16782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16783   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16784
16785   arg1 = (Dali::ConnectionTracker *)jarg1;
16786   {
16787     try {
16788       (arg1)->DisconnectAll();
16789     } catch (std::out_of_range& e) {
16790       {
16791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16792       };
16793     } catch (std::exception& e) {
16794       {
16795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16796       };
16797     } catch (...) {
16798       {
16799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16800       };
16801     }
16802   }
16803 }
16804
16805
16806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16807   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16808   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16809   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16810
16811   arg1 = (Dali::ConnectionTracker *)jarg1;
16812   arg2 = (Dali::SlotObserver *)jarg2;
16813   arg3 = (Dali::CallbackBase *)jarg3;
16814   {
16815     try {
16816       (arg1)->SignalConnected(arg2,arg3);
16817     } catch (std::out_of_range& e) {
16818       {
16819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16820       };
16821     } catch (std::exception& e) {
16822       {
16823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16824       };
16825     } catch (...) {
16826       {
16827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16828       };
16829     }
16830   }
16831 }
16832
16833
16834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16835   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16836   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16837   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16838
16839   arg1 = (Dali::ConnectionTracker *)jarg1;
16840   arg2 = (Dali::SlotObserver *)jarg2;
16841   arg3 = (Dali::CallbackBase *)jarg3;
16842   {
16843     try {
16844       (arg1)->SignalDisconnected(arg2,arg3);
16845     } catch (std::out_of_range& e) {
16846       {
16847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16848       };
16849     } catch (std::exception& e) {
16850       {
16851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16852       };
16853     } catch (...) {
16854       {
16855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16856       };
16857     }
16858   }
16859 }
16860
16861
16862 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16863   unsigned long jresult ;
16864   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16865   std::size_t result;
16866
16867   arg1 = (Dali::ConnectionTracker *)jarg1;
16868   {
16869     try {
16870       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16871     } catch (std::out_of_range& e) {
16872       {
16873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16874       };
16875     } catch (std::exception& e) {
16876       {
16877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16878       };
16879     } catch (...) {
16880       {
16881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16882       };
16883     }
16884   }
16885   jresult = (unsigned long)result;
16886   return jresult;
16887 }
16888
16889
16890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16891   void * jresult ;
16892   Dali::ObjectRegistry *result = 0 ;
16893
16894   {
16895     try {
16896       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16897     } catch (std::out_of_range& e) {
16898       {
16899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16900       };
16901     } catch (std::exception& e) {
16902       {
16903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16904       };
16905     } catch (...) {
16906       {
16907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16908       };
16909     }
16910   }
16911   jresult = (void *)result;
16912   return jresult;
16913 }
16914
16915
16916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16917   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16918
16919   arg1 = (Dali::ObjectRegistry *)jarg1;
16920   {
16921     try {
16922       delete arg1;
16923     } catch (std::out_of_range& e) {
16924       {
16925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16926       };
16927     } catch (std::exception& e) {
16928       {
16929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16930       };
16931     } catch (...) {
16932       {
16933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16934       };
16935     }
16936   }
16937 }
16938
16939
16940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16941   void * jresult ;
16942   Dali::ObjectRegistry *arg1 = 0 ;
16943   Dali::ObjectRegistry *result = 0 ;
16944
16945   arg1 = (Dali::ObjectRegistry *)jarg1;
16946   if (!arg1) {
16947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16948     return 0;
16949   }
16950   {
16951     try {
16952       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16953     } catch (std::out_of_range& e) {
16954       {
16955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16956       };
16957     } catch (std::exception& e) {
16958       {
16959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16960       };
16961     } catch (...) {
16962       {
16963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16964       };
16965     }
16966   }
16967   jresult = (void *)result;
16968   return jresult;
16969 }
16970
16971
16972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16973   void * jresult ;
16974   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16975   Dali::ObjectRegistry *arg2 = 0 ;
16976   Dali::ObjectRegistry *result = 0 ;
16977
16978   arg1 = (Dali::ObjectRegistry *)jarg1;
16979   arg2 = (Dali::ObjectRegistry *)jarg2;
16980   if (!arg2) {
16981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16982     return 0;
16983   }
16984   {
16985     try {
16986       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16987     } catch (std::out_of_range& e) {
16988       {
16989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16990       };
16991     } catch (std::exception& e) {
16992       {
16993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16994       };
16995     } catch (...) {
16996       {
16997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16998       };
16999     }
17000   }
17001   jresult = (void *)result;
17002   return jresult;
17003 }
17004
17005
17006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17007   void * jresult ;
17008   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17009   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17010
17011   arg1 = (Dali::ObjectRegistry *)jarg1;
17012   {
17013     try {
17014       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17015     } catch (std::out_of_range& e) {
17016       {
17017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17018       };
17019     } catch (std::exception& e) {
17020       {
17021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17022       };
17023     } catch (...) {
17024       {
17025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17026       };
17027     }
17028   }
17029   jresult = (void *)result;
17030   return jresult;
17031 }
17032
17033
17034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17035   void * jresult ;
17036   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17037   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17038
17039   arg1 = (Dali::ObjectRegistry *)jarg1;
17040   {
17041     try {
17042       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17043     } catch (std::out_of_range& e) {
17044       {
17045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17046       };
17047     } catch (std::exception& e) {
17048       {
17049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17050       };
17051     } catch (...) {
17052       {
17053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17054       };
17055     }
17056   }
17057   jresult = (void *)result;
17058   return jresult;
17059 }
17060
17061
17062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17063   void * jresult ;
17064   Dali::PropertyCondition *result = 0 ;
17065
17066   {
17067     try {
17068       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17069     } catch (std::out_of_range& e) {
17070       {
17071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17072       };
17073     } catch (std::exception& e) {
17074       {
17075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17076       };
17077     } catch (...) {
17078       {
17079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17080       };
17081     }
17082   }
17083   jresult = (void *)result;
17084   return jresult;
17085 }
17086
17087
17088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17089   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17090
17091   arg1 = (Dali::PropertyCondition *)jarg1;
17092   {
17093     try {
17094       delete arg1;
17095     } catch (std::out_of_range& e) {
17096       {
17097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17098       };
17099     } catch (std::exception& e) {
17100       {
17101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17102       };
17103     } catch (...) {
17104       {
17105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17106       };
17107     }
17108   }
17109 }
17110
17111
17112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17113   void * jresult ;
17114   Dali::PropertyCondition *arg1 = 0 ;
17115   Dali::PropertyCondition *result = 0 ;
17116
17117   arg1 = (Dali::PropertyCondition *)jarg1;
17118   if (!arg1) {
17119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17120     return 0;
17121   }
17122   {
17123     try {
17124       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17125     } catch (std::out_of_range& e) {
17126       {
17127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17128       };
17129     } catch (std::exception& e) {
17130       {
17131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17132       };
17133     } catch (...) {
17134       {
17135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17136       };
17137     }
17138   }
17139   jresult = (void *)result;
17140   return jresult;
17141 }
17142
17143
17144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17145   void * jresult ;
17146   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17147   Dali::PropertyCondition *arg2 = 0 ;
17148   Dali::PropertyCondition *result = 0 ;
17149
17150   arg1 = (Dali::PropertyCondition *)jarg1;
17151   arg2 = (Dali::PropertyCondition *)jarg2;
17152   if (!arg2) {
17153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17154     return 0;
17155   }
17156   {
17157     try {
17158       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17159     } catch (std::out_of_range& e) {
17160       {
17161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17162       };
17163     } catch (std::exception& e) {
17164       {
17165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17166       };
17167     } catch (...) {
17168       {
17169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17170       };
17171     }
17172   }
17173   jresult = (void *)result;
17174   return jresult;
17175 }
17176
17177
17178 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17179   unsigned long jresult ;
17180   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17181   std::size_t result;
17182
17183   arg1 = (Dali::PropertyCondition *)jarg1;
17184   {
17185     try {
17186       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17187     } catch (std::out_of_range& e) {
17188       {
17189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17190       };
17191     } catch (std::exception& e) {
17192       {
17193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17194       };
17195     } catch (...) {
17196       {
17197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17198       };
17199     }
17200   }
17201   jresult = (unsigned long)result;
17202   return jresult;
17203 }
17204
17205
17206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17207   float jresult ;
17208   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17209   std::size_t arg2 ;
17210   float result;
17211
17212   arg1 = (Dali::PropertyCondition *)jarg1;
17213   arg2 = (std::size_t)jarg2;
17214   {
17215     try {
17216       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17217     } catch (std::out_of_range& e) {
17218       {
17219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17220       };
17221     } catch (std::exception& e) {
17222       {
17223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17224       };
17225     } catch (...) {
17226       {
17227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17228       };
17229     }
17230   }
17231   jresult = result;
17232   return jresult;
17233 }
17234
17235
17236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17237   void * jresult ;
17238   float arg1 ;
17239   Dali::PropertyCondition result;
17240
17241   arg1 = (float)jarg1;
17242   {
17243     try {
17244       result = Dali::LessThanCondition(arg1);
17245     } catch (std::out_of_range& e) {
17246       {
17247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17248       };
17249     } catch (std::exception& e) {
17250       {
17251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17252       };
17253     } catch (...) {
17254       {
17255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17256       };
17257     }
17258   }
17259   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17260   return jresult;
17261 }
17262
17263
17264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17265   void * jresult ;
17266   float arg1 ;
17267   Dali::PropertyCondition result;
17268
17269   arg1 = (float)jarg1;
17270   {
17271     try {
17272       result = Dali::GreaterThanCondition(arg1);
17273     } catch (std::out_of_range& e) {
17274       {
17275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17276       };
17277     } catch (std::exception& e) {
17278       {
17279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17280       };
17281     } catch (...) {
17282       {
17283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17284       };
17285     }
17286   }
17287   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17288   return jresult;
17289 }
17290
17291
17292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17293   void * jresult ;
17294   float arg1 ;
17295   float arg2 ;
17296   Dali::PropertyCondition result;
17297
17298   arg1 = (float)jarg1;
17299   arg2 = (float)jarg2;
17300   {
17301     try {
17302       result = Dali::InsideCondition(arg1,arg2);
17303     } catch (std::out_of_range& e) {
17304       {
17305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17306       };
17307     } catch (std::exception& e) {
17308       {
17309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17310       };
17311     } catch (...) {
17312       {
17313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17314       };
17315     }
17316   }
17317   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17318   return jresult;
17319 }
17320
17321
17322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17323   void * jresult ;
17324   float arg1 ;
17325   float arg2 ;
17326   Dali::PropertyCondition result;
17327
17328   arg1 = (float)jarg1;
17329   arg2 = (float)jarg2;
17330   {
17331     try {
17332       result = Dali::OutsideCondition(arg1,arg2);
17333     } catch (std::out_of_range& e) {
17334       {
17335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17336       };
17337     } catch (std::exception& e) {
17338       {
17339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17340       };
17341     } catch (...) {
17342       {
17343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17344       };
17345     }
17346   }
17347   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17348   return jresult;
17349 }
17350
17351
17352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17353   void * jresult ;
17354   float arg1 ;
17355   float arg2 ;
17356   Dali::PropertyCondition result;
17357
17358   arg1 = (float)jarg1;
17359   arg2 = (float)jarg2;
17360   {
17361     try {
17362       result = Dali::StepCondition(arg1,arg2);
17363     } catch (std::out_of_range& e) {
17364       {
17365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17366       };
17367     } catch (std::exception& e) {
17368       {
17369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17370       };
17371     } catch (...) {
17372       {
17373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17374       };
17375     }
17376   }
17377   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17378   return jresult;
17379 }
17380
17381
17382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17383   void * jresult ;
17384   float arg1 ;
17385   Dali::PropertyCondition result;
17386
17387   arg1 = (float)jarg1;
17388   {
17389     try {
17390       result = Dali::StepCondition(arg1);
17391     } catch (std::out_of_range& e) {
17392       {
17393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17394       };
17395     } catch (std::exception& e) {
17396       {
17397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17398       };
17399     } catch (...) {
17400       {
17401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17402       };
17403     }
17404   }
17405   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17406   return jresult;
17407 }
17408
17409
17410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17411   void * jresult ;
17412   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17413   Dali::PropertyCondition result;
17414
17415   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17416   if (!arg1) {
17417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17418     return 0;
17419   }
17420   {
17421     try {
17422       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17423     } catch (std::out_of_range& e) {
17424       {
17425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17426       };
17427     } catch (std::exception& e) {
17428       {
17429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17430       };
17431     } catch (...) {
17432       {
17433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17434       };
17435     }
17436   }
17437   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17438   return jresult;
17439 }
17440
17441
17442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17443   void * jresult ;
17444   Dali::PropertyNotification *result = 0 ;
17445
17446   {
17447     try {
17448       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17449     } catch (std::out_of_range& e) {
17450       {
17451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17452       };
17453     } catch (std::exception& e) {
17454       {
17455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17456       };
17457     } catch (...) {
17458       {
17459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17460       };
17461     }
17462   }
17463   jresult = (void *)result;
17464   return jresult;
17465 }
17466
17467
17468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17469   void * jresult ;
17470   Dali::BaseHandle arg1 ;
17471   Dali::BaseHandle *argp1 ;
17472   Dali::PropertyNotification result;
17473
17474   argp1 = (Dali::BaseHandle *)jarg1;
17475   if (!argp1) {
17476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17477     return 0;
17478   }
17479   arg1 = *argp1;
17480   {
17481     try {
17482       result = Dali::PropertyNotification::DownCast(arg1);
17483     } catch (std::out_of_range& e) {
17484       {
17485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17486       };
17487     } catch (std::exception& e) {
17488       {
17489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17490       };
17491     } catch (...) {
17492       {
17493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17494       };
17495     }
17496   }
17497   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17498   return jresult;
17499 }
17500
17501
17502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17503   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17504
17505   arg1 = (Dali::PropertyNotification *)jarg1;
17506   {
17507     try {
17508       delete arg1;
17509     } catch (std::out_of_range& e) {
17510       {
17511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17512       };
17513     } catch (std::exception& e) {
17514       {
17515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17516       };
17517     } catch (...) {
17518       {
17519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17520       };
17521     }
17522   }
17523 }
17524
17525
17526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17527   void * jresult ;
17528   Dali::PropertyNotification *arg1 = 0 ;
17529   Dali::PropertyNotification *result = 0 ;
17530
17531   arg1 = (Dali::PropertyNotification *)jarg1;
17532   if (!arg1) {
17533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17534     return 0;
17535   }
17536   {
17537     try {
17538       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17539     } catch (std::out_of_range& e) {
17540       {
17541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17542       };
17543     } catch (std::exception& e) {
17544       {
17545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17546       };
17547     } catch (...) {
17548       {
17549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17550       };
17551     }
17552   }
17553   jresult = (void *)result;
17554   return jresult;
17555 }
17556
17557
17558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17559   void * jresult ;
17560   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17561   Dali::PropertyNotification *arg2 = 0 ;
17562   Dali::PropertyNotification *result = 0 ;
17563
17564   arg1 = (Dali::PropertyNotification *)jarg1;
17565   arg2 = (Dali::PropertyNotification *)jarg2;
17566   if (!arg2) {
17567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17568     return 0;
17569   }
17570   {
17571     try {
17572       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17573     } catch (std::out_of_range& e) {
17574       {
17575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17576       };
17577     } catch (std::exception& e) {
17578       {
17579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17580       };
17581     } catch (...) {
17582       {
17583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17584       };
17585     }
17586   }
17587   jresult = (void *)result;
17588   return jresult;
17589 }
17590
17591
17592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17593   void * jresult ;
17594   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17595   Dali::PropertyCondition result;
17596
17597   arg1 = (Dali::PropertyNotification *)jarg1;
17598   {
17599     try {
17600       result = (arg1)->GetCondition();
17601     } catch (std::out_of_range& e) {
17602       {
17603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17604       };
17605     } catch (std::exception& e) {
17606       {
17607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17608       };
17609     } catch (...) {
17610       {
17611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17612       };
17613     }
17614   }
17615   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17616   return jresult;
17617 }
17618
17619
17620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17621   void * jresult ;
17622   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17623   Dali::Handle result;
17624
17625   arg1 = (Dali::PropertyNotification *)jarg1;
17626   {
17627     try {
17628       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17629     } catch (std::out_of_range& e) {
17630       {
17631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17632       };
17633     } catch (std::exception& e) {
17634       {
17635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17636       };
17637     } catch (...) {
17638       {
17639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17640       };
17641     }
17642   }
17643   jresult = new Dali::Handle((const Dali::Handle &)result);
17644   return jresult;
17645 }
17646
17647
17648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17649   int jresult ;
17650   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17651   Dali::Property::Index result;
17652
17653   arg1 = (Dali::PropertyNotification *)jarg1;
17654   {
17655     try {
17656       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17657     } catch (std::out_of_range& e) {
17658       {
17659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17660       };
17661     } catch (std::exception& e) {
17662       {
17663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17664       };
17665     } catch (...) {
17666       {
17667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17668       };
17669     }
17670   }
17671   jresult = result;
17672   return jresult;
17673 }
17674
17675
17676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17677   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17678   Dali::PropertyNotification::NotifyMode arg2 ;
17679
17680   arg1 = (Dali::PropertyNotification *)jarg1;
17681   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17682   {
17683     try {
17684       (arg1)->SetNotifyMode(arg2);
17685     } catch (std::out_of_range& e) {
17686       {
17687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17688       };
17689     } catch (std::exception& e) {
17690       {
17691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17692       };
17693     } catch (...) {
17694       {
17695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17696       };
17697     }
17698   }
17699 }
17700
17701
17702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17703   int jresult ;
17704   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17705   Dali::PropertyNotification::NotifyMode result;
17706
17707   arg1 = (Dali::PropertyNotification *)jarg1;
17708   {
17709     try {
17710       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17711     } catch (std::out_of_range& e) {
17712       {
17713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17714       };
17715     } catch (std::exception& e) {
17716       {
17717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17718       };
17719     } catch (...) {
17720       {
17721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17722       };
17723     }
17724   }
17725   jresult = (int)result;
17726   return jresult;
17727 }
17728
17729
17730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17731   unsigned int jresult ;
17732   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17733   bool result;
17734
17735   arg1 = (Dali::PropertyNotification *)jarg1;
17736   {
17737     try {
17738       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17739     } catch (std::out_of_range& e) {
17740       {
17741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17742       };
17743     } catch (std::exception& e) {
17744       {
17745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17746       };
17747     } catch (...) {
17748       {
17749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17750       };
17751     }
17752   }
17753   jresult = result;
17754   return jresult;
17755 }
17756
17757
17758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17759   void * jresult ;
17760   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17761   Dali::PropertyNotifySignalType *result = 0 ;
17762
17763   arg1 = (Dali::PropertyNotification *)jarg1;
17764   {
17765     try {
17766       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17767     } catch (std::out_of_range& e) {
17768       {
17769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17770       };
17771     } catch (std::exception& e) {
17772       {
17773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17774       };
17775     } catch (...) {
17776       {
17777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17778       };
17779     }
17780   }
17781   jresult = (void *)result;
17782   return jresult;
17783 }
17784
17785
17786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17787   void * jresult ;
17788   Dali::Handle *result = 0 ;
17789
17790   {
17791     try {
17792       result = (Dali::Handle *)new Dali::Handle();
17793     } catch (std::out_of_range& e) {
17794       {
17795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17796       };
17797     } catch (std::exception& e) {
17798       {
17799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17800       };
17801     } catch (...) {
17802       {
17803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17804       };
17805     }
17806   }
17807   jresult = (void *)result;
17808   return jresult;
17809 }
17810
17811
17812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17813   void * jresult ;
17814   Dali::Handle result;
17815
17816   {
17817     try {
17818       result = Dali::Handle::New();
17819     } catch (std::out_of_range& e) {
17820       {
17821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17822       };
17823     } catch (std::exception& e) {
17824       {
17825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17826       };
17827     } catch (...) {
17828       {
17829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17830       };
17831     }
17832   }
17833   jresult = new Dali::Handle((const Dali::Handle &)result);
17834   return jresult;
17835 }
17836
17837
17838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17839   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17840
17841   arg1 = (Dali::Handle *)jarg1;
17842   {
17843     try {
17844       delete arg1;
17845     } catch (std::out_of_range& e) {
17846       {
17847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17848       };
17849     } catch (std::exception& e) {
17850       {
17851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17852       };
17853     } catch (...) {
17854       {
17855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17856       };
17857     }
17858   }
17859 }
17860
17861
17862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17863   void * jresult ;
17864   Dali::Handle *arg1 = 0 ;
17865   Dali::Handle *result = 0 ;
17866
17867   arg1 = (Dali::Handle *)jarg1;
17868   if (!arg1) {
17869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17870     return 0;
17871   }
17872   {
17873     try {
17874       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17875     } catch (std::out_of_range& e) {
17876       {
17877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17878       };
17879     } catch (std::exception& e) {
17880       {
17881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17882       };
17883     } catch (...) {
17884       {
17885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17886       };
17887     }
17888   }
17889   jresult = (void *)result;
17890   return jresult;
17891 }
17892
17893
17894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17895   void * jresult ;
17896   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17897   Dali::Handle *arg2 = 0 ;
17898   Dali::Handle *result = 0 ;
17899
17900   arg1 = (Dali::Handle *)jarg1;
17901   arg2 = (Dali::Handle *)jarg2;
17902   if (!arg2) {
17903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17904     return 0;
17905   }
17906   {
17907     try {
17908       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17909     } catch (std::out_of_range& e) {
17910       {
17911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17912       };
17913     } catch (std::exception& e) {
17914       {
17915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17916       };
17917     } catch (...) {
17918       {
17919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17920       };
17921     }
17922   }
17923   jresult = (void *)result;
17924   return jresult;
17925 }
17926
17927
17928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17929   void * jresult ;
17930   Dali::BaseHandle arg1 ;
17931   Dali::BaseHandle *argp1 ;
17932   Dali::Handle result;
17933
17934   argp1 = (Dali::BaseHandle *)jarg1;
17935   if (!argp1) {
17936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17937     return 0;
17938   }
17939   arg1 = *argp1;
17940   {
17941     try {
17942       result = Dali::Handle::DownCast(arg1);
17943     } catch (std::out_of_range& e) {
17944       {
17945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17946       };
17947     } catch (std::exception& e) {
17948       {
17949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17950       };
17951     } catch (...) {
17952       {
17953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17954       };
17955     }
17956   }
17957   jresult = new Dali::Handle((const Dali::Handle &)result);
17958   return jresult;
17959 }
17960
17961
17962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17963   unsigned int jresult ;
17964   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17965   Dali::Handle::Capability arg2 ;
17966   bool result;
17967
17968   arg1 = (Dali::Handle *)jarg1;
17969   arg2 = (Dali::Handle::Capability)jarg2;
17970   {
17971     try {
17972       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17973     } catch (std::out_of_range& e) {
17974       {
17975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17976       };
17977     } catch (std::exception& e) {
17978       {
17979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17980       };
17981     } catch (...) {
17982       {
17983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17984       };
17985     }
17986   }
17987   jresult = result;
17988   return jresult;
17989 }
17990
17991
17992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17993   unsigned int jresult ;
17994   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17995   unsigned int result;
17996
17997   arg1 = (Dali::Handle *)jarg1;
17998   {
17999     try {
18000       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
18001     } catch (std::out_of_range& e) {
18002       {
18003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18004       };
18005     } catch (std::exception& e) {
18006       {
18007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18008       };
18009     } catch (...) {
18010       {
18011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18012       };
18013     }
18014   }
18015   jresult = result;
18016   return jresult;
18017 }
18018
18019
18020 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
18021   char * jresult ;
18022   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18023   Dali::Property::Index arg2 ;
18024   std::string result;
18025
18026   arg1 = (Dali::Handle *)jarg1;
18027   arg2 = (Dali::Property::Index)jarg2;
18028   {
18029     try {
18030       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18031     } catch (std::out_of_range& e) {
18032       {
18033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18034       };
18035     } catch (std::exception& e) {
18036       {
18037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18038       };
18039     } catch (...) {
18040       {
18041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18042       };
18043     }
18044   }
18045   jresult = SWIG_csharp_string_callback((&result)->c_str());
18046   return jresult;
18047 }
18048
18049
18050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18051   int jresult ;
18052   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18053   std::string *arg2 = 0 ;
18054   Dali::Property::Index result;
18055
18056   arg1 = (Dali::Handle *)jarg1;
18057   if (!jarg2) {
18058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18059     return 0;
18060   }
18061   std::string arg2_str(jarg2);
18062   arg2 = &arg2_str;
18063   {
18064     try {
18065       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18066     } catch (std::out_of_range& e) {
18067       {
18068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18069       };
18070     } catch (std::exception& e) {
18071       {
18072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18073       };
18074     } catch (...) {
18075       {
18076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18077       };
18078     }
18079   }
18080   jresult = result;
18081
18082   //argout typemap for const std::string&
18083
18084   return jresult;
18085 }
18086
18087
18088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18089   unsigned int jresult ;
18090   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18091   Dali::Property::Index arg2 ;
18092   bool result;
18093
18094   arg1 = (Dali::Handle *)jarg1;
18095   arg2 = (Dali::Property::Index)jarg2;
18096   {
18097     try {
18098       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18099     } catch (std::out_of_range& e) {
18100       {
18101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18102       };
18103     } catch (std::exception& e) {
18104       {
18105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18106       };
18107     } catch (...) {
18108       {
18109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18110       };
18111     }
18112   }
18113   jresult = result;
18114   return jresult;
18115 }
18116
18117
18118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18119   unsigned int jresult ;
18120   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18121   Dali::Property::Index arg2 ;
18122   bool result;
18123
18124   arg1 = (Dali::Handle *)jarg1;
18125   arg2 = (Dali::Property::Index)jarg2;
18126   {
18127     try {
18128       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18129     } catch (std::out_of_range& e) {
18130       {
18131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18132       };
18133     } catch (std::exception& e) {
18134       {
18135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18136       };
18137     } catch (...) {
18138       {
18139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18140       };
18141     }
18142   }
18143   jresult = result;
18144   return jresult;
18145 }
18146
18147
18148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18149   unsigned int jresult ;
18150   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18151   Dali::Property::Index arg2 ;
18152   bool result;
18153
18154   arg1 = (Dali::Handle *)jarg1;
18155   arg2 = (Dali::Property::Index)jarg2;
18156   {
18157     try {
18158       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18159     } catch (std::out_of_range& e) {
18160       {
18161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18162       };
18163     } catch (std::exception& e) {
18164       {
18165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18166       };
18167     } catch (...) {
18168       {
18169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18170       };
18171     }
18172   }
18173   jresult = result;
18174   return jresult;
18175 }
18176
18177
18178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18179   int jresult ;
18180   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18181   Dali::Property::Index arg2 ;
18182   Dali::Property::Type result;
18183
18184   arg1 = (Dali::Handle *)jarg1;
18185   arg2 = (Dali::Property::Index)jarg2;
18186   {
18187     try {
18188       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18189     } catch (std::out_of_range& e) {
18190       {
18191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18192       };
18193     } catch (std::exception& e) {
18194       {
18195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18196       };
18197     } catch (...) {
18198       {
18199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18200       };
18201     }
18202   }
18203   jresult = (int)result;
18204   return jresult;
18205 }
18206
18207
18208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18209   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18210   Dali::Property::Index arg2 ;
18211   Dali::Property::Value *arg3 = 0 ;
18212
18213   arg1 = (Dali::Handle *)jarg1;
18214   arg2 = (Dali::Property::Index)jarg2;
18215   arg3 = (Dali::Property::Value *)jarg3;
18216   if (!arg3) {
18217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18218     return ;
18219   }
18220   {
18221     try {
18222       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18223     } catch (std::out_of_range& e) {
18224       {
18225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18226       };
18227     } catch (std::exception& e) {
18228       {
18229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18230       };
18231     } catch (...) {
18232       {
18233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18234       };
18235     }
18236   }
18237 }
18238
18239
18240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18241   int jresult ;
18242   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18243   std::string *arg2 = 0 ;
18244   Dali::Property::Value *arg3 = 0 ;
18245   Dali::Property::Index result;
18246
18247   arg1 = (Dali::Handle *)jarg1;
18248   if (!jarg2) {
18249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18250     return 0;
18251   }
18252   std::string arg2_str(jarg2);
18253   arg2 = &arg2_str;
18254   arg3 = (Dali::Property::Value *)jarg3;
18255   if (!arg3) {
18256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18257     return 0;
18258   }
18259   {
18260     try {
18261       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18262     } catch (std::out_of_range& e) {
18263       {
18264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18265       };
18266     } catch (std::exception& e) {
18267       {
18268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18269       };
18270     } catch (...) {
18271       {
18272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18273       };
18274     }
18275   }
18276   jresult = result;
18277
18278   //argout typemap for const std::string&
18279
18280   return jresult;
18281 }
18282
18283
18284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18285   int jresult ;
18286   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18287   std::string *arg2 = 0 ;
18288   Dali::Property::Value *arg3 = 0 ;
18289   Dali::Property::AccessMode arg4 ;
18290   Dali::Property::Index result;
18291
18292   arg1 = (Dali::Handle *)jarg1;
18293   if (!jarg2) {
18294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18295     return 0;
18296   }
18297   std::string arg2_str(jarg2);
18298   arg2 = &arg2_str;
18299   arg3 = (Dali::Property::Value *)jarg3;
18300   if (!arg3) {
18301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18302     return 0;
18303   }
18304   arg4 = (Dali::Property::AccessMode)jarg4;
18305   {
18306     try {
18307       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18308     } catch (std::out_of_range& e) {
18309       {
18310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18311       };
18312     } catch (std::exception& e) {
18313       {
18314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18315       };
18316     } catch (...) {
18317       {
18318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18319       };
18320     }
18321   }
18322   jresult = result;
18323
18324   //argout typemap for const std::string&
18325
18326   return jresult;
18327 }
18328
18329
18330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18331   void * jresult ;
18332   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18333   Dali::Property::Index arg2 ;
18334   Dali::Property::Value result;
18335
18336   arg1 = (Dali::Handle *)jarg1;
18337   arg2 = (Dali::Property::Index)jarg2;
18338   {
18339     try {
18340       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18341     } catch (std::out_of_range& e) {
18342       {
18343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18344       };
18345     } catch (std::exception& e) {
18346       {
18347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18348       };
18349     } catch (...) {
18350       {
18351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18352       };
18353     }
18354   }
18355   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18356   return jresult;
18357 }
18358
18359
18360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18361   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18362   Dali::Property::IndexContainer *arg2 = 0 ;
18363
18364   arg1 = (Dali::Handle *)jarg1;
18365   arg2 = (Dali::Property::IndexContainer *)jarg2;
18366   if (!arg2) {
18367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18368     return ;
18369   }
18370   {
18371     try {
18372       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18373     } catch (std::out_of_range& e) {
18374       {
18375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18376       };
18377     } catch (std::exception& e) {
18378       {
18379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18380       };
18381     } catch (...) {
18382       {
18383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18384       };
18385     }
18386   }
18387 }
18388
18389
18390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18391   void * jresult ;
18392   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18393   Dali::Property::Index arg2 ;
18394   Dali::PropertyCondition *arg3 = 0 ;
18395   Dali::PropertyNotification result;
18396
18397   arg1 = (Dali::Handle *)jarg1;
18398   arg2 = (Dali::Property::Index)jarg2;
18399   arg3 = (Dali::PropertyCondition *)jarg3;
18400   if (!arg3) {
18401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18402     return 0;
18403   }
18404   {
18405     try {
18406       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18407     } catch (std::out_of_range& e) {
18408       {
18409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18410       };
18411     } catch (std::exception& e) {
18412       {
18413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18414       };
18415     } catch (...) {
18416       {
18417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18418       };
18419     }
18420   }
18421   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18422   return jresult;
18423 }
18424
18425
18426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18427   void * jresult ;
18428   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18429   Dali::Property::Index arg2 ;
18430   int arg3 ;
18431   Dali::PropertyCondition *arg4 = 0 ;
18432   Dali::PropertyNotification result;
18433
18434   arg1 = (Dali::Handle *)jarg1;
18435   arg2 = (Dali::Property::Index)jarg2;
18436   arg3 = (int)jarg3;
18437   arg4 = (Dali::PropertyCondition *)jarg4;
18438   if (!arg4) {
18439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18440     return 0;
18441   }
18442   {
18443     try {
18444       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18445     } catch (std::out_of_range& e) {
18446       {
18447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18448       };
18449     } catch (std::exception& e) {
18450       {
18451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18452       };
18453     } catch (...) {
18454       {
18455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18456       };
18457     }
18458   }
18459   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18460   return jresult;
18461 }
18462
18463
18464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18465   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18466   Dali::PropertyNotification arg2 ;
18467   Dali::PropertyNotification *argp2 ;
18468
18469   arg1 = (Dali::Handle *)jarg1;
18470   argp2 = (Dali::PropertyNotification *)jarg2;
18471   if (!argp2) {
18472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18473     return ;
18474   }
18475   arg2 = *argp2;
18476   {
18477     try {
18478       (arg1)->RemovePropertyNotification(arg2);
18479     } catch (std::out_of_range& e) {
18480       {
18481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18482       };
18483     } catch (std::exception& e) {
18484       {
18485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18486       };
18487     } catch (...) {
18488       {
18489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18490       };
18491     }
18492   }
18493 }
18494
18495
18496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18497   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18498
18499   arg1 = (Dali::Handle *)jarg1;
18500   {
18501     try {
18502       (arg1)->RemovePropertyNotifications();
18503     } catch (std::out_of_range& e) {
18504       {
18505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18506       };
18507     } catch (std::exception& e) {
18508       {
18509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18510       };
18511     } catch (...) {
18512       {
18513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18514       };
18515     }
18516   }
18517 }
18518
18519
18520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18521   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18522
18523   arg1 = (Dali::Handle *)jarg1;
18524   {
18525     try {
18526       (arg1)->RemoveConstraints();
18527     } catch (std::out_of_range& e) {
18528       {
18529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18530       };
18531     } catch (std::exception& e) {
18532       {
18533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18534       };
18535     } catch (...) {
18536       {
18537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18538       };
18539     }
18540   }
18541 }
18542
18543
18544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18545   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18546   unsigned int arg2 ;
18547
18548   arg1 = (Dali::Handle *)jarg1;
18549   arg2 = (unsigned int)jarg2;
18550   {
18551     try {
18552       (arg1)->RemoveConstraints(arg2);
18553     } catch (std::out_of_range& e) {
18554       {
18555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18556       };
18557     } catch (std::exception& e) {
18558       {
18559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18560       };
18561     } catch (...) {
18562       {
18563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18564       };
18565     }
18566   }
18567 }
18568
18569
18570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18571   int jresult ;
18572   Dali::Property::Index result;
18573
18574   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18575   jresult = result;
18576   return jresult;
18577 }
18578
18579
18580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18581   void * jresult ;
18582   Dali::Handle result;
18583
18584   {
18585     try {
18586       result = Dali::WeightObject::New();
18587     } catch (std::out_of_range& e) {
18588       {
18589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18590       };
18591     } catch (std::exception& e) {
18592       {
18593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18594       };
18595     } catch (...) {
18596       {
18597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18598       };
18599     }
18600   }
18601   jresult = new Dali::Handle((const Dali::Handle &)result);
18602   return jresult;
18603 }
18604
18605
18606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18607   void * jresult ;
18608   Dali::TypeInfo *result = 0 ;
18609
18610   {
18611     try {
18612       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18613     } catch (std::out_of_range& e) {
18614       {
18615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18616       };
18617     } catch (std::exception& e) {
18618       {
18619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18620       };
18621     } catch (...) {
18622       {
18623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18624       };
18625     }
18626   }
18627   jresult = (void *)result;
18628   return jresult;
18629 }
18630
18631
18632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18633   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18634
18635   arg1 = (Dali::TypeInfo *)jarg1;
18636   {
18637     try {
18638       delete arg1;
18639     } catch (std::out_of_range& e) {
18640       {
18641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18642       };
18643     } catch (std::exception& e) {
18644       {
18645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18646       };
18647     } catch (...) {
18648       {
18649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18650       };
18651     }
18652   }
18653 }
18654
18655
18656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18657   void * jresult ;
18658   Dali::TypeInfo *arg1 = 0 ;
18659   Dali::TypeInfo *result = 0 ;
18660
18661   arg1 = (Dali::TypeInfo *)jarg1;
18662   if (!arg1) {
18663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18664     return 0;
18665   }
18666   {
18667     try {
18668       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18669     } catch (std::out_of_range& e) {
18670       {
18671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18672       };
18673     } catch (std::exception& e) {
18674       {
18675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18676       };
18677     } catch (...) {
18678       {
18679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18680       };
18681     }
18682   }
18683   jresult = (void *)result;
18684   return jresult;
18685 }
18686
18687
18688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18689   void * jresult ;
18690   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18691   Dali::TypeInfo *arg2 = 0 ;
18692   Dali::TypeInfo *result = 0 ;
18693
18694   arg1 = (Dali::TypeInfo *)jarg1;
18695   arg2 = (Dali::TypeInfo *)jarg2;
18696   if (!arg2) {
18697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18698     return 0;
18699   }
18700   {
18701     try {
18702       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18703     } catch (std::out_of_range& e) {
18704       {
18705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18706       };
18707     } catch (std::exception& e) {
18708       {
18709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18710       };
18711     } catch (...) {
18712       {
18713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18714       };
18715     }
18716   }
18717   jresult = (void *)result;
18718   return jresult;
18719 }
18720
18721
18722 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18723   char * jresult ;
18724   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18725   std::string *result = 0 ;
18726
18727   arg1 = (Dali::TypeInfo *)jarg1;
18728   {
18729     try {
18730       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18731     } catch (std::out_of_range& e) {
18732       {
18733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18734       };
18735     } catch (std::exception& e) {
18736       {
18737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18738       };
18739     } catch (...) {
18740       {
18741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18742       };
18743     }
18744   }
18745   jresult = SWIG_csharp_string_callback(result->c_str());
18746   return jresult;
18747 }
18748
18749
18750 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18751   char * jresult ;
18752   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18753   std::string *result = 0 ;
18754
18755   arg1 = (Dali::TypeInfo *)jarg1;
18756   {
18757     try {
18758       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18759     } catch (std::out_of_range& e) {
18760       {
18761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18762       };
18763     } catch (std::exception& e) {
18764       {
18765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18766       };
18767     } catch (...) {
18768       {
18769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18770       };
18771     }
18772   }
18773   jresult = SWIG_csharp_string_callback(result->c_str());
18774   return jresult;
18775 }
18776
18777
18778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18779   void * jresult ;
18780   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18781   Dali::BaseHandle result;
18782
18783   arg1 = (Dali::TypeInfo *)jarg1;
18784   {
18785     try {
18786       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18787     } catch (std::out_of_range& e) {
18788       {
18789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18790       };
18791     } catch (std::exception& e) {
18792       {
18793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18794       };
18795     } catch (...) {
18796       {
18797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18798       };
18799     }
18800   }
18801   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18802   return jresult;
18803 }
18804
18805
18806 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18807   unsigned long jresult ;
18808   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18809   size_t result;
18810
18811   arg1 = (Dali::TypeInfo *)jarg1;
18812   {
18813     try {
18814       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18815     } catch (std::out_of_range& e) {
18816       {
18817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18818       };
18819     } catch (std::exception& e) {
18820       {
18821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18822       };
18823     } catch (...) {
18824       {
18825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18826       };
18827     }
18828   }
18829   jresult = (unsigned long)result;
18830   return jresult;
18831 }
18832
18833
18834 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18835   char * jresult ;
18836   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18837   size_t arg2 ;
18838   std::string result;
18839
18840   arg1 = (Dali::TypeInfo *)jarg1;
18841   arg2 = (size_t)jarg2;
18842   {
18843     try {
18844       result = (arg1)->GetActionName(arg2);
18845     } catch (std::out_of_range& e) {
18846       {
18847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18848       };
18849     } catch (std::exception& e) {
18850       {
18851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18852       };
18853     } catch (...) {
18854       {
18855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18856       };
18857     }
18858   }
18859   jresult = SWIG_csharp_string_callback((&result)->c_str());
18860   return jresult;
18861 }
18862
18863
18864 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18865   unsigned long jresult ;
18866   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18867   size_t result;
18868
18869   arg1 = (Dali::TypeInfo *)jarg1;
18870   {
18871     try {
18872       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18873     } catch (std::out_of_range& e) {
18874       {
18875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18876       };
18877     } catch (std::exception& e) {
18878       {
18879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18880       };
18881     } catch (...) {
18882       {
18883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18884       };
18885     }
18886   }
18887   jresult = (unsigned long)result;
18888   return jresult;
18889 }
18890
18891
18892 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18893   char * jresult ;
18894   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18895   size_t arg2 ;
18896   std::string result;
18897
18898   arg1 = (Dali::TypeInfo *)jarg1;
18899   arg2 = (size_t)jarg2;
18900   {
18901     try {
18902       result = (arg1)->GetSignalName(arg2);
18903     } catch (std::out_of_range& e) {
18904       {
18905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18906       };
18907     } catch (std::exception& e) {
18908       {
18909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18910       };
18911     } catch (...) {
18912       {
18913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18914       };
18915     }
18916   }
18917   jresult = SWIG_csharp_string_callback((&result)->c_str());
18918   return jresult;
18919 }
18920
18921
18922 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18923   unsigned long jresult ;
18924   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18925   size_t result;
18926
18927   arg1 = (Dali::TypeInfo *)jarg1;
18928   {
18929     try {
18930       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18931     } catch (std::out_of_range& e) {
18932       {
18933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18934       };
18935     } catch (std::exception& e) {
18936       {
18937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18938       };
18939     } catch (...) {
18940       {
18941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18942       };
18943     }
18944   }
18945   jresult = (unsigned long)result;
18946   return jresult;
18947 }
18948
18949
18950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18951   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18952   Dali::Property::IndexContainer *arg2 = 0 ;
18953
18954   arg1 = (Dali::TypeInfo *)jarg1;
18955   arg2 = (Dali::Property::IndexContainer *)jarg2;
18956   if (!arg2) {
18957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18958     return ;
18959   }
18960   {
18961     try {
18962       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18963     } catch (std::out_of_range& e) {
18964       {
18965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18966       };
18967     } catch (std::exception& e) {
18968       {
18969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18970       };
18971     } catch (...) {
18972       {
18973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18974       };
18975     }
18976   }
18977 }
18978
18979
18980 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18981   char * jresult ;
18982   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18983   Dali::Property::Index arg2 ;
18984   std::string *result = 0 ;
18985
18986   arg1 = (Dali::TypeInfo *)jarg1;
18987   arg2 = (Dali::Property::Index)jarg2;
18988   {
18989     try {
18990       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18991     } catch (std::out_of_range& e) {
18992       {
18993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18994       };
18995     } catch (std::exception& e) {
18996       {
18997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18998       };
18999     } catch (...) {
19000       {
19001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19002       };
19003     }
19004   }
19005   jresult = SWIG_csharp_string_callback(result->c_str());
19006   return jresult;
19007 }
19008
19009
19010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
19011   void * jresult ;
19012   Dali::TypeRegistry result;
19013
19014   {
19015     try {
19016       result = Dali::TypeRegistry::Get();
19017     } catch (std::out_of_range& e) {
19018       {
19019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19020       };
19021     } catch (std::exception& e) {
19022       {
19023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19024       };
19025     } catch (...) {
19026       {
19027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19028       };
19029     }
19030   }
19031   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19032   return jresult;
19033 }
19034
19035
19036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
19037   void * jresult ;
19038   Dali::TypeRegistry *result = 0 ;
19039
19040   {
19041     try {
19042       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19043     } catch (std::out_of_range& e) {
19044       {
19045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19046       };
19047     } catch (std::exception& e) {
19048       {
19049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19050       };
19051     } catch (...) {
19052       {
19053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19054       };
19055     }
19056   }
19057   jresult = (void *)result;
19058   return jresult;
19059 }
19060
19061
19062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19063   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19064
19065   arg1 = (Dali::TypeRegistry *)jarg1;
19066   {
19067     try {
19068       delete arg1;
19069     } catch (std::out_of_range& e) {
19070       {
19071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19072       };
19073     } catch (std::exception& e) {
19074       {
19075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19076       };
19077     } catch (...) {
19078       {
19079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19080       };
19081     }
19082   }
19083 }
19084
19085
19086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19087   void * jresult ;
19088   Dali::TypeRegistry *arg1 = 0 ;
19089   Dali::TypeRegistry *result = 0 ;
19090
19091   arg1 = (Dali::TypeRegistry *)jarg1;
19092   if (!arg1) {
19093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19094     return 0;
19095   }
19096   {
19097     try {
19098       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19099     } catch (std::out_of_range& e) {
19100       {
19101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19102       };
19103     } catch (std::exception& e) {
19104       {
19105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19106       };
19107     } catch (...) {
19108       {
19109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19110       };
19111     }
19112   }
19113   jresult = (void *)result;
19114   return jresult;
19115 }
19116
19117
19118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19119   void * jresult ;
19120   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19121   Dali::TypeRegistry *arg2 = 0 ;
19122   Dali::TypeRegistry *result = 0 ;
19123
19124   arg1 = (Dali::TypeRegistry *)jarg1;
19125   arg2 = (Dali::TypeRegistry *)jarg2;
19126   if (!arg2) {
19127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19128     return 0;
19129   }
19130   {
19131     try {
19132       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19133     } catch (std::out_of_range& e) {
19134       {
19135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19136       };
19137     } catch (std::exception& e) {
19138       {
19139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19140       };
19141     } catch (...) {
19142       {
19143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19144       };
19145     }
19146   }
19147   jresult = (void *)result;
19148   return jresult;
19149 }
19150
19151
19152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19153   void * jresult ;
19154   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19155   std::string *arg2 = 0 ;
19156   Dali::TypeInfo result;
19157
19158   arg1 = (Dali::TypeRegistry *)jarg1;
19159   if (!jarg2) {
19160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19161     return 0;
19162   }
19163   std::string arg2_str(jarg2);
19164   arg2 = &arg2_str;
19165   {
19166     try {
19167       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19168     } catch (std::out_of_range& e) {
19169       {
19170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19171       };
19172     } catch (std::exception& e) {
19173       {
19174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19175       };
19176     } catch (...) {
19177       {
19178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19179       };
19180     }
19181   }
19182   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19183
19184   //argout typemap for const std::string&
19185
19186   return jresult;
19187 }
19188
19189
19190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19191   void * jresult ;
19192   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19193   std::type_info *arg2 = 0 ;
19194   Dali::TypeInfo result;
19195
19196   arg1 = (Dali::TypeRegistry *)jarg1;
19197   arg2 = (std::type_info *)jarg2;
19198   if (!arg2) {
19199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19200     return 0;
19201   }
19202   {
19203     try {
19204       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19205     } catch (std::out_of_range& e) {
19206       {
19207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19208       };
19209     } catch (std::exception& e) {
19210       {
19211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19212       };
19213     } catch (...) {
19214       {
19215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19216       };
19217     }
19218   }
19219   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19220   return jresult;
19221 }
19222
19223
19224 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19225   unsigned long jresult ;
19226   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19227   size_t result;
19228
19229   arg1 = (Dali::TypeRegistry *)jarg1;
19230   {
19231     try {
19232       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19233     } catch (std::out_of_range& e) {
19234       {
19235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19236       };
19237     } catch (std::exception& e) {
19238       {
19239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19240       };
19241     } catch (...) {
19242       {
19243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19244       };
19245     }
19246   }
19247   jresult = (unsigned long)result;
19248   return jresult;
19249 }
19250
19251
19252 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19253   char * jresult ;
19254   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19255   size_t arg2 ;
19256   std::string result;
19257
19258   arg1 = (Dali::TypeRegistry *)jarg1;
19259   arg2 = (size_t)jarg2;
19260   {
19261     try {
19262       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19263     } catch (std::out_of_range& e) {
19264       {
19265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19266       };
19267     } catch (std::exception& e) {
19268       {
19269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19270       };
19271     } catch (...) {
19272       {
19273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19274       };
19275     }
19276   }
19277   jresult = SWIG_csharp_string_callback((&result)->c_str());
19278   return jresult;
19279 }
19280
19281
19282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19283   void * jresult ;
19284   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19285   Dali::TypeRegistry *result = 0 ;
19286
19287   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19288   {
19289     try {
19290       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19291     } catch (std::out_of_range& e) {
19292       {
19293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19294       };
19295     } catch (std::exception& e) {
19296       {
19297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19298       };
19299     } catch (...) {
19300       {
19301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19302       };
19303     }
19304   }
19305   jresult = (void *)result;
19306   return jresult;
19307 }
19308
19309
19310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19311   void * jresult ;
19312   std::type_info *arg1 = 0 ;
19313   std::type_info *arg2 = 0 ;
19314   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19315   Dali::TypeRegistration *result = 0 ;
19316
19317   arg1 = (std::type_info *)jarg1;
19318   if (!arg1) {
19319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19320     return 0;
19321   }
19322   arg2 = (std::type_info *)jarg2;
19323   if (!arg2) {
19324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19325     return 0;
19326   }
19327   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19328   {
19329     try {
19330       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19331     } catch (std::out_of_range& e) {
19332       {
19333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19334       };
19335     } catch (std::exception& e) {
19336       {
19337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19338       };
19339     } catch (...) {
19340       {
19341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19342       };
19343     }
19344   }
19345   jresult = (void *)result;
19346   return jresult;
19347 }
19348
19349
19350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19351   void * jresult ;
19352   std::type_info *arg1 = 0 ;
19353   std::type_info *arg2 = 0 ;
19354   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19355   bool arg4 ;
19356   Dali::TypeRegistration *result = 0 ;
19357
19358   arg1 = (std::type_info *)jarg1;
19359   if (!arg1) {
19360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19361     return 0;
19362   }
19363   arg2 = (std::type_info *)jarg2;
19364   if (!arg2) {
19365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19366     return 0;
19367   }
19368   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19369   arg4 = jarg4 ? true : false;
19370   {
19371     try {
19372       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19373     } catch (std::out_of_range& e) {
19374       {
19375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19376       };
19377     } catch (std::exception& e) {
19378       {
19379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19380       };
19381     } catch (...) {
19382       {
19383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19384       };
19385     }
19386   }
19387   jresult = (void *)result;
19388   return jresult;
19389 }
19390
19391
19392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19393   void * jresult ;
19394   std::string *arg1 = 0 ;
19395   std::type_info *arg2 = 0 ;
19396   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19397   Dali::TypeRegistration *result = 0 ;
19398
19399   if (!jarg1) {
19400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19401     return 0;
19402   }
19403   std::string arg1_str(jarg1);
19404   arg1 = &arg1_str;
19405   arg2 = (std::type_info *)jarg2;
19406   if (!arg2) {
19407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19408     return 0;
19409   }
19410   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19411   {
19412     try {
19413       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19414     } catch (std::out_of_range& e) {
19415       {
19416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19417       };
19418     } catch (std::exception& e) {
19419       {
19420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19421       };
19422     } catch (...) {
19423       {
19424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19425       };
19426     }
19427   }
19428   jresult = (void *)result;
19429
19430   //argout typemap for const std::string&
19431
19432   return jresult;
19433 }
19434
19435
19436 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19437   char * jresult ;
19438   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19439   std::string result;
19440
19441   arg1 = (Dali::TypeRegistration *)jarg1;
19442   {
19443     try {
19444       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19445     } catch (std::out_of_range& e) {
19446       {
19447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19448       };
19449     } catch (std::exception& e) {
19450       {
19451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19452       };
19453     } catch (...) {
19454       {
19455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19456       };
19457     }
19458   }
19459   jresult = SWIG_csharp_string_callback((&result)->c_str());
19460   return jresult;
19461 }
19462
19463
19464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19465   std::string *arg1 = 0 ;
19466   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19467
19468   if (!jarg1) {
19469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19470     return ;
19471   }
19472   std::string arg1_str(jarg1);
19473   arg1 = &arg1_str;
19474   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19475   {
19476     try {
19477       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19478     } catch (std::out_of_range& e) {
19479       {
19480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19481       };
19482     } catch (std::exception& e) {
19483       {
19484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19485       };
19486     } catch (...) {
19487       {
19488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19489       };
19490     }
19491   }
19492
19493   //argout typemap for const std::string&
19494
19495 }
19496
19497
19498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19499   std::string *arg1 = 0 ;
19500   std::string *arg2 = 0 ;
19501   int arg3 ;
19502   Dali::Property::Type arg4 ;
19503   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19504   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19505
19506   if (!jarg1) {
19507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19508     return ;
19509   }
19510   std::string arg1_str(jarg1);
19511   arg1 = &arg1_str;
19512   if (!jarg2) {
19513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19514     return ;
19515   }
19516   std::string arg2_str(jarg2);
19517   arg2 = &arg2_str;
19518   arg3 = (int)jarg3;
19519   arg4 = (Dali::Property::Type)jarg4;
19520   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19521   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19522   {
19523     try {
19524       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19525     } catch (std::out_of_range& e) {
19526       {
19527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19528       };
19529     } catch (std::exception& e) {
19530       {
19531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19532       };
19533     } catch (...) {
19534       {
19535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19536       };
19537     }
19538   }
19539
19540   //argout typemap for const std::string&
19541
19542
19543   //argout typemap for const std::string&
19544
19545 }
19546
19547
19548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19549   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19550
19551   arg1 = (Dali::TypeRegistration *)jarg1;
19552   {
19553     try {
19554       delete arg1;
19555     } catch (std::out_of_range& e) {
19556       {
19557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19558       };
19559     } catch (std::exception& e) {
19560       {
19561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19562       };
19563     } catch (...) {
19564       {
19565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19566       };
19567     }
19568   }
19569 }
19570
19571
19572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19573   void * jresult ;
19574   Dali::TypeRegistration *arg1 = 0 ;
19575   std::string *arg2 = 0 ;
19576   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19577   Dali::SignalConnectorType *result = 0 ;
19578
19579   arg1 = (Dali::TypeRegistration *)jarg1;
19580   if (!arg1) {
19581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19582     return 0;
19583   }
19584   if (!jarg2) {
19585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19586     return 0;
19587   }
19588   std::string arg2_str(jarg2);
19589   arg2 = &arg2_str;
19590   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19591   {
19592     try {
19593       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19594     } catch (std::out_of_range& e) {
19595       {
19596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19597       };
19598     } catch (std::exception& e) {
19599       {
19600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19601       };
19602     } catch (...) {
19603       {
19604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19605       };
19606     }
19607   }
19608   jresult = (void *)result;
19609
19610   //argout typemap for const std::string&
19611
19612   return jresult;
19613 }
19614
19615
19616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19617   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19618
19619   arg1 = (Dali::SignalConnectorType *)jarg1;
19620   {
19621     try {
19622       delete arg1;
19623     } catch (std::out_of_range& e) {
19624       {
19625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19626       };
19627     } catch (std::exception& e) {
19628       {
19629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19630       };
19631     } catch (...) {
19632       {
19633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19634       };
19635     }
19636   }
19637 }
19638
19639
19640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19641   void * jresult ;
19642   Dali::TypeRegistration *arg1 = 0 ;
19643   std::string *arg2 = 0 ;
19644   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19645   Dali::TypeAction *result = 0 ;
19646
19647   arg1 = (Dali::TypeRegistration *)jarg1;
19648   if (!arg1) {
19649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19650     return 0;
19651   }
19652   if (!jarg2) {
19653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19654     return 0;
19655   }
19656   std::string arg2_str(jarg2);
19657   arg2 = &arg2_str;
19658   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19659   {
19660     try {
19661       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19662     } catch (std::out_of_range& e) {
19663       {
19664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19665       };
19666     } catch (std::exception& e) {
19667       {
19668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19669       };
19670     } catch (...) {
19671       {
19672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19673       };
19674     }
19675   }
19676   jresult = (void *)result;
19677
19678   //argout typemap for const std::string&
19679
19680   return jresult;
19681 }
19682
19683
19684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19685   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19686
19687   arg1 = (Dali::TypeAction *)jarg1;
19688   {
19689     try {
19690       delete arg1;
19691     } catch (std::out_of_range& e) {
19692       {
19693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19694       };
19695     } catch (std::exception& e) {
19696       {
19697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19698       };
19699     } catch (...) {
19700       {
19701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19702       };
19703     }
19704   }
19705 }
19706
19707
19708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19709   void * jresult ;
19710   Dali::TypeRegistration *arg1 = 0 ;
19711   std::string *arg2 = 0 ;
19712   Dali::Property::Index arg3 ;
19713   Dali::Property::Type arg4 ;
19714   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19715   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19716   Dali::PropertyRegistration *result = 0 ;
19717
19718   arg1 = (Dali::TypeRegistration *)jarg1;
19719   if (!arg1) {
19720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19721     return 0;
19722   }
19723   if (!jarg2) {
19724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19725     return 0;
19726   }
19727   std::string arg2_str(jarg2);
19728   arg2 = &arg2_str;
19729   arg3 = (Dali::Property::Index)jarg3;
19730   arg4 = (Dali::Property::Type)jarg4;
19731   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19732   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19733   {
19734     try {
19735       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19736     } catch (std::out_of_range& e) {
19737       {
19738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19739       };
19740     } catch (std::exception& e) {
19741       {
19742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19743       };
19744     } catch (...) {
19745       {
19746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19747       };
19748     }
19749   }
19750   jresult = (void *)result;
19751
19752   //argout typemap for const std::string&
19753
19754   return jresult;
19755 }
19756
19757
19758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19759   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19760
19761   arg1 = (Dali::PropertyRegistration *)jarg1;
19762   {
19763     try {
19764       delete arg1;
19765     } catch (std::out_of_range& e) {
19766       {
19767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19768       };
19769     } catch (std::exception& e) {
19770       {
19771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19772       };
19773     } catch (...) {
19774       {
19775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19776       };
19777     }
19778   }
19779 }
19780
19781
19782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19783   void * jresult ;
19784   Dali::TypeRegistration *arg1 = 0 ;
19785   std::string *arg2 = 0 ;
19786   Dali::Property::Index arg3 ;
19787   Dali::Property::Type arg4 ;
19788   Dali::AnimatablePropertyRegistration *result = 0 ;
19789
19790   arg1 = (Dali::TypeRegistration *)jarg1;
19791   if (!arg1) {
19792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19793     return 0;
19794   }
19795   if (!jarg2) {
19796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19797     return 0;
19798   }
19799   std::string arg2_str(jarg2);
19800   arg2 = &arg2_str;
19801   arg3 = (Dali::Property::Index)jarg3;
19802   arg4 = (Dali::Property::Type)jarg4;
19803   {
19804     try {
19805       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19806     } catch (std::out_of_range& e) {
19807       {
19808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19809       };
19810     } catch (std::exception& e) {
19811       {
19812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19813       };
19814     } catch (...) {
19815       {
19816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19817       };
19818     }
19819   }
19820   jresult = (void *)result;
19821
19822   //argout typemap for const std::string&
19823
19824   return jresult;
19825 }
19826
19827
19828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19829   void * jresult ;
19830   Dali::TypeRegistration *arg1 = 0 ;
19831   std::string *arg2 = 0 ;
19832   Dali::Property::Index arg3 ;
19833   Dali::Property::Value *arg4 = 0 ;
19834   Dali::AnimatablePropertyRegistration *result = 0 ;
19835
19836   arg1 = (Dali::TypeRegistration *)jarg1;
19837   if (!arg1) {
19838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19839     return 0;
19840   }
19841   if (!jarg2) {
19842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19843     return 0;
19844   }
19845   std::string arg2_str(jarg2);
19846   arg2 = &arg2_str;
19847   arg3 = (Dali::Property::Index)jarg3;
19848   arg4 = (Dali::Property::Value *)jarg4;
19849   if (!arg4) {
19850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19851     return 0;
19852   }
19853   {
19854     try {
19855       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19856     } catch (std::out_of_range& e) {
19857       {
19858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19859       };
19860     } catch (std::exception& e) {
19861       {
19862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19863       };
19864     } catch (...) {
19865       {
19866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19867       };
19868     }
19869   }
19870   jresult = (void *)result;
19871
19872   //argout typemap for const std::string&
19873
19874   return jresult;
19875 }
19876
19877
19878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19879   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19880
19881   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19882   {
19883     try {
19884       delete arg1;
19885     } catch (std::out_of_range& e) {
19886       {
19887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19888       };
19889     } catch (std::exception& e) {
19890       {
19891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19892       };
19893     } catch (...) {
19894       {
19895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19896       };
19897     }
19898   }
19899 }
19900
19901
19902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19903   void * jresult ;
19904   Dali::TypeRegistration *arg1 = 0 ;
19905   std::string *arg2 = 0 ;
19906   Dali::Property::Index arg3 ;
19907   Dali::Property::Index arg4 ;
19908   unsigned int arg5 ;
19909   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19910
19911   arg1 = (Dali::TypeRegistration *)jarg1;
19912   if (!arg1) {
19913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19914     return 0;
19915   }
19916   if (!jarg2) {
19917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19918     return 0;
19919   }
19920   std::string arg2_str(jarg2);
19921   arg2 = &arg2_str;
19922   arg3 = (Dali::Property::Index)jarg3;
19923   arg4 = (Dali::Property::Index)jarg4;
19924   arg5 = (unsigned int)jarg5;
19925   {
19926     try {
19927       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19928     } catch (std::out_of_range& e) {
19929       {
19930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19931       };
19932     } catch (std::exception& e) {
19933       {
19934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19935       };
19936     } catch (...) {
19937       {
19938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19939       };
19940     }
19941   }
19942   jresult = (void *)result;
19943
19944   //argout typemap for const std::string&
19945
19946   return jresult;
19947 }
19948
19949
19950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19951   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19952
19953   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19954   {
19955     try {
19956       delete arg1;
19957     } catch (std::out_of_range& e) {
19958       {
19959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19960       };
19961     } catch (std::exception& e) {
19962       {
19963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19964       };
19965     } catch (...) {
19966       {
19967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19968       };
19969     }
19970   }
19971 }
19972
19973
19974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19975   void * jresult ;
19976   Dali::TypeRegistration *arg1 = 0 ;
19977   std::string *arg2 = 0 ;
19978   Dali::Property::Index arg3 ;
19979   Dali::Property::Type arg4 ;
19980   Dali::ChildPropertyRegistration *result = 0 ;
19981
19982   arg1 = (Dali::TypeRegistration *)jarg1;
19983   if (!arg1) {
19984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19985     return 0;
19986   }
19987   if (!jarg2) {
19988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19989     return 0;
19990   }
19991   std::string arg2_str(jarg2);
19992   arg2 = &arg2_str;
19993   arg3 = (Dali::Property::Index)jarg3;
19994   arg4 = (Dali::Property::Type)jarg4;
19995   {
19996     try {
19997       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19998     } catch (std::out_of_range& e) {
19999       {
20000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20001       };
20002     } catch (std::exception& e) {
20003       {
20004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20005       };
20006     } catch (...) {
20007       {
20008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20009       };
20010     }
20011   }
20012   jresult = (void *)result;
20013
20014   //argout typemap for const std::string&
20015
20016   return jresult;
20017 }
20018
20019
20020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
20021   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
20022
20023   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
20024   {
20025     try {
20026       delete arg1;
20027     } catch (std::out_of_range& e) {
20028       {
20029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20030       };
20031     } catch (std::exception& e) {
20032       {
20033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20034       };
20035     } catch (...) {
20036       {
20037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20038       };
20039     }
20040   }
20041 }
20042
20043
20044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
20045   unsigned int jresult ;
20046   std::string *arg1 = 0 ;
20047   std::type_info *arg2 = 0 ;
20048   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
20049   bool result;
20050
20051   if (!jarg1) {
20052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20053     return 0;
20054   }
20055   std::string arg1_str(jarg1);
20056   arg1 = &arg1_str;
20057   arg2 = (std::type_info *)jarg2;
20058   if (!arg2) {
20059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20060     return 0;
20061   }
20062   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20063   {
20064     try {
20065       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20066     } catch (std::out_of_range& e) {
20067       {
20068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20069       };
20070     } catch (std::exception& e) {
20071       {
20072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20073       };
20074     } catch (...) {
20075       {
20076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20077       };
20078     }
20079   }
20080   jresult = result;
20081
20082   //argout typemap for const std::string&
20083
20084   return jresult;
20085 }
20086
20087
20088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20089   unsigned int jresult ;
20090   std::string *arg1 = 0 ;
20091   std::string *arg2 = 0 ;
20092   Dali::Property::Index arg3 ;
20093   Dali::Property::Type arg4 ;
20094   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20095   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20096   bool result;
20097
20098   if (!jarg1) {
20099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20100     return 0;
20101   }
20102   std::string arg1_str(jarg1);
20103   arg1 = &arg1_str;
20104   if (!jarg2) {
20105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20106     return 0;
20107   }
20108   std::string arg2_str(jarg2);
20109   arg2 = &arg2_str;
20110   arg3 = (Dali::Property::Index)jarg3;
20111   arg4 = (Dali::Property::Type)jarg4;
20112   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20113   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20114   {
20115     try {
20116       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20117     } catch (std::out_of_range& e) {
20118       {
20119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20120       };
20121     } catch (std::exception& e) {
20122       {
20123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20124       };
20125     } catch (...) {
20126       {
20127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20128       };
20129     }
20130   }
20131   jresult = result;
20132
20133   //argout typemap for const std::string&
20134
20135
20136   //argout typemap for const std::string&
20137
20138   return jresult;
20139 }
20140
20141
20142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20143   float jresult ;
20144   float result;
20145
20146   result = (float)(float)Dali::ParentOrigin::TOP;
20147   jresult = result;
20148   return jresult;
20149 }
20150
20151
20152 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20153   float jresult ;
20154   float result;
20155
20156   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20157   jresult = result;
20158   return jresult;
20159 }
20160
20161
20162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20163   float jresult ;
20164   float result;
20165
20166   result = (float)(float)Dali::ParentOrigin::LEFT;
20167   jresult = result;
20168   return jresult;
20169 }
20170
20171
20172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20173   float jresult ;
20174   float result;
20175
20176   result = (float)(float)Dali::ParentOrigin::RIGHT;
20177   jresult = result;
20178   return jresult;
20179 }
20180
20181
20182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20183   float jresult ;
20184   float result;
20185
20186   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20187   jresult = result;
20188   return jresult;
20189 }
20190
20191
20192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20193   void * jresult ;
20194   Dali::Vector3 *result = 0 ;
20195
20196   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20197   jresult = (void *)result;
20198   return jresult;
20199 }
20200
20201
20202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20203   void * jresult ;
20204   Dali::Vector3 *result = 0 ;
20205
20206   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20207   jresult = (void *)result;
20208   return jresult;
20209 }
20210
20211
20212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20213   void * jresult ;
20214   Dali::Vector3 *result = 0 ;
20215
20216   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20217   jresult = (void *)result;
20218   return jresult;
20219 }
20220
20221
20222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20223   void * jresult ;
20224   Dali::Vector3 *result = 0 ;
20225
20226   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20227   jresult = (void *)result;
20228   return jresult;
20229 }
20230
20231
20232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20233   void * jresult ;
20234   Dali::Vector3 *result = 0 ;
20235
20236   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20237   jresult = (void *)result;
20238   return jresult;
20239 }
20240
20241
20242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20243   void * jresult ;
20244   Dali::Vector3 *result = 0 ;
20245
20246   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20247   jresult = (void *)result;
20248   return jresult;
20249 }
20250
20251
20252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20253   void * jresult ;
20254   Dali::Vector3 *result = 0 ;
20255
20256   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20257   jresult = (void *)result;
20258   return jresult;
20259 }
20260
20261
20262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20263   void * jresult ;
20264   Dali::Vector3 *result = 0 ;
20265
20266   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20267   jresult = (void *)result;
20268   return jresult;
20269 }
20270
20271
20272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20273   void * jresult ;
20274   Dali::Vector3 *result = 0 ;
20275
20276   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20277   jresult = (void *)result;
20278   return jresult;
20279 }
20280
20281
20282 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20283   float jresult ;
20284   float result;
20285
20286   result = (float)(float)Dali::AnchorPoint::TOP;
20287   jresult = result;
20288   return jresult;
20289 }
20290
20291
20292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20293   float jresult ;
20294   float result;
20295
20296   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20297   jresult = result;
20298   return jresult;
20299 }
20300
20301
20302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20303   float jresult ;
20304   float result;
20305
20306   result = (float)(float)Dali::AnchorPoint::LEFT;
20307   jresult = result;
20308   return jresult;
20309 }
20310
20311
20312 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20313   float jresult ;
20314   float result;
20315
20316   result = (float)(float)Dali::AnchorPoint::RIGHT;
20317   jresult = result;
20318   return jresult;
20319 }
20320
20321
20322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20323   float jresult ;
20324   float result;
20325
20326   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20327   jresult = result;
20328   return jresult;
20329 }
20330
20331
20332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20333   void * jresult ;
20334   Dali::Vector3 *result = 0 ;
20335
20336   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20337   jresult = (void *)result;
20338   return jresult;
20339 }
20340
20341
20342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20343   void * jresult ;
20344   Dali::Vector3 *result = 0 ;
20345
20346   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20347   jresult = (void *)result;
20348   return jresult;
20349 }
20350
20351
20352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20353   void * jresult ;
20354   Dali::Vector3 *result = 0 ;
20355
20356   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20357   jresult = (void *)result;
20358   return jresult;
20359 }
20360
20361
20362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20363   void * jresult ;
20364   Dali::Vector3 *result = 0 ;
20365
20366   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20367   jresult = (void *)result;
20368   return jresult;
20369 }
20370
20371
20372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20373   void * jresult ;
20374   Dali::Vector3 *result = 0 ;
20375
20376   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20377   jresult = (void *)result;
20378   return jresult;
20379 }
20380
20381
20382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20383   void * jresult ;
20384   Dali::Vector3 *result = 0 ;
20385
20386   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20387   jresult = (void *)result;
20388   return jresult;
20389 }
20390
20391
20392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20393   void * jresult ;
20394   Dali::Vector3 *result = 0 ;
20395
20396   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20397   jresult = (void *)result;
20398   return jresult;
20399 }
20400
20401
20402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20403   void * jresult ;
20404   Dali::Vector3 *result = 0 ;
20405
20406   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20407   jresult = (void *)result;
20408   return jresult;
20409 }
20410
20411
20412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20413   void * jresult ;
20414   Dali::Vector3 *result = 0 ;
20415
20416   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20417   jresult = (void *)result;
20418   return jresult;
20419 }
20420
20421
20422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20423   void * jresult ;
20424   Dali::Vector4 *result = 0 ;
20425
20426   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20427   jresult = (void *)result;
20428   return jresult;
20429 }
20430
20431
20432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20433   void * jresult ;
20434   Dali::Vector4 *result = 0 ;
20435
20436   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20437   jresult = (void *)result;
20438   return jresult;
20439 }
20440
20441
20442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20443   void * jresult ;
20444   Dali::Vector4 *result = 0 ;
20445
20446   result = (Dali::Vector4 *)&Dali::Color::RED;
20447   jresult = (void *)result;
20448   return jresult;
20449 }
20450
20451
20452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20453   void * jresult ;
20454   Dali::Vector4 *result = 0 ;
20455
20456   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20457   jresult = (void *)result;
20458   return jresult;
20459 }
20460
20461
20462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20463   void * jresult ;
20464   Dali::Vector4 *result = 0 ;
20465
20466   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20467   jresult = (void *)result;
20468   return jresult;
20469 }
20470
20471
20472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20473   void * jresult ;
20474   Dali::Vector4 *result = 0 ;
20475
20476   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20477   jresult = (void *)result;
20478   return jresult;
20479 }
20480
20481
20482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20483   void * jresult ;
20484   Dali::Vector4 *result = 0 ;
20485
20486   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20487   jresult = (void *)result;
20488   return jresult;
20489 }
20490
20491
20492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20493   void * jresult ;
20494   Dali::Vector4 *result = 0 ;
20495
20496   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20497   jresult = (void *)result;
20498   return jresult;
20499 }
20500
20501
20502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20503   void * jresult ;
20504   Dali::Vector4 *result = 0 ;
20505
20506   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20507   jresult = (void *)result;
20508   return jresult;
20509 }
20510
20511
20512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20513   float jresult ;
20514   float result;
20515
20516   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20517   jresult = result;
20518   return jresult;
20519 }
20520
20521
20522 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20523   float jresult ;
20524   float result;
20525
20526   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20527   jresult = result;
20528   return jresult;
20529 }
20530
20531
20532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20533   float jresult ;
20534   float result;
20535
20536   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20537   jresult = result;
20538   return jresult;
20539 }
20540
20541
20542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20543   float jresult ;
20544   float result;
20545
20546   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20547   jresult = result;
20548   return jresult;
20549 }
20550
20551
20552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20553   float jresult ;
20554   float result;
20555
20556   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20557   jresult = result;
20558   return jresult;
20559 }
20560
20561
20562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20563   float jresult ;
20564   float result;
20565
20566   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20567   jresult = result;
20568   return jresult;
20569 }
20570
20571
20572 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20573   float jresult ;
20574   float result;
20575
20576   result = (float)(float)Dali::Math::PI;
20577   jresult = result;
20578   return jresult;
20579 }
20580
20581
20582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20583   float jresult ;
20584   float result;
20585
20586   result = (float)(float)Dali::Math::PI_2;
20587   jresult = result;
20588   return jresult;
20589 }
20590
20591
20592 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20593   float jresult ;
20594   float result;
20595
20596   result = (float)(float)Dali::Math::PI_4;
20597   jresult = result;
20598   return jresult;
20599 }
20600
20601
20602 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20603   float jresult ;
20604   float result;
20605
20606   result = (float)(float)Dali::Math::PI_OVER_180;
20607   jresult = result;
20608   return jresult;
20609 }
20610
20611
20612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20613   float jresult ;
20614   float result;
20615
20616   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20617   jresult = result;
20618   return jresult;
20619 }
20620
20621
20622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20623   int jresult ;
20624   Dali::ResizePolicy::Type result;
20625
20626   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20627   jresult = (int)result;
20628   return jresult;
20629 }
20630
20631
20632 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20633   unsigned long jresult ;
20634   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20635   Dali::VectorBase::SizeType result;
20636
20637   arg1 = (Dali::VectorBase *)jarg1;
20638   {
20639     try {
20640       result = ((Dali::VectorBase const *)arg1)->Count();
20641     } catch (std::out_of_range& e) {
20642       {
20643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20644       };
20645     } catch (std::exception& e) {
20646       {
20647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20648       };
20649     } catch (...) {
20650       {
20651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20652       };
20653     }
20654   }
20655   jresult = (unsigned long)result;
20656   return jresult;
20657 }
20658
20659
20660 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20661   unsigned long jresult ;
20662   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20663   Dali::VectorBase::SizeType result;
20664
20665   arg1 = (Dali::VectorBase *)jarg1;
20666   {
20667     try {
20668       result = ((Dali::VectorBase const *)arg1)->Size();
20669     } catch (std::out_of_range& e) {
20670       {
20671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20672       };
20673     } catch (std::exception& e) {
20674       {
20675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20676       };
20677     } catch (...) {
20678       {
20679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20680       };
20681     }
20682   }
20683   jresult = (unsigned long)result;
20684   return jresult;
20685 }
20686
20687
20688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20689   unsigned int jresult ;
20690   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20691   bool result;
20692
20693   arg1 = (Dali::VectorBase *)jarg1;
20694   {
20695     try {
20696       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20697     } catch (std::out_of_range& e) {
20698       {
20699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20700       };
20701     } catch (std::exception& e) {
20702       {
20703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20704       };
20705     } catch (...) {
20706       {
20707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20708       };
20709     }
20710   }
20711   jresult = result;
20712   return jresult;
20713 }
20714
20715
20716 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20717   unsigned long jresult ;
20718   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20719   Dali::VectorBase::SizeType result;
20720
20721   arg1 = (Dali::VectorBase *)jarg1;
20722   {
20723     try {
20724       result = ((Dali::VectorBase const *)arg1)->Capacity();
20725     } catch (std::out_of_range& e) {
20726       {
20727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20728       };
20729     } catch (std::exception& e) {
20730       {
20731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20732       };
20733     } catch (...) {
20734       {
20735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20736       };
20737     }
20738   }
20739   jresult = (unsigned long)result;
20740   return jresult;
20741 }
20742
20743
20744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20745   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20746
20747   arg1 = (Dali::VectorBase *)jarg1;
20748   {
20749     try {
20750       (arg1)->Release();
20751     } catch (std::out_of_range& e) {
20752       {
20753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20754       };
20755     } catch (std::exception& e) {
20756       {
20757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20758       };
20759     } catch (...) {
20760       {
20761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20762       };
20763     }
20764   }
20765 }
20766
20767
20768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20769   void * jresult ;
20770   Dali::Image *result = 0 ;
20771
20772   {
20773     try {
20774       result = (Dali::Image *)new Dali::Image();
20775     } catch (std::out_of_range& e) {
20776       {
20777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20778       };
20779     } catch (std::exception& e) {
20780       {
20781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20782       };
20783     } catch (...) {
20784       {
20785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20786       };
20787     }
20788   }
20789   jresult = (void *)result;
20790   return jresult;
20791 }
20792
20793
20794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20795   Dali::Image *arg1 = (Dali::Image *) 0 ;
20796
20797   arg1 = (Dali::Image *)jarg1;
20798   {
20799     try {
20800       delete arg1;
20801     } catch (std::out_of_range& e) {
20802       {
20803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20804       };
20805     } catch (std::exception& e) {
20806       {
20807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20808       };
20809     } catch (...) {
20810       {
20811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20812       };
20813     }
20814   }
20815 }
20816
20817
20818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20819   void * jresult ;
20820   Dali::Image *arg1 = 0 ;
20821   Dali::Image *result = 0 ;
20822
20823   arg1 = (Dali::Image *)jarg1;
20824   if (!arg1) {
20825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20826     return 0;
20827   }
20828   {
20829     try {
20830       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20831     } catch (std::out_of_range& e) {
20832       {
20833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20834       };
20835     } catch (std::exception& e) {
20836       {
20837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20838       };
20839     } catch (...) {
20840       {
20841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20842       };
20843     }
20844   }
20845   jresult = (void *)result;
20846   return jresult;
20847 }
20848
20849
20850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20851   void * jresult ;
20852   Dali::Image *arg1 = (Dali::Image *) 0 ;
20853   Dali::Image *arg2 = 0 ;
20854   Dali::Image *result = 0 ;
20855
20856   arg1 = (Dali::Image *)jarg1;
20857   arg2 = (Dali::Image *)jarg2;
20858   if (!arg2) {
20859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20860     return 0;
20861   }
20862   {
20863     try {
20864       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20865     } catch (std::out_of_range& e) {
20866       {
20867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20868       };
20869     } catch (std::exception& e) {
20870       {
20871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20872       };
20873     } catch (...) {
20874       {
20875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20876       };
20877     }
20878   }
20879   jresult = (void *)result;
20880   return jresult;
20881 }
20882
20883
20884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20885   void * jresult ;
20886   Dali::BaseHandle arg1 ;
20887   Dali::BaseHandle *argp1 ;
20888   Dali::Image result;
20889
20890   argp1 = (Dali::BaseHandle *)jarg1;
20891   if (!argp1) {
20892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20893     return 0;
20894   }
20895   arg1 = *argp1;
20896   {
20897     try {
20898       result = Dali::Image::DownCast(arg1);
20899     } catch (std::out_of_range& e) {
20900       {
20901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20902       };
20903     } catch (std::exception& e) {
20904       {
20905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20906       };
20907     } catch (...) {
20908       {
20909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20910       };
20911     }
20912   }
20913   jresult = new Dali::Image((const Dali::Image &)result);
20914   return jresult;
20915 }
20916
20917
20918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20919   unsigned int jresult ;
20920   Dali::Image *arg1 = (Dali::Image *) 0 ;
20921   unsigned int result;
20922
20923   arg1 = (Dali::Image *)jarg1;
20924   {
20925     try {
20926       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20927     } catch (std::out_of_range& e) {
20928       {
20929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20930       };
20931     } catch (std::exception& e) {
20932       {
20933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20934       };
20935     } catch (...) {
20936       {
20937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20938       };
20939     }
20940   }
20941   jresult = result;
20942   return jresult;
20943 }
20944
20945
20946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20947   unsigned int jresult ;
20948   Dali::Image *arg1 = (Dali::Image *) 0 ;
20949   unsigned int result;
20950
20951   arg1 = (Dali::Image *)jarg1;
20952   {
20953     try {
20954       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20955     } catch (std::out_of_range& e) {
20956       {
20957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20958       };
20959     } catch (std::exception& e) {
20960       {
20961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20962       };
20963     } catch (...) {
20964       {
20965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20966       };
20967     }
20968   }
20969   jresult = result;
20970   return jresult;
20971 }
20972
20973
20974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20975   void * jresult ;
20976   Dali::Image *arg1 = (Dali::Image *) 0 ;
20977   Dali::Image::ImageSignalType *result = 0 ;
20978
20979   arg1 = (Dali::Image *)jarg1;
20980   {
20981     try {
20982       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20983     } catch (std::out_of_range& e) {
20984       {
20985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20986       };
20987     } catch (std::exception& e) {
20988       {
20989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20990       };
20991     } catch (...) {
20992       {
20993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20994       };
20995     }
20996   }
20997   jresult = (void *)result;
20998   return jresult;
20999 }
21000
21001
21002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
21003   int jresult ;
21004   Dali::Pixel::Format result;
21005
21006   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
21007   jresult = (int)result;
21008   return jresult;
21009 }
21010
21011
21012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
21013   int jresult ;
21014   Dali::Pixel::Format result;
21015
21016   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
21017   jresult = (int)result;
21018   return jresult;
21019 }
21020
21021
21022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
21023   unsigned int jresult ;
21024   Dali::Pixel::Format arg1 ;
21025   bool result;
21026
21027   arg1 = (Dali::Pixel::Format)jarg1;
21028   {
21029     try {
21030       result = (bool)Dali::Pixel::HasAlpha(arg1);
21031     } catch (std::out_of_range& e) {
21032       {
21033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21034       };
21035     } catch (std::exception& e) {
21036       {
21037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21038       };
21039     } catch (...) {
21040       {
21041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21042       };
21043     }
21044   }
21045   jresult = result;
21046   return jresult;
21047 }
21048
21049
21050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
21051   unsigned int jresult ;
21052   Dali::Pixel::Format arg1 ;
21053   unsigned int result;
21054
21055   arg1 = (Dali::Pixel::Format)jarg1;
21056   {
21057     try {
21058       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21059     } catch (std::out_of_range& e) {
21060       {
21061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21062       };
21063     } catch (std::exception& e) {
21064       {
21065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21066       };
21067     } catch (...) {
21068       {
21069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21070       };
21071     }
21072   }
21073   jresult = result;
21074   return jresult;
21075 }
21076
21077
21078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21079   Dali::Pixel::Format arg1 ;
21080   int *arg2 = 0 ;
21081   int *arg3 = 0 ;
21082
21083   arg1 = (Dali::Pixel::Format)jarg1;
21084   arg2 = (int *)jarg2;
21085   if (!arg2) {
21086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21087     return ;
21088   }
21089   arg3 = (int *)jarg3;
21090   if (!arg3) {
21091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21092     return ;
21093   }
21094   {
21095     try {
21096       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21097     } catch (std::out_of_range& e) {
21098       {
21099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21100       };
21101     } catch (std::exception& e) {
21102       {
21103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21104       };
21105     } catch (...) {
21106       {
21107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21108       };
21109     }
21110   }
21111 }
21112
21113
21114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21115   void * jresult ;
21116   unsigned char *arg1 = (unsigned char *) 0 ;
21117   unsigned int arg2 ;
21118   unsigned int arg3 ;
21119   unsigned int arg4 ;
21120   Dali::Pixel::Format arg5 ;
21121   Dali::PixelData::ReleaseFunction arg6 ;
21122   Dali::PixelData result;
21123
21124   arg1 = jarg1;
21125   arg2 = (unsigned int)jarg2;
21126   arg3 = (unsigned int)jarg3;
21127   arg4 = (unsigned int)jarg4;
21128   arg5 = (Dali::Pixel::Format)jarg5;
21129   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21130   {
21131     try {
21132       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21133     } catch (std::out_of_range& e) {
21134       {
21135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21136       };
21137     } catch (std::exception& e) {
21138       {
21139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21140       };
21141     } catch (...) {
21142       {
21143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21144       };
21145     }
21146   }
21147   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21148
21149
21150   return jresult;
21151 }
21152
21153
21154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21155   void * jresult ;
21156   Dali::PixelData *result = 0 ;
21157
21158   {
21159     try {
21160       result = (Dali::PixelData *)new Dali::PixelData();
21161     } catch (std::out_of_range& e) {
21162       {
21163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21164       };
21165     } catch (std::exception& e) {
21166       {
21167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21168       };
21169     } catch (...) {
21170       {
21171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21172       };
21173     }
21174   }
21175   jresult = (void *)result;
21176   return jresult;
21177 }
21178
21179
21180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21181   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21182
21183   arg1 = (Dali::PixelData *)jarg1;
21184   {
21185     try {
21186       delete arg1;
21187     } catch (std::out_of_range& e) {
21188       {
21189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21190       };
21191     } catch (std::exception& e) {
21192       {
21193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21194       };
21195     } catch (...) {
21196       {
21197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21198       };
21199     }
21200   }
21201 }
21202
21203
21204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21205   void * jresult ;
21206   Dali::PixelData *arg1 = 0 ;
21207   Dali::PixelData *result = 0 ;
21208
21209   arg1 = (Dali::PixelData *)jarg1;
21210   if (!arg1) {
21211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21212     return 0;
21213   }
21214   {
21215     try {
21216       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21217     } catch (std::out_of_range& e) {
21218       {
21219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21220       };
21221     } catch (std::exception& e) {
21222       {
21223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21224       };
21225     } catch (...) {
21226       {
21227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21228       };
21229     }
21230   }
21231   jresult = (void *)result;
21232   return jresult;
21233 }
21234
21235
21236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21237   void * jresult ;
21238   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21239   Dali::PixelData *arg2 = 0 ;
21240   Dali::PixelData *result = 0 ;
21241
21242   arg1 = (Dali::PixelData *)jarg1;
21243   arg2 = (Dali::PixelData *)jarg2;
21244   if (!arg2) {
21245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21246     return 0;
21247   }
21248   {
21249     try {
21250       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21251     } catch (std::out_of_range& e) {
21252       {
21253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21254       };
21255     } catch (std::exception& e) {
21256       {
21257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21258       };
21259     } catch (...) {
21260       {
21261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21262       };
21263     }
21264   }
21265   jresult = (void *)result;
21266   return jresult;
21267 }
21268
21269
21270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21271   unsigned int jresult ;
21272   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21273   unsigned int result;
21274
21275   arg1 = (Dali::PixelData *)jarg1;
21276   {
21277     try {
21278       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21279     } catch (std::out_of_range& e) {
21280       {
21281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21282       };
21283     } catch (std::exception& e) {
21284       {
21285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21286       };
21287     } catch (...) {
21288       {
21289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21290       };
21291     }
21292   }
21293   jresult = result;
21294   return jresult;
21295 }
21296
21297
21298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21299   unsigned int jresult ;
21300   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21301   unsigned int result;
21302
21303   arg1 = (Dali::PixelData *)jarg1;
21304   {
21305     try {
21306       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21307     } catch (std::out_of_range& e) {
21308       {
21309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21310       };
21311     } catch (std::exception& e) {
21312       {
21313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21314       };
21315     } catch (...) {
21316       {
21317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21318       };
21319     }
21320   }
21321   jresult = result;
21322   return jresult;
21323 }
21324
21325
21326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21327   int jresult ;
21328   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21329   Dali::Pixel::Format result;
21330
21331   arg1 = (Dali::PixelData *)jarg1;
21332   {
21333     try {
21334       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21335     } catch (std::out_of_range& e) {
21336       {
21337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21338       };
21339     } catch (std::exception& e) {
21340       {
21341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21342       };
21343     } catch (...) {
21344       {
21345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21346       };
21347     }
21348   }
21349   jresult = (int)result;
21350   return jresult;
21351 }
21352
21353
21354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21355   unsigned int jresult ;
21356   unsigned int result;
21357
21358   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21359   jresult = result;
21360   return jresult;
21361 }
21362
21363
21364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21365   unsigned int jresult ;
21366   unsigned int result;
21367
21368   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21369   jresult = result;
21370   return jresult;
21371 }
21372
21373
21374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21375   unsigned int jresult ;
21376   unsigned int result;
21377
21378   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21379   jresult = result;
21380   return jresult;
21381 }
21382
21383
21384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21385   unsigned int jresult ;
21386   unsigned int result;
21387
21388   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21389   jresult = result;
21390   return jresult;
21391 }
21392
21393
21394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21395   unsigned int jresult ;
21396   unsigned int result;
21397
21398   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21399   jresult = result;
21400   return jresult;
21401 }
21402
21403
21404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21405   unsigned int jresult ;
21406   unsigned int result;
21407
21408   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21409   jresult = result;
21410   return jresult;
21411 }
21412
21413
21414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21415   void * jresult ;
21416   Dali::TextureType::Type arg1 ;
21417   Dali::Pixel::Format arg2 ;
21418   unsigned int arg3 ;
21419   unsigned int arg4 ;
21420   Dali::Texture result;
21421
21422   arg1 = (Dali::TextureType::Type)jarg1;
21423   arg2 = (Dali::Pixel::Format)jarg2;
21424   arg3 = (unsigned int)jarg3;
21425   arg4 = (unsigned int)jarg4;
21426   {
21427     try {
21428       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21429     } catch (std::out_of_range& e) {
21430       {
21431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21432       };
21433     } catch (std::exception& e) {
21434       {
21435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21436       };
21437     } catch (...) {
21438       {
21439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21440       };
21441     }
21442   }
21443   jresult = new Dali::Texture((const Dali::Texture &)result);
21444   return jresult;
21445 }
21446
21447
21448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21449   void * jresult ;
21450   NativeImageInterface *arg1 = 0 ;
21451   Dali::Texture result;
21452
21453   arg1 = (NativeImageInterface *)jarg1;
21454   if (!arg1) {
21455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21456     return 0;
21457   }
21458   {
21459     try {
21460       result = Dali::Texture::New(*arg1);
21461     } catch (std::out_of_range& e) {
21462       {
21463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21464       };
21465     } catch (std::exception& e) {
21466       {
21467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21468       };
21469     } catch (...) {
21470       {
21471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21472       };
21473     }
21474   }
21475   jresult = new Dali::Texture((const Dali::Texture &)result);
21476   return jresult;
21477 }
21478
21479
21480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21481   void * jresult ;
21482   Dali::Texture *result = 0 ;
21483
21484   {
21485     try {
21486       result = (Dali::Texture *)new Dali::Texture();
21487     } catch (std::out_of_range& e) {
21488       {
21489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21490       };
21491     } catch (std::exception& e) {
21492       {
21493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21494       };
21495     } catch (...) {
21496       {
21497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21498       };
21499     }
21500   }
21501   jresult = (void *)result;
21502   return jresult;
21503 }
21504
21505
21506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21507   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21508
21509   arg1 = (Dali::Texture *)jarg1;
21510   {
21511     try {
21512       delete arg1;
21513     } catch (std::out_of_range& e) {
21514       {
21515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21516       };
21517     } catch (std::exception& e) {
21518       {
21519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21520       };
21521     } catch (...) {
21522       {
21523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21524       };
21525     }
21526   }
21527 }
21528
21529
21530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21531   void * jresult ;
21532   Dali::Texture *arg1 = 0 ;
21533   Dali::Texture *result = 0 ;
21534
21535   arg1 = (Dali::Texture *)jarg1;
21536   if (!arg1) {
21537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21538     return 0;
21539   }
21540   {
21541     try {
21542       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21543     } catch (std::out_of_range& e) {
21544       {
21545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21546       };
21547     } catch (std::exception& e) {
21548       {
21549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21550       };
21551     } catch (...) {
21552       {
21553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21554       };
21555     }
21556   }
21557   jresult = (void *)result;
21558   return jresult;
21559 }
21560
21561
21562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21563   void * jresult ;
21564   Dali::BaseHandle arg1 ;
21565   Dali::BaseHandle *argp1 ;
21566   Dali::Texture result;
21567
21568   argp1 = (Dali::BaseHandle *)jarg1;
21569   if (!argp1) {
21570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21571     return 0;
21572   }
21573   arg1 = *argp1;
21574   {
21575     try {
21576       result = Dali::Texture::DownCast(arg1);
21577     } catch (std::out_of_range& e) {
21578       {
21579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21580       };
21581     } catch (std::exception& e) {
21582       {
21583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21584       };
21585     } catch (...) {
21586       {
21587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21588       };
21589     }
21590   }
21591   jresult = new Dali::Texture((const Dali::Texture &)result);
21592   return jresult;
21593 }
21594
21595
21596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21597   void * jresult ;
21598   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21599   Dali::Texture *arg2 = 0 ;
21600   Dali::Texture *result = 0 ;
21601
21602   arg1 = (Dali::Texture *)jarg1;
21603   arg2 = (Dali::Texture *)jarg2;
21604   if (!arg2) {
21605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21606     return 0;
21607   }
21608   {
21609     try {
21610       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21611     } catch (std::out_of_range& e) {
21612       {
21613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21614       };
21615     } catch (std::exception& e) {
21616       {
21617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21618       };
21619     } catch (...) {
21620       {
21621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21622       };
21623     }
21624   }
21625   jresult = (void *)result;
21626   return jresult;
21627 }
21628
21629
21630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21631   unsigned int jresult ;
21632   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21633   Dali::PixelData arg2 ;
21634   Dali::PixelData *argp2 ;
21635   bool result;
21636
21637   arg1 = (Dali::Texture *)jarg1;
21638   argp2 = (Dali::PixelData *)jarg2;
21639   if (!argp2) {
21640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21641     return 0;
21642   }
21643   arg2 = *argp2;
21644   {
21645     try {
21646       result = (bool)(arg1)->Upload(arg2);
21647     } catch (std::out_of_range& e) {
21648       {
21649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21650       };
21651     } catch (std::exception& e) {
21652       {
21653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21654       };
21655     } catch (...) {
21656       {
21657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21658       };
21659     }
21660   }
21661   jresult = result;
21662   return jresult;
21663 }
21664
21665
21666 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) {
21667   unsigned int jresult ;
21668   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21669   Dali::PixelData arg2 ;
21670   unsigned int arg3 ;
21671   unsigned int arg4 ;
21672   unsigned int arg5 ;
21673   unsigned int arg6 ;
21674   unsigned int arg7 ;
21675   unsigned int arg8 ;
21676   Dali::PixelData *argp2 ;
21677   bool result;
21678
21679   arg1 = (Dali::Texture *)jarg1;
21680   argp2 = (Dali::PixelData *)jarg2;
21681   if (!argp2) {
21682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21683     return 0;
21684   }
21685   arg2 = *argp2;
21686   arg3 = (unsigned int)jarg3;
21687   arg4 = (unsigned int)jarg4;
21688   arg5 = (unsigned int)jarg5;
21689   arg6 = (unsigned int)jarg6;
21690   arg7 = (unsigned int)jarg7;
21691   arg8 = (unsigned int)jarg8;
21692   {
21693     try {
21694       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21695     } catch (std::out_of_range& e) {
21696       {
21697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21698       };
21699     } catch (std::exception& e) {
21700       {
21701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21702       };
21703     } catch (...) {
21704       {
21705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21706       };
21707     }
21708   }
21709   jresult = result;
21710   return jresult;
21711 }
21712
21713
21714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21715   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21716
21717   arg1 = (Dali::Texture *)jarg1;
21718   {
21719     try {
21720       (arg1)->GenerateMipmaps();
21721     } catch (std::out_of_range& e) {
21722       {
21723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21724       };
21725     } catch (std::exception& e) {
21726       {
21727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21728       };
21729     } catch (...) {
21730       {
21731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21732       };
21733     }
21734   }
21735 }
21736
21737
21738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21739   unsigned int jresult ;
21740   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21741   unsigned int result;
21742
21743   arg1 = (Dali::Texture *)jarg1;
21744   {
21745     try {
21746       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21747     } catch (std::out_of_range& e) {
21748       {
21749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21750       };
21751     } catch (std::exception& e) {
21752       {
21753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21754       };
21755     } catch (...) {
21756       {
21757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21758       };
21759     }
21760   }
21761   jresult = result;
21762   return jresult;
21763 }
21764
21765
21766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21767   unsigned int jresult ;
21768   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21769   unsigned int result;
21770
21771   arg1 = (Dali::Texture *)jarg1;
21772   {
21773     try {
21774       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21775     } catch (std::out_of_range& e) {
21776       {
21777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21778       };
21779     } catch (std::exception& e) {
21780       {
21781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21782       };
21783     } catch (...) {
21784       {
21785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21786       };
21787     }
21788   }
21789   jresult = result;
21790   return jresult;
21791 }
21792
21793
21794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21795   void * jresult ;
21796   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21797   Dali::Texture *result = 0 ;
21798
21799   arg1 = (Dali::Internal::Texture *)jarg1;
21800   {
21801     try {
21802       result = (Dali::Texture *)new Dali::Texture(arg1);
21803     } catch (std::out_of_range& e) {
21804       {
21805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21806       };
21807     } catch (std::exception& e) {
21808       {
21809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21810       };
21811     } catch (...) {
21812       {
21813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21814       };
21815     }
21816   }
21817   jresult = (void *)result;
21818   return jresult;
21819 }
21820
21821
21822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21823   void * jresult ;
21824   Dali::Sampler result;
21825
21826   {
21827     try {
21828       result = Dali::Sampler::New();
21829     } catch (std::out_of_range& e) {
21830       {
21831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21832       };
21833     } catch (std::exception& e) {
21834       {
21835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21836       };
21837     } catch (...) {
21838       {
21839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21840       };
21841     }
21842   }
21843   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21844   return jresult;
21845 }
21846
21847
21848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21849   void * jresult ;
21850   Dali::Sampler *result = 0 ;
21851
21852   {
21853     try {
21854       result = (Dali::Sampler *)new Dali::Sampler();
21855     } catch (std::out_of_range& e) {
21856       {
21857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21858       };
21859     } catch (std::exception& e) {
21860       {
21861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21862       };
21863     } catch (...) {
21864       {
21865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21866       };
21867     }
21868   }
21869   jresult = (void *)result;
21870   return jresult;
21871 }
21872
21873
21874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21875   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21876
21877   arg1 = (Dali::Sampler *)jarg1;
21878   {
21879     try {
21880       delete arg1;
21881     } catch (std::out_of_range& e) {
21882       {
21883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21884       };
21885     } catch (std::exception& e) {
21886       {
21887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21888       };
21889     } catch (...) {
21890       {
21891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21892       };
21893     }
21894   }
21895 }
21896
21897
21898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21899   void * jresult ;
21900   Dali::Sampler *arg1 = 0 ;
21901   Dali::Sampler *result = 0 ;
21902
21903   arg1 = (Dali::Sampler *)jarg1;
21904   if (!arg1) {
21905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21906     return 0;
21907   }
21908   {
21909     try {
21910       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21911     } catch (std::out_of_range& e) {
21912       {
21913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21914       };
21915     } catch (std::exception& e) {
21916       {
21917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21918       };
21919     } catch (...) {
21920       {
21921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21922       };
21923     }
21924   }
21925   jresult = (void *)result;
21926   return jresult;
21927 }
21928
21929
21930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21931   void * jresult ;
21932   Dali::BaseHandle arg1 ;
21933   Dali::BaseHandle *argp1 ;
21934   Dali::Sampler result;
21935
21936   argp1 = (Dali::BaseHandle *)jarg1;
21937   if (!argp1) {
21938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21939     return 0;
21940   }
21941   arg1 = *argp1;
21942   {
21943     try {
21944       result = Dali::Sampler::DownCast(arg1);
21945     } catch (std::out_of_range& e) {
21946       {
21947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21948       };
21949     } catch (std::exception& e) {
21950       {
21951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21952       };
21953     } catch (...) {
21954       {
21955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21956       };
21957     }
21958   }
21959   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21960   return jresult;
21961 }
21962
21963
21964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21965   void * jresult ;
21966   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21967   Dali::Sampler *arg2 = 0 ;
21968   Dali::Sampler *result = 0 ;
21969
21970   arg1 = (Dali::Sampler *)jarg1;
21971   arg2 = (Dali::Sampler *)jarg2;
21972   if (!arg2) {
21973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21974     return 0;
21975   }
21976   {
21977     try {
21978       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21979     } catch (std::out_of_range& e) {
21980       {
21981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21982       };
21983     } catch (std::exception& e) {
21984       {
21985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21986       };
21987     } catch (...) {
21988       {
21989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21990       };
21991     }
21992   }
21993   jresult = (void *)result;
21994   return jresult;
21995 }
21996
21997
21998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21999   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22000   Dali::FilterMode::Type arg2 ;
22001   Dali::FilterMode::Type arg3 ;
22002
22003   arg1 = (Dali::Sampler *)jarg1;
22004   arg2 = (Dali::FilterMode::Type)jarg2;
22005   arg3 = (Dali::FilterMode::Type)jarg3;
22006   {
22007     try {
22008       (arg1)->SetFilterMode(arg2,arg3);
22009     } catch (std::out_of_range& e) {
22010       {
22011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22012       };
22013     } catch (std::exception& e) {
22014       {
22015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22016       };
22017     } catch (...) {
22018       {
22019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22020       };
22021     }
22022   }
22023 }
22024
22025
22026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
22027   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22028   Dali::WrapMode::Type arg2 ;
22029   Dali::WrapMode::Type arg3 ;
22030
22031   arg1 = (Dali::Sampler *)jarg1;
22032   arg2 = (Dali::WrapMode::Type)jarg2;
22033   arg3 = (Dali::WrapMode::Type)jarg3;
22034   {
22035     try {
22036       (arg1)->SetWrapMode(arg2,arg3);
22037     } catch (std::out_of_range& e) {
22038       {
22039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22040       };
22041     } catch (std::exception& e) {
22042       {
22043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22044       };
22045     } catch (...) {
22046       {
22047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22048       };
22049     }
22050   }
22051 }
22052
22053
22054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
22055   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22056   Dali::WrapMode::Type arg2 ;
22057   Dali::WrapMode::Type arg3 ;
22058   Dali::WrapMode::Type arg4 ;
22059
22060   arg1 = (Dali::Sampler *)jarg1;
22061   arg2 = (Dali::WrapMode::Type)jarg2;
22062   arg3 = (Dali::WrapMode::Type)jarg3;
22063   arg4 = (Dali::WrapMode::Type)jarg4;
22064   {
22065     try {
22066       (arg1)->SetWrapMode(arg2,arg3,arg4);
22067     } catch (std::out_of_range& e) {
22068       {
22069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22070       };
22071     } catch (std::exception& e) {
22072       {
22073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22074       };
22075     } catch (...) {
22076       {
22077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22078       };
22079     }
22080   }
22081 }
22082
22083
22084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22085   void * jresult ;
22086   Dali::TextureSet result;
22087
22088   {
22089     try {
22090       result = Dali::TextureSet::New();
22091     } catch (std::out_of_range& e) {
22092       {
22093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22094       };
22095     } catch (std::exception& e) {
22096       {
22097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22098       };
22099     } catch (...) {
22100       {
22101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22102       };
22103     }
22104   }
22105   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22106   return jresult;
22107 }
22108
22109
22110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22111   void * jresult ;
22112   Dali::TextureSet *result = 0 ;
22113
22114   {
22115     try {
22116       result = (Dali::TextureSet *)new Dali::TextureSet();
22117     } catch (std::out_of_range& e) {
22118       {
22119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22120       };
22121     } catch (std::exception& e) {
22122       {
22123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22124       };
22125     } catch (...) {
22126       {
22127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22128       };
22129     }
22130   }
22131   jresult = (void *)result;
22132   return jresult;
22133 }
22134
22135
22136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22137   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22138
22139   arg1 = (Dali::TextureSet *)jarg1;
22140   {
22141     try {
22142       delete arg1;
22143     } catch (std::out_of_range& e) {
22144       {
22145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22146       };
22147     } catch (std::exception& e) {
22148       {
22149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22150       };
22151     } catch (...) {
22152       {
22153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22154       };
22155     }
22156   }
22157 }
22158
22159
22160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22161   void * jresult ;
22162   Dali::TextureSet *arg1 = 0 ;
22163   Dali::TextureSet *result = 0 ;
22164
22165   arg1 = (Dali::TextureSet *)jarg1;
22166   if (!arg1) {
22167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22168     return 0;
22169   }
22170   {
22171     try {
22172       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22173     } catch (std::out_of_range& e) {
22174       {
22175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22176       };
22177     } catch (std::exception& e) {
22178       {
22179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22180       };
22181     } catch (...) {
22182       {
22183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22184       };
22185     }
22186   }
22187   jresult = (void *)result;
22188   return jresult;
22189 }
22190
22191
22192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22193   void * jresult ;
22194   Dali::BaseHandle arg1 ;
22195   Dali::BaseHandle *argp1 ;
22196   Dali::TextureSet result;
22197
22198   argp1 = (Dali::BaseHandle *)jarg1;
22199   if (!argp1) {
22200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22201     return 0;
22202   }
22203   arg1 = *argp1;
22204   {
22205     try {
22206       result = Dali::TextureSet::DownCast(arg1);
22207     } catch (std::out_of_range& e) {
22208       {
22209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22210       };
22211     } catch (std::exception& e) {
22212       {
22213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22214       };
22215     } catch (...) {
22216       {
22217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22218       };
22219     }
22220   }
22221   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22222   return jresult;
22223 }
22224
22225
22226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22227   void * jresult ;
22228   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22229   Dali::TextureSet *arg2 = 0 ;
22230   Dali::TextureSet *result = 0 ;
22231
22232   arg1 = (Dali::TextureSet *)jarg1;
22233   arg2 = (Dali::TextureSet *)jarg2;
22234   if (!arg2) {
22235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22236     return 0;
22237   }
22238   {
22239     try {
22240       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22241     } catch (std::out_of_range& e) {
22242       {
22243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22244       };
22245     } catch (std::exception& e) {
22246       {
22247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22248       };
22249     } catch (...) {
22250       {
22251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22252       };
22253     }
22254   }
22255   jresult = (void *)result;
22256   return jresult;
22257 }
22258
22259
22260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22261   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22262   size_t arg2 ;
22263   Dali::Texture arg3 ;
22264   Dali::Texture *argp3 ;
22265
22266   arg1 = (Dali::TextureSet *)jarg1;
22267   arg2 = (size_t)jarg2;
22268   argp3 = (Dali::Texture *)jarg3;
22269   if (!argp3) {
22270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22271     return ;
22272   }
22273   arg3 = *argp3;
22274   {
22275     try {
22276       (arg1)->SetTexture(arg2,arg3);
22277     } catch (std::out_of_range& e) {
22278       {
22279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22280       };
22281     } catch (std::exception& e) {
22282       {
22283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22284       };
22285     } catch (...) {
22286       {
22287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22288       };
22289     }
22290   }
22291 }
22292
22293
22294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22295   void * jresult ;
22296   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22297   size_t arg2 ;
22298   Dali::Texture result;
22299
22300   arg1 = (Dali::TextureSet *)jarg1;
22301   arg2 = (size_t)jarg2;
22302   {
22303     try {
22304       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22305     } catch (std::out_of_range& e) {
22306       {
22307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22308       };
22309     } catch (std::exception& e) {
22310       {
22311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22312       };
22313     } catch (...) {
22314       {
22315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22316       };
22317     }
22318   }
22319   jresult = new Dali::Texture((const Dali::Texture &)result);
22320   return jresult;
22321 }
22322
22323
22324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22325   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22326   size_t arg2 ;
22327   Dali::Sampler arg3 ;
22328   Dali::Sampler *argp3 ;
22329
22330   arg1 = (Dali::TextureSet *)jarg1;
22331   arg2 = (size_t)jarg2;
22332   argp3 = (Dali::Sampler *)jarg3;
22333   if (!argp3) {
22334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22335     return ;
22336   }
22337   arg3 = *argp3;
22338   {
22339     try {
22340       (arg1)->SetSampler(arg2,arg3);
22341     } catch (std::out_of_range& e) {
22342       {
22343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22344       };
22345     } catch (std::exception& e) {
22346       {
22347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22348       };
22349     } catch (...) {
22350       {
22351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22352       };
22353     }
22354   }
22355 }
22356
22357
22358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22359   void * jresult ;
22360   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22361   size_t arg2 ;
22362   Dali::Sampler result;
22363
22364   arg1 = (Dali::TextureSet *)jarg1;
22365   arg2 = (size_t)jarg2;
22366   {
22367     try {
22368       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22369     } catch (std::out_of_range& e) {
22370       {
22371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22372       };
22373     } catch (std::exception& e) {
22374       {
22375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22376       };
22377     } catch (...) {
22378       {
22379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22380       };
22381     }
22382   }
22383   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22384   return jresult;
22385 }
22386
22387
22388 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22389   unsigned long jresult ;
22390   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22391   size_t result;
22392
22393   arg1 = (Dali::TextureSet *)jarg1;
22394   {
22395     try {
22396       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22397     } catch (std::out_of_range& e) {
22398       {
22399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22400       };
22401     } catch (std::exception& e) {
22402       {
22403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22404       };
22405     } catch (...) {
22406       {
22407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22408       };
22409     }
22410   }
22411   jresult = (unsigned long)result;
22412   return jresult;
22413 }
22414
22415
22416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22417   void * jresult ;
22418   Dali::Property::Map *arg1 = 0 ;
22419   Dali::PropertyBuffer result;
22420
22421   arg1 = (Dali::Property::Map *)jarg1;
22422   if (!arg1) {
22423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22424     return 0;
22425   }
22426   {
22427     try {
22428       result = Dali::PropertyBuffer::New(*arg1);
22429     } catch (std::out_of_range& e) {
22430       {
22431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22432       };
22433     } catch (std::exception& e) {
22434       {
22435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22436       };
22437     } catch (...) {
22438       {
22439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22440       };
22441     }
22442   }
22443   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22444   return jresult;
22445 }
22446
22447
22448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22449   void * jresult ;
22450   Dali::PropertyBuffer *result = 0 ;
22451
22452   {
22453     try {
22454       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22455     } catch (std::out_of_range& e) {
22456       {
22457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22458       };
22459     } catch (std::exception& e) {
22460       {
22461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22462       };
22463     } catch (...) {
22464       {
22465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22466       };
22467     }
22468   }
22469   jresult = (void *)result;
22470   return jresult;
22471 }
22472
22473
22474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22475   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22476
22477   arg1 = (Dali::PropertyBuffer *)jarg1;
22478   {
22479     try {
22480       delete arg1;
22481     } catch (std::out_of_range& e) {
22482       {
22483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22484       };
22485     } catch (std::exception& e) {
22486       {
22487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22488       };
22489     } catch (...) {
22490       {
22491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22492       };
22493     }
22494   }
22495 }
22496
22497
22498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22499   void * jresult ;
22500   Dali::PropertyBuffer *arg1 = 0 ;
22501   Dali::PropertyBuffer *result = 0 ;
22502
22503   arg1 = (Dali::PropertyBuffer *)jarg1;
22504   if (!arg1) {
22505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22506     return 0;
22507   }
22508   {
22509     try {
22510       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22511     } catch (std::out_of_range& e) {
22512       {
22513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22514       };
22515     } catch (std::exception& e) {
22516       {
22517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22518       };
22519     } catch (...) {
22520       {
22521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22522       };
22523     }
22524   }
22525   jresult = (void *)result;
22526   return jresult;
22527 }
22528
22529
22530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22531   void * jresult ;
22532   Dali::BaseHandle arg1 ;
22533   Dali::BaseHandle *argp1 ;
22534   Dali::PropertyBuffer result;
22535
22536   argp1 = (Dali::BaseHandle *)jarg1;
22537   if (!argp1) {
22538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22539     return 0;
22540   }
22541   arg1 = *argp1;
22542   {
22543     try {
22544       result = Dali::PropertyBuffer::DownCast(arg1);
22545     } catch (std::out_of_range& e) {
22546       {
22547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22548       };
22549     } catch (std::exception& e) {
22550       {
22551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22552       };
22553     } catch (...) {
22554       {
22555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22556       };
22557     }
22558   }
22559   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22560   return jresult;
22561 }
22562
22563
22564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22565   void * jresult ;
22566   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22567   Dali::PropertyBuffer *arg2 = 0 ;
22568   Dali::PropertyBuffer *result = 0 ;
22569
22570   arg1 = (Dali::PropertyBuffer *)jarg1;
22571   arg2 = (Dali::PropertyBuffer *)jarg2;
22572   if (!arg2) {
22573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22574     return 0;
22575   }
22576   {
22577     try {
22578       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22579     } catch (std::out_of_range& e) {
22580       {
22581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22582       };
22583     } catch (std::exception& e) {
22584       {
22585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22586       };
22587     } catch (...) {
22588       {
22589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22590       };
22591     }
22592   }
22593   jresult = (void *)result;
22594   return jresult;
22595 }
22596
22597
22598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22599   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22600   void *arg2 = (void *) 0 ;
22601   std::size_t arg3 ;
22602
22603   arg1 = (Dali::PropertyBuffer *)jarg1;
22604   arg2 = jarg2;
22605   arg3 = (std::size_t)jarg3;
22606   {
22607     try {
22608       (arg1)->SetData((void const *)arg2,arg3);
22609     } catch (std::out_of_range& e) {
22610       {
22611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22612       };
22613     } catch (std::exception& e) {
22614       {
22615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22616       };
22617     } catch (...) {
22618       {
22619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22620       };
22621     }
22622   }
22623 }
22624
22625
22626 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22627   unsigned long jresult ;
22628   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22629   std::size_t result;
22630
22631   arg1 = (Dali::PropertyBuffer *)jarg1;
22632   {
22633     try {
22634       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22635     } catch (std::out_of_range& e) {
22636       {
22637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22638       };
22639     } catch (std::exception& e) {
22640       {
22641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22642       };
22643     } catch (...) {
22644       {
22645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22646       };
22647     }
22648   }
22649   jresult = (unsigned long)result;
22650   return jresult;
22651 }
22652
22653
22654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22655   void * jresult ;
22656   Dali::Geometry result;
22657
22658   {
22659     try {
22660       result = Dali::Geometry::New();
22661     } catch (std::out_of_range& e) {
22662       {
22663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22664       };
22665     } catch (std::exception& e) {
22666       {
22667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22668       };
22669     } catch (...) {
22670       {
22671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22672       };
22673     }
22674   }
22675   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22676   return jresult;
22677 }
22678
22679
22680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22681   void * jresult ;
22682   Dali::Geometry *result = 0 ;
22683
22684   {
22685     try {
22686       result = (Dali::Geometry *)new Dali::Geometry();
22687     } catch (std::out_of_range& e) {
22688       {
22689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22690       };
22691     } catch (std::exception& e) {
22692       {
22693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22694       };
22695     } catch (...) {
22696       {
22697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22698       };
22699     }
22700   }
22701   jresult = (void *)result;
22702   return jresult;
22703 }
22704
22705
22706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22707   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22708
22709   arg1 = (Dali::Geometry *)jarg1;
22710   {
22711     try {
22712       delete arg1;
22713     } catch (std::out_of_range& e) {
22714       {
22715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22716       };
22717     } catch (std::exception& e) {
22718       {
22719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22720       };
22721     } catch (...) {
22722       {
22723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22724       };
22725     }
22726   }
22727 }
22728
22729
22730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22731   void * jresult ;
22732   Dali::Geometry *arg1 = 0 ;
22733   Dali::Geometry *result = 0 ;
22734
22735   arg1 = (Dali::Geometry *)jarg1;
22736   if (!arg1) {
22737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22738     return 0;
22739   }
22740   {
22741     try {
22742       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22743     } catch (std::out_of_range& e) {
22744       {
22745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22746       };
22747     } catch (std::exception& e) {
22748       {
22749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22750       };
22751     } catch (...) {
22752       {
22753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22754       };
22755     }
22756   }
22757   jresult = (void *)result;
22758   return jresult;
22759 }
22760
22761
22762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22763   void * jresult ;
22764   Dali::BaseHandle arg1 ;
22765   Dali::BaseHandle *argp1 ;
22766   Dali::Geometry result;
22767
22768   argp1 = (Dali::BaseHandle *)jarg1;
22769   if (!argp1) {
22770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22771     return 0;
22772   }
22773   arg1 = *argp1;
22774   {
22775     try {
22776       result = Dali::Geometry::DownCast(arg1);
22777     } catch (std::out_of_range& e) {
22778       {
22779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22780       };
22781     } catch (std::exception& e) {
22782       {
22783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22784       };
22785     } catch (...) {
22786       {
22787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22788       };
22789     }
22790   }
22791   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22792   return jresult;
22793 }
22794
22795
22796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22797   void * jresult ;
22798   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22799   Dali::Geometry *arg2 = 0 ;
22800   Dali::Geometry *result = 0 ;
22801
22802   arg1 = (Dali::Geometry *)jarg1;
22803   arg2 = (Dali::Geometry *)jarg2;
22804   if (!arg2) {
22805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22806     return 0;
22807   }
22808   {
22809     try {
22810       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22811     } catch (std::out_of_range& e) {
22812       {
22813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22814       };
22815     } catch (std::exception& e) {
22816       {
22817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22818       };
22819     } catch (...) {
22820       {
22821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22822       };
22823     }
22824   }
22825   jresult = (void *)result;
22826   return jresult;
22827 }
22828
22829
22830 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22831   unsigned long jresult ;
22832   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22833   Dali::PropertyBuffer *arg2 = 0 ;
22834   std::size_t result;
22835
22836   arg1 = (Dali::Geometry *)jarg1;
22837   arg2 = (Dali::PropertyBuffer *)jarg2;
22838   if (!arg2) {
22839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22840     return 0;
22841   }
22842   {
22843     try {
22844       result = (arg1)->AddVertexBuffer(*arg2);
22845     } catch (std::out_of_range& e) {
22846       {
22847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22848       };
22849     } catch (std::exception& e) {
22850       {
22851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22852       };
22853     } catch (...) {
22854       {
22855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22856       };
22857     }
22858   }
22859   jresult = (unsigned long)result;
22860   return jresult;
22861 }
22862
22863
22864 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22865   unsigned long jresult ;
22866   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22867   std::size_t result;
22868
22869   arg1 = (Dali::Geometry *)jarg1;
22870   {
22871     try {
22872       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22873     } catch (std::out_of_range& e) {
22874       {
22875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22876       };
22877     } catch (std::exception& e) {
22878       {
22879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22880       };
22881     } catch (...) {
22882       {
22883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22884       };
22885     }
22886   }
22887   jresult = (unsigned long)result;
22888   return jresult;
22889 }
22890
22891
22892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22893   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22894   std::size_t arg2 ;
22895
22896   arg1 = (Dali::Geometry *)jarg1;
22897   arg2 = (std::size_t)jarg2;
22898   {
22899     try {
22900       (arg1)->RemoveVertexBuffer(arg2);
22901     } catch (std::out_of_range& e) {
22902       {
22903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22904       };
22905     } catch (std::exception& e) {
22906       {
22907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22908       };
22909     } catch (...) {
22910       {
22911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22912       };
22913     }
22914   }
22915 }
22916
22917
22918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22919   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22920   unsigned short *arg2 = (unsigned short *) 0 ;
22921   size_t arg3 ;
22922
22923   arg1 = (Dali::Geometry *)jarg1;
22924   arg2 = jarg2;
22925   arg3 = (size_t)jarg3;
22926   {
22927     try {
22928       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22929     } catch (std::out_of_range& e) {
22930       {
22931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22932       };
22933     } catch (std::exception& e) {
22934       {
22935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22936       };
22937     } catch (...) {
22938       {
22939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22940       };
22941     }
22942   }
22943
22944
22945 }
22946
22947
22948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22949   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22950   Dali::Geometry::Type arg2 ;
22951
22952   arg1 = (Dali::Geometry *)jarg1;
22953   arg2 = (Dali::Geometry::Type)jarg2;
22954   {
22955     try {
22956       (arg1)->SetType(arg2);
22957     } catch (std::out_of_range& e) {
22958       {
22959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22960       };
22961     } catch (std::exception& e) {
22962       {
22963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22964       };
22965     } catch (...) {
22966       {
22967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22968       };
22969     }
22970   }
22971 }
22972
22973
22974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22975   int jresult ;
22976   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22977   Dali::Geometry::Type result;
22978
22979   arg1 = (Dali::Geometry *)jarg1;
22980   {
22981     try {
22982       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22983     } catch (std::out_of_range& e) {
22984       {
22985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22986       };
22987     } catch (std::exception& e) {
22988       {
22989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22990       };
22991     } catch (...) {
22992       {
22993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22994       };
22995     }
22996   }
22997   jresult = (int)result;
22998   return jresult;
22999 }
23000
23001
23002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
23003   void * jresult ;
23004   Dali::Shader::Hint *result = 0 ;
23005
23006   {
23007     try {
23008       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
23009     } catch (std::out_of_range& e) {
23010       {
23011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23012       };
23013     } catch (std::exception& e) {
23014       {
23015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23016       };
23017     } catch (...) {
23018       {
23019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23020       };
23021     }
23022   }
23023   jresult = (void *)result;
23024   return jresult;
23025 }
23026
23027
23028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
23029   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
23030
23031   arg1 = (Dali::Shader::Hint *)jarg1;
23032   {
23033     try {
23034       delete arg1;
23035     } catch (std::out_of_range& e) {
23036       {
23037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23038       };
23039     } catch (std::exception& e) {
23040       {
23041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23042       };
23043     } catch (...) {
23044       {
23045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23046       };
23047     }
23048   }
23049 }
23050
23051
23052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
23053   int jresult ;
23054   int result;
23055
23056   result = (int)Dali::Shader::Property::PROGRAM;
23057   jresult = (int)result;
23058   return jresult;
23059 }
23060
23061
23062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23063   void * jresult ;
23064   Dali::Shader::Property *result = 0 ;
23065
23066   {
23067     try {
23068       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23069     } catch (std::out_of_range& e) {
23070       {
23071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23072       };
23073     } catch (std::exception& e) {
23074       {
23075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23076       };
23077     } catch (...) {
23078       {
23079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23080       };
23081     }
23082   }
23083   jresult = (void *)result;
23084   return jresult;
23085 }
23086
23087
23088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23089   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23090
23091   arg1 = (Dali::Shader::Property *)jarg1;
23092   {
23093     try {
23094       delete arg1;
23095     } catch (std::out_of_range& e) {
23096       {
23097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23098       };
23099     } catch (std::exception& e) {
23100       {
23101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23102       };
23103     } catch (...) {
23104       {
23105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23106       };
23107     }
23108   }
23109 }
23110
23111
23112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23113   void * jresult ;
23114   std::string *arg1 = 0 ;
23115   std::string *arg2 = 0 ;
23116   Dali::Shader::Hint::Value arg3 ;
23117   Dali::Shader result;
23118
23119   if (!jarg1) {
23120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23121     return 0;
23122   }
23123   std::string arg1_str(jarg1);
23124   arg1 = &arg1_str;
23125   if (!jarg2) {
23126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23127     return 0;
23128   }
23129   std::string arg2_str(jarg2);
23130   arg2 = &arg2_str;
23131   arg3 = (Dali::Shader::Hint::Value)jarg3;
23132   {
23133     try {
23134       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23135     } catch (std::out_of_range& e) {
23136       {
23137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23138       };
23139     } catch (std::exception& e) {
23140       {
23141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23142       };
23143     } catch (...) {
23144       {
23145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23146       };
23147     }
23148   }
23149   jresult = new Dali::Shader((const Dali::Shader &)result);
23150
23151   //argout typemap for const std::string&
23152
23153
23154   //argout typemap for const std::string&
23155
23156   return jresult;
23157 }
23158
23159
23160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23161   void * jresult ;
23162   std::string *arg1 = 0 ;
23163   std::string *arg2 = 0 ;
23164   Dali::Shader result;
23165
23166   if (!jarg1) {
23167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23168     return 0;
23169   }
23170   std::string arg1_str(jarg1);
23171   arg1 = &arg1_str;
23172   if (!jarg2) {
23173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23174     return 0;
23175   }
23176   std::string arg2_str(jarg2);
23177   arg2 = &arg2_str;
23178   {
23179     try {
23180       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23181     } catch (std::out_of_range& e) {
23182       {
23183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23184       };
23185     } catch (std::exception& e) {
23186       {
23187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23188       };
23189     } catch (...) {
23190       {
23191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23192       };
23193     }
23194   }
23195   jresult = new Dali::Shader((const Dali::Shader &)result);
23196
23197   //argout typemap for const std::string&
23198
23199
23200   //argout typemap for const std::string&
23201
23202   return jresult;
23203 }
23204
23205
23206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23207   void * jresult ;
23208   Dali::Shader *result = 0 ;
23209
23210   {
23211     try {
23212       result = (Dali::Shader *)new Dali::Shader();
23213     } catch (std::out_of_range& e) {
23214       {
23215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23216       };
23217     } catch (std::exception& e) {
23218       {
23219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23220       };
23221     } catch (...) {
23222       {
23223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23224       };
23225     }
23226   }
23227   jresult = (void *)result;
23228   return jresult;
23229 }
23230
23231
23232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23233   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23234
23235   arg1 = (Dali::Shader *)jarg1;
23236   {
23237     try {
23238       delete arg1;
23239     } catch (std::out_of_range& e) {
23240       {
23241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23242       };
23243     } catch (std::exception& e) {
23244       {
23245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23246       };
23247     } catch (...) {
23248       {
23249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23250       };
23251     }
23252   }
23253 }
23254
23255
23256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23257   void * jresult ;
23258   Dali::Shader *arg1 = 0 ;
23259   Dali::Shader *result = 0 ;
23260
23261   arg1 = (Dali::Shader *)jarg1;
23262   if (!arg1) {
23263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23264     return 0;
23265   }
23266   {
23267     try {
23268       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23269     } catch (std::out_of_range& e) {
23270       {
23271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23272       };
23273     } catch (std::exception& e) {
23274       {
23275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23276       };
23277     } catch (...) {
23278       {
23279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23280       };
23281     }
23282   }
23283   jresult = (void *)result;
23284   return jresult;
23285 }
23286
23287
23288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23289   void * jresult ;
23290   Dali::BaseHandle arg1 ;
23291   Dali::BaseHandle *argp1 ;
23292   Dali::Shader result;
23293
23294   argp1 = (Dali::BaseHandle *)jarg1;
23295   if (!argp1) {
23296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23297     return 0;
23298   }
23299   arg1 = *argp1;
23300   {
23301     try {
23302       result = Dali::Shader::DownCast(arg1);
23303     } catch (std::out_of_range& e) {
23304       {
23305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23306       };
23307     } catch (std::exception& e) {
23308       {
23309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23310       };
23311     } catch (...) {
23312       {
23313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23314       };
23315     }
23316   }
23317   jresult = new Dali::Shader((const Dali::Shader &)result);
23318   return jresult;
23319 }
23320
23321
23322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23323   void * jresult ;
23324   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23325   Dali::Shader *arg2 = 0 ;
23326   Dali::Shader *result = 0 ;
23327
23328   arg1 = (Dali::Shader *)jarg1;
23329   arg2 = (Dali::Shader *)jarg2;
23330   if (!arg2) {
23331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23332     return 0;
23333   }
23334   {
23335     try {
23336       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23337     } catch (std::out_of_range& e) {
23338       {
23339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23340       };
23341     } catch (std::exception& e) {
23342       {
23343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23344       };
23345     } catch (...) {
23346       {
23347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23348       };
23349     }
23350   }
23351   jresult = (void *)result;
23352   return jresult;
23353 }
23354
23355
23356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23357   int jresult ;
23358   int result;
23359
23360   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23361   jresult = (int)result;
23362   return jresult;
23363 }
23364
23365
23366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23367   int jresult ;
23368   int result;
23369
23370   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23371   jresult = (int)result;
23372   return jresult;
23373 }
23374
23375
23376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23377   int jresult ;
23378   int result;
23379
23380   result = (int)Dali::Renderer::Property::BLEND_MODE;
23381   jresult = (int)result;
23382   return jresult;
23383 }
23384
23385
23386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23387   int jresult ;
23388   int result;
23389
23390   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23391   jresult = (int)result;
23392   return jresult;
23393 }
23394
23395
23396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23397   int jresult ;
23398   int result;
23399
23400   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23401   jresult = (int)result;
23402   return jresult;
23403 }
23404
23405
23406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23407   int jresult ;
23408   int result;
23409
23410   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23411   jresult = (int)result;
23412   return jresult;
23413 }
23414
23415
23416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23417   int jresult ;
23418   int result;
23419
23420   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23421   jresult = (int)result;
23422   return jresult;
23423 }
23424
23425
23426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23427   int jresult ;
23428   int result;
23429
23430   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23431   jresult = (int)result;
23432   return jresult;
23433 }
23434
23435
23436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23437   int jresult ;
23438   int result;
23439
23440   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23441   jresult = (int)result;
23442   return jresult;
23443 }
23444
23445
23446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23447   int jresult ;
23448   int result;
23449
23450   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23451   jresult = (int)result;
23452   return jresult;
23453 }
23454
23455
23456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23457   int jresult ;
23458   int result;
23459
23460   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23461   jresult = (int)result;
23462   return jresult;
23463 }
23464
23465
23466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23467   int jresult ;
23468   int result;
23469
23470   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23471   jresult = (int)result;
23472   return jresult;
23473 }
23474
23475
23476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23477   int jresult ;
23478   int result;
23479
23480   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23481   jresult = (int)result;
23482   return jresult;
23483 }
23484
23485
23486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23487   int jresult ;
23488   int result;
23489
23490   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23491   jresult = (int)result;
23492   return jresult;
23493 }
23494
23495
23496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23497   int jresult ;
23498   int result;
23499
23500   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23501   jresult = (int)result;
23502   return jresult;
23503 }
23504
23505
23506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23507   int jresult ;
23508   int result;
23509
23510   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23511   jresult = (int)result;
23512   return jresult;
23513 }
23514
23515
23516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23517   int jresult ;
23518   int result;
23519
23520   result = (int)Dali::Renderer::Property::RENDER_MODE;
23521   jresult = (int)result;
23522   return jresult;
23523 }
23524
23525
23526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23527   int jresult ;
23528   int result;
23529
23530   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23531   jresult = (int)result;
23532   return jresult;
23533 }
23534
23535
23536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23537   int jresult ;
23538   int result;
23539
23540   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23541   jresult = (int)result;
23542   return jresult;
23543 }
23544
23545
23546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23547   int jresult ;
23548   int result;
23549
23550   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23551   jresult = (int)result;
23552   return jresult;
23553 }
23554
23555
23556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23557   int jresult ;
23558   int result;
23559
23560   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23561   jresult = (int)result;
23562   return jresult;
23563 }
23564
23565
23566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23567   int jresult ;
23568   int result;
23569
23570   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23571   jresult = (int)result;
23572   return jresult;
23573 }
23574
23575
23576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23577   int jresult ;
23578   int result;
23579
23580   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23581   jresult = (int)result;
23582   return jresult;
23583 }
23584
23585
23586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23587   int jresult ;
23588   int result;
23589
23590   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23591   jresult = (int)result;
23592   return jresult;
23593 }
23594
23595
23596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23597   void * jresult ;
23598   Dali::Renderer::Property *result = 0 ;
23599
23600   {
23601     try {
23602       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23603     } catch (std::out_of_range& e) {
23604       {
23605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23606       };
23607     } catch (std::exception& e) {
23608       {
23609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23610       };
23611     } catch (...) {
23612       {
23613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23614       };
23615     }
23616   }
23617   jresult = (void *)result;
23618   return jresult;
23619 }
23620
23621
23622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23623   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23624
23625   arg1 = (Dali::Renderer::Property *)jarg1;
23626   {
23627     try {
23628       delete arg1;
23629     } catch (std::out_of_range& e) {
23630       {
23631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23632       };
23633     } catch (std::exception& e) {
23634       {
23635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23636       };
23637     } catch (...) {
23638       {
23639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23640       };
23641     }
23642   }
23643 }
23644
23645
23646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23647   void * jresult ;
23648   Dali::Geometry *arg1 = 0 ;
23649   Dali::Shader *arg2 = 0 ;
23650   Dali::Renderer result;
23651
23652   arg1 = (Dali::Geometry *)jarg1;
23653   if (!arg1) {
23654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23655     return 0;
23656   }
23657   arg2 = (Dali::Shader *)jarg2;
23658   if (!arg2) {
23659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23660     return 0;
23661   }
23662   {
23663     try {
23664       result = Dali::Renderer::New(*arg1,*arg2);
23665     } catch (std::out_of_range& e) {
23666       {
23667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23668       };
23669     } catch (std::exception& e) {
23670       {
23671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23672       };
23673     } catch (...) {
23674       {
23675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23676       };
23677     }
23678   }
23679   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23680   return jresult;
23681 }
23682
23683
23684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23685   void * jresult ;
23686   Dali::Renderer *result = 0 ;
23687
23688   {
23689     try {
23690       result = (Dali::Renderer *)new Dali::Renderer();
23691     } catch (std::out_of_range& e) {
23692       {
23693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23694       };
23695     } catch (std::exception& e) {
23696       {
23697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23698       };
23699     } catch (...) {
23700       {
23701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23702       };
23703     }
23704   }
23705   jresult = (void *)result;
23706   return jresult;
23707 }
23708
23709
23710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23711   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23712
23713   arg1 = (Dali::Renderer *)jarg1;
23714   {
23715     try {
23716       delete arg1;
23717     } catch (std::out_of_range& e) {
23718       {
23719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23720       };
23721     } catch (std::exception& e) {
23722       {
23723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23724       };
23725     } catch (...) {
23726       {
23727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23728       };
23729     }
23730   }
23731 }
23732
23733
23734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23735   void * jresult ;
23736   Dali::Renderer *arg1 = 0 ;
23737   Dali::Renderer *result = 0 ;
23738
23739   arg1 = (Dali::Renderer *)jarg1;
23740   if (!arg1) {
23741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23742     return 0;
23743   }
23744   {
23745     try {
23746       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23747     } catch (std::out_of_range& e) {
23748       {
23749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23750       };
23751     } catch (std::exception& e) {
23752       {
23753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23754       };
23755     } catch (...) {
23756       {
23757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23758       };
23759     }
23760   }
23761   jresult = (void *)result;
23762   return jresult;
23763 }
23764
23765
23766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23767   void * jresult ;
23768   Dali::BaseHandle arg1 ;
23769   Dali::BaseHandle *argp1 ;
23770   Dali::Renderer result;
23771
23772   argp1 = (Dali::BaseHandle *)jarg1;
23773   if (!argp1) {
23774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23775     return 0;
23776   }
23777   arg1 = *argp1;
23778   {
23779     try {
23780       result = Dali::Renderer::DownCast(arg1);
23781     } catch (std::out_of_range& e) {
23782       {
23783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23784       };
23785     } catch (std::exception& e) {
23786       {
23787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23788       };
23789     } catch (...) {
23790       {
23791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23792       };
23793     }
23794   }
23795   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23796   return jresult;
23797 }
23798
23799
23800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23801   void * jresult ;
23802   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23803   Dali::Renderer *arg2 = 0 ;
23804   Dali::Renderer *result = 0 ;
23805
23806   arg1 = (Dali::Renderer *)jarg1;
23807   arg2 = (Dali::Renderer *)jarg2;
23808   if (!arg2) {
23809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23810     return 0;
23811   }
23812   {
23813     try {
23814       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23815     } catch (std::out_of_range& e) {
23816       {
23817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23818       };
23819     } catch (std::exception& e) {
23820       {
23821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23822       };
23823     } catch (...) {
23824       {
23825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23826       };
23827     }
23828   }
23829   jresult = (void *)result;
23830   return jresult;
23831 }
23832
23833
23834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23835   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23836   Dali::Geometry *arg2 = 0 ;
23837
23838   arg1 = (Dali::Renderer *)jarg1;
23839   arg2 = (Dali::Geometry *)jarg2;
23840   if (!arg2) {
23841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23842     return ;
23843   }
23844   {
23845     try {
23846       (arg1)->SetGeometry(*arg2);
23847     } catch (std::out_of_range& e) {
23848       {
23849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23850       };
23851     } catch (std::exception& e) {
23852       {
23853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23854       };
23855     } catch (...) {
23856       {
23857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23858       };
23859     }
23860   }
23861 }
23862
23863
23864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23865   void * jresult ;
23866   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23867   Dali::Geometry result;
23868
23869   arg1 = (Dali::Renderer *)jarg1;
23870   {
23871     try {
23872       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23873     } catch (std::out_of_range& e) {
23874       {
23875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23876       };
23877     } catch (std::exception& e) {
23878       {
23879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23880       };
23881     } catch (...) {
23882       {
23883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23884       };
23885     }
23886   }
23887   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23888   return jresult;
23889 }
23890
23891
23892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23893   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23894   int arg2 ;
23895   int arg3 ;
23896
23897   arg1 = (Dali::Renderer *)jarg1;
23898   arg2 = (int)jarg2;
23899   arg3 = (int)jarg3;
23900   {
23901     try {
23902       (arg1)->SetIndexRange(arg2,arg3);
23903     } catch (std::out_of_range& e) {
23904       {
23905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23906       };
23907     } catch (std::exception& e) {
23908       {
23909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23910       };
23911     } catch (...) {
23912       {
23913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23914       };
23915     }
23916   }
23917 }
23918
23919
23920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23921   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23922   Dali::TextureSet *arg2 = 0 ;
23923
23924   arg1 = (Dali::Renderer *)jarg1;
23925   arg2 = (Dali::TextureSet *)jarg2;
23926   if (!arg2) {
23927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23928     return ;
23929   }
23930   {
23931     try {
23932       (arg1)->SetTextures(*arg2);
23933     } catch (std::out_of_range& e) {
23934       {
23935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23936       };
23937     } catch (std::exception& e) {
23938       {
23939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23940       };
23941     } catch (...) {
23942       {
23943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23944       };
23945     }
23946   }
23947 }
23948
23949
23950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23951   void * jresult ;
23952   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23953   Dali::TextureSet result;
23954
23955   arg1 = (Dali::Renderer *)jarg1;
23956   {
23957     try {
23958       result = ((Dali::Renderer const *)arg1)->GetTextures();
23959     } catch (std::out_of_range& e) {
23960       {
23961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23962       };
23963     } catch (std::exception& e) {
23964       {
23965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23966       };
23967     } catch (...) {
23968       {
23969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23970       };
23971     }
23972   }
23973   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23974   return jresult;
23975 }
23976
23977
23978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23979   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23980   Dali::Shader *arg2 = 0 ;
23981
23982   arg1 = (Dali::Renderer *)jarg1;
23983   arg2 = (Dali::Shader *)jarg2;
23984   if (!arg2) {
23985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23986     return ;
23987   }
23988   {
23989     try {
23990       (arg1)->SetShader(*arg2);
23991     } catch (std::out_of_range& e) {
23992       {
23993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23994       };
23995     } catch (std::exception& e) {
23996       {
23997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23998       };
23999     } catch (...) {
24000       {
24001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24002       };
24003     }
24004   }
24005 }
24006
24007
24008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
24009   void * jresult ;
24010   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24011   Dali::Shader result;
24012
24013   arg1 = (Dali::Renderer *)jarg1;
24014   {
24015     try {
24016       result = ((Dali::Renderer const *)arg1)->GetShader();
24017     } catch (std::out_of_range& e) {
24018       {
24019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24020       };
24021     } catch (std::exception& e) {
24022       {
24023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24024       };
24025     } catch (...) {
24026       {
24027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24028       };
24029     }
24030   }
24031   jresult = new Dali::Shader((const Dali::Shader &)result);
24032   return jresult;
24033 }
24034
24035
24036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
24037   void * jresult ;
24038   Dali::FrameBuffer::Attachment *result = 0 ;
24039
24040   {
24041     try {
24042       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
24043     } catch (std::out_of_range& e) {
24044       {
24045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24046       };
24047     } catch (std::exception& e) {
24048       {
24049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24050       };
24051     } catch (...) {
24052       {
24053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24054       };
24055     }
24056   }
24057   jresult = (void *)result;
24058   return jresult;
24059 }
24060
24061
24062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24063   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24064
24065   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24066   {
24067     try {
24068       delete arg1;
24069     } catch (std::out_of_range& e) {
24070       {
24071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24072       };
24073     } catch (std::exception& e) {
24074       {
24075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24076       };
24077     } catch (...) {
24078       {
24079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24080       };
24081     }
24082   }
24083 }
24084
24085
24086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24087   void * jresult ;
24088   unsigned int arg1 ;
24089   unsigned int arg2 ;
24090   unsigned int arg3 ;
24091   Dali::FrameBuffer result;
24092
24093   arg1 = (unsigned int)jarg1;
24094   arg2 = (unsigned int)jarg2;
24095   arg3 = (unsigned int)jarg3;
24096   {
24097     try {
24098       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24099     } catch (std::out_of_range& e) {
24100       {
24101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24102       };
24103     } catch (std::exception& e) {
24104       {
24105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24106       };
24107     } catch (...) {
24108       {
24109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24110       };
24111     }
24112   }
24113   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24114   return jresult;
24115 }
24116
24117
24118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24119   void * jresult ;
24120   Dali::FrameBuffer *result = 0 ;
24121
24122   {
24123     try {
24124       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24125     } catch (std::out_of_range& e) {
24126       {
24127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24128       };
24129     } catch (std::exception& e) {
24130       {
24131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24132       };
24133     } catch (...) {
24134       {
24135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24136       };
24137     }
24138   }
24139   jresult = (void *)result;
24140   return jresult;
24141 }
24142
24143
24144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24145   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24146
24147   arg1 = (Dali::FrameBuffer *)jarg1;
24148   {
24149     try {
24150       delete arg1;
24151     } catch (std::out_of_range& e) {
24152       {
24153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24154       };
24155     } catch (std::exception& e) {
24156       {
24157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24158       };
24159     } catch (...) {
24160       {
24161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24162       };
24163     }
24164   }
24165 }
24166
24167
24168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24169   void * jresult ;
24170   Dali::FrameBuffer *arg1 = 0 ;
24171   Dali::FrameBuffer *result = 0 ;
24172
24173   arg1 = (Dali::FrameBuffer *)jarg1;
24174   if (!arg1) {
24175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24176     return 0;
24177   }
24178   {
24179     try {
24180       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24181     } catch (std::out_of_range& e) {
24182       {
24183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24184       };
24185     } catch (std::exception& e) {
24186       {
24187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24188       };
24189     } catch (...) {
24190       {
24191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24192       };
24193     }
24194   }
24195   jresult = (void *)result;
24196   return jresult;
24197 }
24198
24199
24200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24201   void * jresult ;
24202   Dali::BaseHandle arg1 ;
24203   Dali::BaseHandle *argp1 ;
24204   Dali::FrameBuffer result;
24205
24206   argp1 = (Dali::BaseHandle *)jarg1;
24207   if (!argp1) {
24208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24209     return 0;
24210   }
24211   arg1 = *argp1;
24212   {
24213     try {
24214       result = Dali::FrameBuffer::DownCast(arg1);
24215     } catch (std::out_of_range& e) {
24216       {
24217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24218       };
24219     } catch (std::exception& e) {
24220       {
24221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24222       };
24223     } catch (...) {
24224       {
24225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24226       };
24227     }
24228   }
24229   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24230   return jresult;
24231 }
24232
24233
24234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24235   void * jresult ;
24236   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24237   Dali::FrameBuffer *arg2 = 0 ;
24238   Dali::FrameBuffer *result = 0 ;
24239
24240   arg1 = (Dali::FrameBuffer *)jarg1;
24241   arg2 = (Dali::FrameBuffer *)jarg2;
24242   if (!arg2) {
24243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24244     return 0;
24245   }
24246   {
24247     try {
24248       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24249     } catch (std::out_of_range& e) {
24250       {
24251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24252       };
24253     } catch (std::exception& e) {
24254       {
24255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24256       };
24257     } catch (...) {
24258       {
24259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24260       };
24261     }
24262   }
24263   jresult = (void *)result;
24264   return jresult;
24265 }
24266
24267
24268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24269   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24270   Dali::Texture *arg2 = 0 ;
24271
24272   arg1 = (Dali::FrameBuffer *)jarg1;
24273   arg2 = (Dali::Texture *)jarg2;
24274   if (!arg2) {
24275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24276     return ;
24277   }
24278   {
24279     try {
24280       (arg1)->AttachColorTexture(*arg2);
24281     } catch (std::out_of_range& e) {
24282       {
24283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24284       };
24285     } catch (std::exception& e) {
24286       {
24287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24288       };
24289     } catch (...) {
24290       {
24291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24292       };
24293     }
24294   }
24295 }
24296
24297
24298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24299   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24300   Dali::Texture *arg2 = 0 ;
24301   unsigned int arg3 ;
24302   unsigned int arg4 ;
24303
24304   arg1 = (Dali::FrameBuffer *)jarg1;
24305   arg2 = (Dali::Texture *)jarg2;
24306   if (!arg2) {
24307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24308     return ;
24309   }
24310   arg3 = (unsigned int)jarg3;
24311   arg4 = (unsigned int)jarg4;
24312   {
24313     try {
24314       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24315     } catch (std::out_of_range& e) {
24316       {
24317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24318       };
24319     } catch (std::exception& e) {
24320       {
24321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24322       };
24323     } catch (...) {
24324       {
24325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24326       };
24327     }
24328   }
24329 }
24330
24331
24332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24333   void * jresult ;
24334   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24335   Dali::Texture result;
24336
24337   arg1 = (Dali::FrameBuffer *)jarg1;
24338   {
24339     try {
24340       result = (arg1)->GetColorTexture();
24341     } catch (std::out_of_range& e) {
24342       {
24343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24344       };
24345     } catch (std::exception& e) {
24346       {
24347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24348       };
24349     } catch (...) {
24350       {
24351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24352       };
24353     }
24354   }
24355   jresult = new Dali::Texture((const Dali::Texture &)result);
24356   return jresult;
24357 }
24358
24359
24360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24361   void * jresult ;
24362   Dali::RenderTaskList *result = 0 ;
24363
24364   {
24365     try {
24366       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24367     } catch (std::out_of_range& e) {
24368       {
24369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24370       };
24371     } catch (std::exception& e) {
24372       {
24373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24374       };
24375     } catch (...) {
24376       {
24377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24378       };
24379     }
24380   }
24381   jresult = (void *)result;
24382   return jresult;
24383 }
24384
24385
24386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24387   void * jresult ;
24388   Dali::BaseHandle arg1 ;
24389   Dali::BaseHandle *argp1 ;
24390   Dali::RenderTaskList result;
24391
24392   argp1 = (Dali::BaseHandle *)jarg1;
24393   if (!argp1) {
24394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24395     return 0;
24396   }
24397   arg1 = *argp1;
24398   {
24399     try {
24400       result = Dali::RenderTaskList::DownCast(arg1);
24401     } catch (std::out_of_range& e) {
24402       {
24403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24404       };
24405     } catch (std::exception& e) {
24406       {
24407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24408       };
24409     } catch (...) {
24410       {
24411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24412       };
24413     }
24414   }
24415   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24416   return jresult;
24417 }
24418
24419
24420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24421   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24422
24423   arg1 = (Dali::RenderTaskList *)jarg1;
24424   {
24425     try {
24426       delete arg1;
24427     } catch (std::out_of_range& e) {
24428       {
24429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24430       };
24431     } catch (std::exception& e) {
24432       {
24433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24434       };
24435     } catch (...) {
24436       {
24437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24438       };
24439     }
24440   }
24441 }
24442
24443
24444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24445   void * jresult ;
24446   Dali::RenderTaskList *arg1 = 0 ;
24447   Dali::RenderTaskList *result = 0 ;
24448
24449   arg1 = (Dali::RenderTaskList *)jarg1;
24450   if (!arg1) {
24451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24452     return 0;
24453   }
24454   {
24455     try {
24456       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24457     } catch (std::out_of_range& e) {
24458       {
24459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24460       };
24461     } catch (std::exception& e) {
24462       {
24463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24464       };
24465     } catch (...) {
24466       {
24467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24468       };
24469     }
24470   }
24471   jresult = (void *)result;
24472   return jresult;
24473 }
24474
24475
24476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24477   void * jresult ;
24478   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24479   Dali::RenderTaskList *arg2 = 0 ;
24480   Dali::RenderTaskList *result = 0 ;
24481
24482   arg1 = (Dali::RenderTaskList *)jarg1;
24483   arg2 = (Dali::RenderTaskList *)jarg2;
24484   if (!arg2) {
24485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24486     return 0;
24487   }
24488   {
24489     try {
24490       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24491     } catch (std::out_of_range& e) {
24492       {
24493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24494       };
24495     } catch (std::exception& e) {
24496       {
24497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24498       };
24499     } catch (...) {
24500       {
24501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24502       };
24503     }
24504   }
24505   jresult = (void *)result;
24506   return jresult;
24507 }
24508
24509
24510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24511   void * jresult ;
24512   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24513   Dali::RenderTask result;
24514
24515   arg1 = (Dali::RenderTaskList *)jarg1;
24516   {
24517     try {
24518       result = (arg1)->CreateTask();
24519     } catch (std::out_of_range& e) {
24520       {
24521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24522       };
24523     } catch (std::exception& e) {
24524       {
24525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24526       };
24527     } catch (...) {
24528       {
24529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24530       };
24531     }
24532   }
24533   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24534   return jresult;
24535 }
24536
24537
24538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24539   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24540   Dali::RenderTask arg2 ;
24541   Dali::RenderTask *argp2 ;
24542
24543   arg1 = (Dali::RenderTaskList *)jarg1;
24544   argp2 = (Dali::RenderTask *)jarg2;
24545   if (!argp2) {
24546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24547     return ;
24548   }
24549   arg2 = *argp2;
24550   {
24551     try {
24552       (arg1)->RemoveTask(arg2);
24553     } catch (std::out_of_range& e) {
24554       {
24555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24556       };
24557     } catch (std::exception& e) {
24558       {
24559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24560       };
24561     } catch (...) {
24562       {
24563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24564       };
24565     }
24566   }
24567 }
24568
24569
24570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24571   unsigned int jresult ;
24572   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24573   unsigned int result;
24574
24575   arg1 = (Dali::RenderTaskList *)jarg1;
24576   {
24577     try {
24578       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24579     } catch (std::out_of_range& e) {
24580       {
24581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24582       };
24583     } catch (std::exception& e) {
24584       {
24585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24586       };
24587     } catch (...) {
24588       {
24589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24590       };
24591     }
24592   }
24593   jresult = result;
24594   return jresult;
24595 }
24596
24597
24598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24599   void * jresult ;
24600   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24601   unsigned int arg2 ;
24602   Dali::RenderTask result;
24603
24604   arg1 = (Dali::RenderTaskList *)jarg1;
24605   arg2 = (unsigned int)jarg2;
24606   {
24607     try {
24608       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24609     } catch (std::out_of_range& e) {
24610       {
24611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24612       };
24613     } catch (std::exception& e) {
24614       {
24615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24616       };
24617     } catch (...) {
24618       {
24619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24620       };
24621     }
24622   }
24623   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24624   return jresult;
24625 }
24626
24627
24628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24629   int jresult ;
24630   int result;
24631
24632   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24633   jresult = (int)result;
24634   return jresult;
24635 }
24636
24637
24638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24639   int jresult ;
24640   int result;
24641
24642   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24643   jresult = (int)result;
24644   return jresult;
24645 }
24646
24647
24648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24649   int jresult ;
24650   int result;
24651
24652   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24653   jresult = (int)result;
24654   return jresult;
24655 }
24656
24657
24658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24659   int jresult ;
24660   int result;
24661
24662   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24663   jresult = (int)result;
24664   return jresult;
24665 }
24666
24667
24668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24669   void * jresult ;
24670   Dali::RenderTask::Property *result = 0 ;
24671
24672   {
24673     try {
24674       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24675     } catch (std::out_of_range& e) {
24676       {
24677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24678       };
24679     } catch (std::exception& e) {
24680       {
24681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24682       };
24683     } catch (...) {
24684       {
24685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24686       };
24687     }
24688   }
24689   jresult = (void *)result;
24690   return jresult;
24691 }
24692
24693
24694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24695   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24696
24697   arg1 = (Dali::RenderTask::Property *)jarg1;
24698   {
24699     try {
24700       delete arg1;
24701     } catch (std::out_of_range& e) {
24702       {
24703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24704       };
24705     } catch (std::exception& e) {
24706       {
24707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24708       };
24709     } catch (...) {
24710       {
24711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24712       };
24713     }
24714   }
24715 }
24716
24717
24718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24719   void * jresult ;
24720   bool (*result)(Dali::Vector2 &) = 0 ;
24721
24722   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24723   jresult = (void *)result;
24724   return jresult;
24725 }
24726
24727
24728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24729   void * jresult ;
24730   bool (*result)(Dali::Vector2 &) = 0 ;
24731
24732   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24733   jresult = (void *)result;
24734   return jresult;
24735 }
24736
24737
24738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24739   unsigned int jresult ;
24740   bool result;
24741
24742   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24743   jresult = result;
24744   return jresult;
24745 }
24746
24747
24748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24749   unsigned int jresult ;
24750   bool result;
24751
24752   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24753   jresult = result;
24754   return jresult;
24755 }
24756
24757
24758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24759   void * jresult ;
24760   Dali::Vector4 *result = 0 ;
24761
24762   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24763   jresult = (void *)result;
24764   return jresult;
24765 }
24766
24767
24768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24769   unsigned int jresult ;
24770   bool result;
24771
24772   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24773   jresult = result;
24774   return jresult;
24775 }
24776
24777
24778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24779   unsigned int jresult ;
24780   bool result;
24781
24782   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24783   jresult = result;
24784   return jresult;
24785 }
24786
24787
24788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24789   unsigned int jresult ;
24790   unsigned int result;
24791
24792   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24793   jresult = result;
24794   return jresult;
24795 }
24796
24797
24798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24799   void * jresult ;
24800   Dali::RenderTask *result = 0 ;
24801
24802   {
24803     try {
24804       result = (Dali::RenderTask *)new Dali::RenderTask();
24805     } catch (std::out_of_range& e) {
24806       {
24807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24808       };
24809     } catch (std::exception& e) {
24810       {
24811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24812       };
24813     } catch (...) {
24814       {
24815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24816       };
24817     }
24818   }
24819   jresult = (void *)result;
24820   return jresult;
24821 }
24822
24823
24824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24825   void * jresult ;
24826   Dali::BaseHandle arg1 ;
24827   Dali::BaseHandle *argp1 ;
24828   Dali::RenderTask result;
24829
24830   argp1 = (Dali::BaseHandle *)jarg1;
24831   if (!argp1) {
24832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24833     return 0;
24834   }
24835   arg1 = *argp1;
24836   {
24837     try {
24838       result = Dali::RenderTask::DownCast(arg1);
24839     } catch (std::out_of_range& e) {
24840       {
24841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24842       };
24843     } catch (std::exception& e) {
24844       {
24845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24846       };
24847     } catch (...) {
24848       {
24849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24850       };
24851     }
24852   }
24853   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24854   return jresult;
24855 }
24856
24857
24858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24859   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24860
24861   arg1 = (Dali::RenderTask *)jarg1;
24862   {
24863     try {
24864       delete arg1;
24865     } catch (std::out_of_range& e) {
24866       {
24867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24868       };
24869     } catch (std::exception& e) {
24870       {
24871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24872       };
24873     } catch (...) {
24874       {
24875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24876       };
24877     }
24878   }
24879 }
24880
24881
24882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24883   void * jresult ;
24884   Dali::RenderTask *arg1 = 0 ;
24885   Dali::RenderTask *result = 0 ;
24886
24887   arg1 = (Dali::RenderTask *)jarg1;
24888   if (!arg1) {
24889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24890     return 0;
24891   }
24892   {
24893     try {
24894       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24895     } catch (std::out_of_range& e) {
24896       {
24897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24898       };
24899     } catch (std::exception& e) {
24900       {
24901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24902       };
24903     } catch (...) {
24904       {
24905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24906       };
24907     }
24908   }
24909   jresult = (void *)result;
24910   return jresult;
24911 }
24912
24913
24914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24915   void * jresult ;
24916   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24917   Dali::RenderTask *arg2 = 0 ;
24918   Dali::RenderTask *result = 0 ;
24919
24920   arg1 = (Dali::RenderTask *)jarg1;
24921   arg2 = (Dali::RenderTask *)jarg2;
24922   if (!arg2) {
24923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24924     return 0;
24925   }
24926   {
24927     try {
24928       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24929     } catch (std::out_of_range& e) {
24930       {
24931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24932       };
24933     } catch (std::exception& e) {
24934       {
24935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24936       };
24937     } catch (...) {
24938       {
24939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24940       };
24941     }
24942   }
24943   jresult = (void *)result;
24944   return jresult;
24945 }
24946
24947
24948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24949   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24950   Dali::Actor arg2 ;
24951   Dali::Actor *argp2 ;
24952
24953   arg1 = (Dali::RenderTask *)jarg1;
24954   argp2 = (Dali::Actor *)jarg2;
24955   if (!argp2) {
24956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24957     return ;
24958   }
24959   arg2 = *argp2;
24960   {
24961     try {
24962       (arg1)->SetSourceActor(arg2);
24963     } catch (std::out_of_range& e) {
24964       {
24965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24966       };
24967     } catch (std::exception& e) {
24968       {
24969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24970       };
24971     } catch (...) {
24972       {
24973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24974       };
24975     }
24976   }
24977 }
24978
24979
24980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24981   void * jresult ;
24982   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24983   Dali::Actor result;
24984
24985   arg1 = (Dali::RenderTask *)jarg1;
24986   {
24987     try {
24988       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24989     } catch (std::out_of_range& e) {
24990       {
24991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24992       };
24993     } catch (std::exception& e) {
24994       {
24995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24996       };
24997     } catch (...) {
24998       {
24999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25000       };
25001     }
25002   }
25003   jresult = new Dali::Actor((const Dali::Actor &)result);
25004   return jresult;
25005 }
25006
25007
25008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
25009   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25010   bool arg2 ;
25011
25012   arg1 = (Dali::RenderTask *)jarg1;
25013   arg2 = jarg2 ? true : false;
25014   {
25015     try {
25016       (arg1)->SetExclusive(arg2);
25017     } catch (std::out_of_range& e) {
25018       {
25019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25020       };
25021     } catch (std::exception& e) {
25022       {
25023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25024       };
25025     } catch (...) {
25026       {
25027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25028       };
25029     }
25030   }
25031 }
25032
25033
25034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
25035   unsigned int jresult ;
25036   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25037   bool result;
25038
25039   arg1 = (Dali::RenderTask *)jarg1;
25040   {
25041     try {
25042       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
25043     } catch (std::out_of_range& e) {
25044       {
25045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25046       };
25047     } catch (std::exception& e) {
25048       {
25049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25050       };
25051     } catch (...) {
25052       {
25053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25054       };
25055     }
25056   }
25057   jresult = result;
25058   return jresult;
25059 }
25060
25061
25062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25063   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25064   bool arg2 ;
25065
25066   arg1 = (Dali::RenderTask *)jarg1;
25067   arg2 = jarg2 ? true : false;
25068   {
25069     try {
25070       (arg1)->SetInputEnabled(arg2);
25071     } catch (std::out_of_range& e) {
25072       {
25073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25074       };
25075     } catch (std::exception& e) {
25076       {
25077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25078       };
25079     } catch (...) {
25080       {
25081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25082       };
25083     }
25084   }
25085 }
25086
25087
25088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25089   unsigned int jresult ;
25090   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25091   bool result;
25092
25093   arg1 = (Dali::RenderTask *)jarg1;
25094   {
25095     try {
25096       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25097     } catch (std::out_of_range& e) {
25098       {
25099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25100       };
25101     } catch (std::exception& e) {
25102       {
25103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25104       };
25105     } catch (...) {
25106       {
25107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25108       };
25109     }
25110   }
25111   jresult = result;
25112   return jresult;
25113 }
25114
25115
25116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25117   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25118   Dali::CameraActor arg2 ;
25119   Dali::CameraActor *argp2 ;
25120
25121   arg1 = (Dali::RenderTask *)jarg1;
25122   argp2 = (Dali::CameraActor *)jarg2;
25123   if (!argp2) {
25124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25125     return ;
25126   }
25127   arg2 = *argp2;
25128   {
25129     try {
25130       (arg1)->SetCameraActor(arg2);
25131     } catch (std::out_of_range& e) {
25132       {
25133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25134       };
25135     } catch (std::exception& e) {
25136       {
25137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25138       };
25139     } catch (...) {
25140       {
25141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25142       };
25143     }
25144   }
25145 }
25146
25147
25148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25149   void * jresult ;
25150   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25151   Dali::CameraActor result;
25152
25153   arg1 = (Dali::RenderTask *)jarg1;
25154   {
25155     try {
25156       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25157     } catch (std::out_of_range& e) {
25158       {
25159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25160       };
25161     } catch (std::exception& e) {
25162       {
25163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25164       };
25165     } catch (...) {
25166       {
25167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25168       };
25169     }
25170   }
25171   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25172   return jresult;
25173 }
25174
25175
25176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25177   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25178   Dali::FrameBufferImage arg2 ;
25179   Dali::FrameBufferImage *argp2 ;
25180
25181   arg1 = (Dali::RenderTask *)jarg1;
25182   argp2 = (Dali::FrameBufferImage *)jarg2;
25183   if (!argp2) {
25184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25185     return ;
25186   }
25187   arg2 = *argp2;
25188   {
25189     try {
25190       (arg1)->SetTargetFrameBuffer(arg2);
25191     } catch (std::out_of_range& e) {
25192       {
25193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25194       };
25195     } catch (std::exception& e) {
25196       {
25197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25198       };
25199     } catch (...) {
25200       {
25201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25202       };
25203     }
25204   }
25205 }
25206
25207
25208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25209   void * jresult ;
25210   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25211   Dali::FrameBufferImage result;
25212
25213   arg1 = (Dali::RenderTask *)jarg1;
25214   {
25215     try {
25216       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25217     } catch (std::out_of_range& e) {
25218       {
25219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25220       };
25221     } catch (std::exception& e) {
25222       {
25223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25224       };
25225     } catch (...) {
25226       {
25227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25228       };
25229     }
25230   }
25231   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25232   return jresult;
25233 }
25234
25235
25236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25237   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25238   Dali::FrameBuffer arg2 ;
25239   Dali::FrameBuffer *argp2 ;
25240
25241   arg1 = (Dali::RenderTask *)jarg1;
25242   argp2 = (Dali::FrameBuffer *)jarg2;
25243   if (!argp2) {
25244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25245     return ;
25246   }
25247   arg2 = *argp2;
25248   {
25249     try {
25250       (arg1)->SetFrameBuffer(arg2);
25251     } catch (std::out_of_range& e) {
25252       {
25253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25254       };
25255     } catch (std::exception& e) {
25256       {
25257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25258       };
25259     } catch (...) {
25260       {
25261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25262       };
25263     }
25264   }
25265 }
25266
25267
25268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25269   void * jresult ;
25270   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25271   Dali::FrameBuffer result;
25272
25273   arg1 = (Dali::RenderTask *)jarg1;
25274   {
25275     try {
25276       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25277     } catch (std::out_of_range& e) {
25278       {
25279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25280       };
25281     } catch (std::exception& e) {
25282       {
25283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25284       };
25285     } catch (...) {
25286       {
25287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25288       };
25289     }
25290   }
25291   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25292   return jresult;
25293 }
25294
25295
25296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25297   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25298   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25299
25300   arg1 = (Dali::RenderTask *)jarg1;
25301   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25302   {
25303     try {
25304       (arg1)->SetScreenToFrameBufferFunction(arg2);
25305     } catch (std::out_of_range& e) {
25306       {
25307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25308       };
25309     } catch (std::exception& e) {
25310       {
25311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25312       };
25313     } catch (...) {
25314       {
25315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25316       };
25317     }
25318   }
25319 }
25320
25321
25322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25323   void * jresult ;
25324   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25325   Dali::RenderTask::ScreenToFrameBufferFunction result;
25326
25327   arg1 = (Dali::RenderTask *)jarg1;
25328   {
25329     try {
25330       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25331     } catch (std::out_of_range& e) {
25332       {
25333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25334       };
25335     } catch (std::exception& e) {
25336       {
25337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25338       };
25339     } catch (...) {
25340       {
25341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25342       };
25343     }
25344   }
25345   jresult = (void *)result;
25346   return jresult;
25347 }
25348
25349
25350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25351   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25352   Dali::Actor arg2 ;
25353   Dali::Actor *argp2 ;
25354
25355   arg1 = (Dali::RenderTask *)jarg1;
25356   argp2 = (Dali::Actor *)jarg2;
25357   if (!argp2) {
25358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25359     return ;
25360   }
25361   arg2 = *argp2;
25362   {
25363     try {
25364       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25365     } catch (std::out_of_range& e) {
25366       {
25367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25368       };
25369     } catch (std::exception& e) {
25370       {
25371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25372       };
25373     } catch (...) {
25374       {
25375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25376       };
25377     }
25378   }
25379 }
25380
25381
25382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25383   void * jresult ;
25384   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25385   Dali::Actor result;
25386
25387   arg1 = (Dali::RenderTask *)jarg1;
25388   {
25389     try {
25390       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25391     } catch (std::out_of_range& e) {
25392       {
25393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25394       };
25395     } catch (std::exception& e) {
25396       {
25397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25398       };
25399     } catch (...) {
25400       {
25401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25402       };
25403     }
25404   }
25405   jresult = new Dali::Actor((const Dali::Actor &)result);
25406   return jresult;
25407 }
25408
25409
25410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25411   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25412   Dali::Vector2 arg2 ;
25413   Dali::Vector2 *argp2 ;
25414
25415   arg1 = (Dali::RenderTask *)jarg1;
25416   argp2 = (Dali::Vector2 *)jarg2;
25417   if (!argp2) {
25418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25419     return ;
25420   }
25421   arg2 = *argp2;
25422   {
25423     try {
25424       (arg1)->SetViewportPosition(arg2);
25425     } catch (std::out_of_range& e) {
25426       {
25427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25428       };
25429     } catch (std::exception& e) {
25430       {
25431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25432       };
25433     } catch (...) {
25434       {
25435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25436       };
25437     }
25438   }
25439 }
25440
25441
25442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25443   void * jresult ;
25444   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25445   Dali::Vector2 result;
25446
25447   arg1 = (Dali::RenderTask *)jarg1;
25448   {
25449     try {
25450       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25451     } catch (std::out_of_range& e) {
25452       {
25453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25454       };
25455     } catch (std::exception& e) {
25456       {
25457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25458       };
25459     } catch (...) {
25460       {
25461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25462       };
25463     }
25464   }
25465   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25466   return jresult;
25467 }
25468
25469
25470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25471   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25472   Dali::Vector2 arg2 ;
25473   Dali::Vector2 *argp2 ;
25474
25475   arg1 = (Dali::RenderTask *)jarg1;
25476   argp2 = (Dali::Vector2 *)jarg2;
25477   if (!argp2) {
25478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25479     return ;
25480   }
25481   arg2 = *argp2;
25482   {
25483     try {
25484       (arg1)->SetViewportSize(arg2);
25485     } catch (std::out_of_range& e) {
25486       {
25487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25488       };
25489     } catch (std::exception& e) {
25490       {
25491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25492       };
25493     } catch (...) {
25494       {
25495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25496       };
25497     }
25498   }
25499 }
25500
25501
25502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25503   void * jresult ;
25504   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25505   Dali::Vector2 result;
25506
25507   arg1 = (Dali::RenderTask *)jarg1;
25508   {
25509     try {
25510       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25511     } catch (std::out_of_range& e) {
25512       {
25513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25514       };
25515     } catch (std::exception& e) {
25516       {
25517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25518       };
25519     } catch (...) {
25520       {
25521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25522       };
25523     }
25524   }
25525   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25526   return jresult;
25527 }
25528
25529
25530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25531   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25532   Dali::Viewport arg2 ;
25533   Dali::Viewport *argp2 ;
25534
25535   arg1 = (Dali::RenderTask *)jarg1;
25536   argp2 = (Dali::Viewport *)jarg2;
25537   if (!argp2) {
25538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25539     return ;
25540   }
25541   arg2 = *argp2;
25542   {
25543     try {
25544       (arg1)->SetViewport(arg2);
25545     } catch (std::out_of_range& e) {
25546       {
25547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25548       };
25549     } catch (std::exception& e) {
25550       {
25551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25552       };
25553     } catch (...) {
25554       {
25555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25556       };
25557     }
25558   }
25559 }
25560
25561
25562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25563   void * jresult ;
25564   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25565   Dali::Viewport result;
25566
25567   arg1 = (Dali::RenderTask *)jarg1;
25568   {
25569     try {
25570       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25571     } catch (std::out_of_range& e) {
25572       {
25573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25574       };
25575     } catch (std::exception& e) {
25576       {
25577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25578       };
25579     } catch (...) {
25580       {
25581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25582       };
25583     }
25584   }
25585   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25586   return jresult;
25587 }
25588
25589
25590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25591   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25592   Dali::Vector4 *arg2 = 0 ;
25593
25594   arg1 = (Dali::RenderTask *)jarg1;
25595   arg2 = (Dali::Vector4 *)jarg2;
25596   if (!arg2) {
25597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25598     return ;
25599   }
25600   {
25601     try {
25602       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25603     } catch (std::out_of_range& e) {
25604       {
25605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25606       };
25607     } catch (std::exception& e) {
25608       {
25609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25610       };
25611     } catch (...) {
25612       {
25613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25614       };
25615     }
25616   }
25617 }
25618
25619
25620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25621   void * jresult ;
25622   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25623   Dali::Vector4 result;
25624
25625   arg1 = (Dali::RenderTask *)jarg1;
25626   {
25627     try {
25628       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25629     } catch (std::out_of_range& e) {
25630       {
25631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25632       };
25633     } catch (std::exception& e) {
25634       {
25635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25636       };
25637     } catch (...) {
25638       {
25639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25640       };
25641     }
25642   }
25643   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25644   return jresult;
25645 }
25646
25647
25648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25649   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25650   bool arg2 ;
25651
25652   arg1 = (Dali::RenderTask *)jarg1;
25653   arg2 = jarg2 ? true : false;
25654   {
25655     try {
25656       (arg1)->SetClearEnabled(arg2);
25657     } catch (std::out_of_range& e) {
25658       {
25659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25660       };
25661     } catch (std::exception& e) {
25662       {
25663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25664       };
25665     } catch (...) {
25666       {
25667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25668       };
25669     }
25670   }
25671 }
25672
25673
25674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25675   unsigned int jresult ;
25676   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25677   bool result;
25678
25679   arg1 = (Dali::RenderTask *)jarg1;
25680   {
25681     try {
25682       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25683     } catch (std::out_of_range& e) {
25684       {
25685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25686       };
25687     } catch (std::exception& e) {
25688       {
25689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25690       };
25691     } catch (...) {
25692       {
25693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25694       };
25695     }
25696   }
25697   jresult = result;
25698   return jresult;
25699 }
25700
25701
25702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25703   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25704   bool arg2 ;
25705
25706   arg1 = (Dali::RenderTask *)jarg1;
25707   arg2 = jarg2 ? true : false;
25708   {
25709     try {
25710       (arg1)->SetCullMode(arg2);
25711     } catch (std::out_of_range& e) {
25712       {
25713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25714       };
25715     } catch (std::exception& e) {
25716       {
25717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25718       };
25719     } catch (...) {
25720       {
25721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25722       };
25723     }
25724   }
25725 }
25726
25727
25728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25729   unsigned int jresult ;
25730   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25731   bool result;
25732
25733   arg1 = (Dali::RenderTask *)jarg1;
25734   {
25735     try {
25736       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25737     } catch (std::out_of_range& e) {
25738       {
25739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25740       };
25741     } catch (std::exception& e) {
25742       {
25743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25744       };
25745     } catch (...) {
25746       {
25747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25748       };
25749     }
25750   }
25751   jresult = result;
25752   return jresult;
25753 }
25754
25755
25756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25757   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25758   unsigned int arg2 ;
25759
25760   arg1 = (Dali::RenderTask *)jarg1;
25761   arg2 = (unsigned int)jarg2;
25762   {
25763     try {
25764       (arg1)->SetRefreshRate(arg2);
25765     } catch (std::out_of_range& e) {
25766       {
25767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25768       };
25769     } catch (std::exception& e) {
25770       {
25771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25772       };
25773     } catch (...) {
25774       {
25775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25776       };
25777     }
25778   }
25779 }
25780
25781
25782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25783   unsigned int jresult ;
25784   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25785   unsigned int result;
25786
25787   arg1 = (Dali::RenderTask *)jarg1;
25788   {
25789     try {
25790       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25791     } catch (std::out_of_range& e) {
25792       {
25793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25794       };
25795     } catch (std::exception& e) {
25796       {
25797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25798       };
25799     } catch (...) {
25800       {
25801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25802       };
25803     }
25804   }
25805   jresult = result;
25806   return jresult;
25807 }
25808
25809
25810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25811   unsigned int jresult ;
25812   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25813   Dali::Vector3 *arg2 = 0 ;
25814   float *arg3 = 0 ;
25815   float *arg4 = 0 ;
25816   bool result;
25817
25818   arg1 = (Dali::RenderTask *)jarg1;
25819   arg2 = (Dali::Vector3 *)jarg2;
25820   if (!arg2) {
25821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25822     return 0;
25823   }
25824   arg3 = (float *)jarg3;
25825   arg4 = (float *)jarg4;
25826   {
25827     try {
25828       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25829     } catch (std::out_of_range& e) {
25830       {
25831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25832       };
25833     } catch (std::exception& e) {
25834       {
25835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25836       };
25837     } catch (...) {
25838       {
25839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25840       };
25841     }
25842   }
25843   jresult = result;
25844   return jresult;
25845 }
25846
25847
25848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25849   unsigned int jresult ;
25850   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25851   Dali::Actor arg2 ;
25852   float arg3 ;
25853   float arg4 ;
25854   float *arg5 = 0 ;
25855   float *arg6 = 0 ;
25856   Dali::Actor *argp2 ;
25857   bool result;
25858
25859   arg1 = (Dali::RenderTask *)jarg1;
25860   argp2 = (Dali::Actor *)jarg2;
25861   if (!argp2) {
25862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25863     return 0;
25864   }
25865   arg2 = *argp2;
25866   arg3 = (float)jarg3;
25867   arg4 = (float)jarg4;
25868   arg5 = (float *)jarg5;
25869   arg6 = (float *)jarg6;
25870   {
25871     try {
25872       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25873     } catch (std::out_of_range& e) {
25874       {
25875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25876       };
25877     } catch (std::exception& e) {
25878       {
25879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25880       };
25881     } catch (...) {
25882       {
25883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25884       };
25885     }
25886   }
25887   jresult = result;
25888   return jresult;
25889 }
25890
25891
25892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25893   void * jresult ;
25894   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25895   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25896
25897   arg1 = (Dali::RenderTask *)jarg1;
25898   {
25899     try {
25900       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25901     } catch (std::out_of_range& e) {
25902       {
25903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25904       };
25905     } catch (std::exception& e) {
25906       {
25907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25908       };
25909     } catch (...) {
25910       {
25911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25912       };
25913     }
25914   }
25915   jresult = (void *)result;
25916   return jresult;
25917 }
25918
25919
25920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25921   void * jresult ;
25922   int arg1 ;
25923   Dali::TouchPoint::State arg2 ;
25924   float arg3 ;
25925   float arg4 ;
25926   Dali::TouchPoint *result = 0 ;
25927
25928   arg1 = (int)jarg1;
25929   arg2 = (Dali::TouchPoint::State)jarg2;
25930   arg3 = (float)jarg3;
25931   arg4 = (float)jarg4;
25932   {
25933     try {
25934       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25935     } catch (std::out_of_range& e) {
25936       {
25937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25938       };
25939     } catch (std::exception& e) {
25940       {
25941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25942       };
25943     } catch (...) {
25944       {
25945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25946       };
25947     }
25948   }
25949   jresult = (void *)result;
25950   return jresult;
25951 }
25952
25953
25954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25955   void * jresult ;
25956   int arg1 ;
25957   Dali::TouchPoint::State arg2 ;
25958   float arg3 ;
25959   float arg4 ;
25960   float arg5 ;
25961   float arg6 ;
25962   Dali::TouchPoint *result = 0 ;
25963
25964   arg1 = (int)jarg1;
25965   arg2 = (Dali::TouchPoint::State)jarg2;
25966   arg3 = (float)jarg3;
25967   arg4 = (float)jarg4;
25968   arg5 = (float)jarg5;
25969   arg6 = (float)jarg6;
25970   {
25971     try {
25972       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25973     } catch (std::out_of_range& e) {
25974       {
25975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25976       };
25977     } catch (std::exception& e) {
25978       {
25979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25980       };
25981     } catch (...) {
25982       {
25983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25984       };
25985     }
25986   }
25987   jresult = (void *)result;
25988   return jresult;
25989 }
25990
25991
25992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25993   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25994
25995   arg1 = (Dali::TouchPoint *)jarg1;
25996   {
25997     try {
25998       delete arg1;
25999     } catch (std::out_of_range& e) {
26000       {
26001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26002       };
26003     } catch (std::exception& e) {
26004       {
26005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26006       };
26007     } catch (...) {
26008       {
26009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26010       };
26011     }
26012   }
26013 }
26014
26015
26016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
26017   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26018   int arg2 ;
26019
26020   arg1 = (Dali::TouchPoint *)jarg1;
26021   arg2 = (int)jarg2;
26022   if (arg1) (arg1)->deviceId = arg2;
26023 }
26024
26025
26026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
26027   int jresult ;
26028   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26029   int result;
26030
26031   arg1 = (Dali::TouchPoint *)jarg1;
26032   result = (int) ((arg1)->deviceId);
26033   jresult = result;
26034   return jresult;
26035 }
26036
26037
26038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
26039   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26040   Dali::TouchPoint::State arg2 ;
26041
26042   arg1 = (Dali::TouchPoint *)jarg1;
26043   arg2 = (Dali::TouchPoint::State)jarg2;
26044   if (arg1) (arg1)->state = arg2;
26045 }
26046
26047
26048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
26049   int jresult ;
26050   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26051   Dali::TouchPoint::State result;
26052
26053   arg1 = (Dali::TouchPoint *)jarg1;
26054   result = (Dali::TouchPoint::State) ((arg1)->state);
26055   jresult = (int)result;
26056   return jresult;
26057 }
26058
26059
26060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26061   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26062   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26063
26064   arg1 = (Dali::TouchPoint *)jarg1;
26065   arg2 = (Dali::Actor *)jarg2;
26066   if (arg1) (arg1)->hitActor = *arg2;
26067 }
26068
26069
26070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26071   void * jresult ;
26072   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26073   Dali::Actor *result = 0 ;
26074
26075   arg1 = (Dali::TouchPoint *)jarg1;
26076   result = (Dali::Actor *)& ((arg1)->hitActor);
26077   jresult = (void *)result;
26078   return jresult;
26079 }
26080
26081
26082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26083   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26084   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26085
26086   arg1 = (Dali::TouchPoint *)jarg1;
26087   arg2 = (Dali::Vector2 *)jarg2;
26088   if (arg1) (arg1)->local = *arg2;
26089 }
26090
26091
26092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26093   void * jresult ;
26094   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26095   Dali::Vector2 *result = 0 ;
26096
26097   arg1 = (Dali::TouchPoint *)jarg1;
26098   result = (Dali::Vector2 *)& ((arg1)->local);
26099   jresult = (void *)result;
26100   return jresult;
26101 }
26102
26103
26104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26105   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26106   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26107
26108   arg1 = (Dali::TouchPoint *)jarg1;
26109   arg2 = (Dali::Vector2 *)jarg2;
26110   if (arg1) (arg1)->screen = *arg2;
26111 }
26112
26113
26114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26115   void * jresult ;
26116   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26117   Dali::Vector2 *result = 0 ;
26118
26119   arg1 = (Dali::TouchPoint *)jarg1;
26120   result = (Dali::Vector2 *)& ((arg1)->screen);
26121   jresult = (void *)result;
26122   return jresult;
26123 }
26124
26125
26126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26127   void * jresult ;
26128   Dali::TouchData *result = 0 ;
26129
26130   {
26131     try {
26132       result = (Dali::TouchData *)new Dali::TouchData();
26133     } catch (std::out_of_range& e) {
26134       {
26135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26136       };
26137     } catch (std::exception& e) {
26138       {
26139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26140       };
26141     } catch (...) {
26142       {
26143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26144       };
26145     }
26146   }
26147   jresult = (void *)result;
26148   return jresult;
26149 }
26150
26151
26152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26153   void * jresult ;
26154   Dali::TouchData *arg1 = 0 ;
26155   Dali::TouchData *result = 0 ;
26156
26157   arg1 = (Dali::TouchData *)jarg1;
26158   if (!arg1) {
26159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26160     return 0;
26161   }
26162   {
26163     try {
26164       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26165     } catch (std::out_of_range& e) {
26166       {
26167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26168       };
26169     } catch (std::exception& e) {
26170       {
26171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26172       };
26173     } catch (...) {
26174       {
26175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26176       };
26177     }
26178   }
26179   jresult = (void *)result;
26180   return jresult;
26181 }
26182
26183
26184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26185   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26186
26187   arg1 = (Dali::TouchData *)jarg1;
26188   {
26189     try {
26190       delete arg1;
26191     } catch (std::out_of_range& e) {
26192       {
26193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26194       };
26195     } catch (std::exception& e) {
26196       {
26197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26198       };
26199     } catch (...) {
26200       {
26201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26202       };
26203     }
26204   }
26205 }
26206
26207
26208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26209   void * jresult ;
26210   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26211   Dali::TouchData *arg2 = 0 ;
26212   Dali::TouchData *result = 0 ;
26213
26214   arg1 = (Dali::TouchData *)jarg1;
26215   arg2 = (Dali::TouchData *)jarg2;
26216   if (!arg2) {
26217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26218     return 0;
26219   }
26220   {
26221     try {
26222       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26223     } catch (std::out_of_range& e) {
26224       {
26225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26226       };
26227     } catch (std::exception& e) {
26228       {
26229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26230       };
26231     } catch (...) {
26232       {
26233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26234       };
26235     }
26236   }
26237   jresult = (void *)result;
26238   return jresult;
26239 }
26240
26241
26242 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26243   unsigned long jresult ;
26244   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26245   unsigned long result;
26246
26247   arg1 = (Dali::TouchData *)jarg1;
26248   {
26249     try {
26250       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26251     } catch (std::out_of_range& e) {
26252       {
26253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26254       };
26255     } catch (std::exception& e) {
26256       {
26257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26258       };
26259     } catch (...) {
26260       {
26261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26262       };
26263     }
26264   }
26265   jresult = (unsigned long)result;
26266   return jresult;
26267 }
26268
26269
26270 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26271   unsigned long jresult ;
26272   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26273   std::size_t result;
26274
26275   arg1 = (Dali::TouchData *)jarg1;
26276   {
26277     try {
26278       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26279     } catch (std::out_of_range& e) {
26280       {
26281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26282       };
26283     } catch (std::exception& e) {
26284       {
26285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26286       };
26287     } catch (...) {
26288       {
26289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26290       };
26291     }
26292   }
26293   jresult = (unsigned long)result;
26294   return jresult;
26295 }
26296
26297
26298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26299   int jresult ;
26300   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26301   std::size_t arg2 ;
26302   int32_t result;
26303
26304   arg1 = (Dali::TouchData *)jarg1;
26305   arg2 = (std::size_t)jarg2;
26306   {
26307     try {
26308       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26309     } catch (std::out_of_range& e) {
26310       {
26311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26312       };
26313     } catch (std::exception& e) {
26314       {
26315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26316       };
26317     } catch (...) {
26318       {
26319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26320       };
26321     }
26322   }
26323   jresult = result;
26324   return jresult;
26325 }
26326
26327
26328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26329   int jresult ;
26330   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26331   std::size_t arg2 ;
26332   Dali::PointState::Type result;
26333
26334   arg1 = (Dali::TouchData *)jarg1;
26335   arg2 = (std::size_t)jarg2;
26336   {
26337     try {
26338       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26339     } catch (std::out_of_range& e) {
26340       {
26341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26342       };
26343     } catch (std::exception& e) {
26344       {
26345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26346       };
26347     } catch (...) {
26348       {
26349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26350       };
26351     }
26352   }
26353   jresult = (int)result;
26354   return jresult;
26355 }
26356
26357
26358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26359   void * jresult ;
26360   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26361   std::size_t arg2 ;
26362   Dali::Actor result;
26363
26364   arg1 = (Dali::TouchData *)jarg1;
26365   arg2 = (std::size_t)jarg2;
26366   {
26367     try {
26368       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26369     } catch (std::out_of_range& e) {
26370       {
26371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26372       };
26373     } catch (std::exception& e) {
26374       {
26375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26376       };
26377     } catch (...) {
26378       {
26379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26380       };
26381     }
26382   }
26383   jresult = new Dali::Actor((const Dali::Actor &)result);
26384   return jresult;
26385 }
26386
26387
26388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26389   void * jresult ;
26390   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26391   std::size_t arg2 ;
26392   Dali::Vector2 *result = 0 ;
26393
26394   arg1 = (Dali::TouchData *)jarg1;
26395   arg2 = (std::size_t)jarg2;
26396   {
26397     try {
26398       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26399     } catch (std::out_of_range& e) {
26400       {
26401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26402       };
26403     } catch (std::exception& e) {
26404       {
26405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26406       };
26407     } catch (...) {
26408       {
26409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26410       };
26411     }
26412   }
26413   jresult = (void *)result;
26414   return jresult;
26415 }
26416
26417
26418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26419   void * jresult ;
26420   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26421   std::size_t arg2 ;
26422   Dali::Vector2 *result = 0 ;
26423
26424   arg1 = (Dali::TouchData *)jarg1;
26425   arg2 = (std::size_t)jarg2;
26426   {
26427     try {
26428       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26429     } catch (std::out_of_range& e) {
26430       {
26431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26432       };
26433     } catch (std::exception& e) {
26434       {
26435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26436       };
26437     } catch (...) {
26438       {
26439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26440       };
26441     }
26442   }
26443   jresult = (void *)result;
26444   return jresult;
26445 }
26446
26447
26448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26449   float jresult ;
26450   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26451   std::size_t arg2 ;
26452   float result;
26453
26454   arg1 = (Dali::TouchData *)jarg1;
26455   arg2 = (std::size_t)jarg2;
26456   {
26457     try {
26458       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26459     } catch (std::out_of_range& e) {
26460       {
26461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26462       };
26463     } catch (std::exception& e) {
26464       {
26465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26466       };
26467     } catch (...) {
26468       {
26469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26470       };
26471     }
26472   }
26473   jresult = result;
26474   return jresult;
26475 }
26476
26477
26478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26479   void * jresult ;
26480   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26481   std::size_t arg2 ;
26482   Dali::Vector2 *result = 0 ;
26483
26484   arg1 = (Dali::TouchData *)jarg1;
26485   arg2 = (std::size_t)jarg2;
26486   {
26487     try {
26488       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26489     } catch (std::out_of_range& e) {
26490       {
26491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26492       };
26493     } catch (std::exception& e) {
26494       {
26495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26496       };
26497     } catch (...) {
26498       {
26499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26500       };
26501     }
26502   }
26503   jresult = (void *)result;
26504   return jresult;
26505 }
26506
26507
26508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26509   float jresult ;
26510   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26511   std::size_t arg2 ;
26512   float result;
26513
26514   arg1 = (Dali::TouchData *)jarg1;
26515   arg2 = (std::size_t)jarg2;
26516   {
26517     try {
26518       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26519     } catch (std::out_of_range& e) {
26520       {
26521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26522       };
26523     } catch (std::exception& e) {
26524       {
26525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26526       };
26527     } catch (...) {
26528       {
26529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26530       };
26531     }
26532   }
26533   jresult = result;
26534   return jresult;
26535 }
26536
26537
26538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26539   void * jresult ;
26540   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26541   std::size_t arg2 ;
26542   Dali::Degree result;
26543
26544   arg1 = (Dali::TouchData *)jarg1;
26545   arg2 = (std::size_t)jarg2;
26546   {
26547     try {
26548       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26549     } catch (std::out_of_range& e) {
26550       {
26551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26552       };
26553     } catch (std::exception& e) {
26554       {
26555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26556       };
26557     } catch (...) {
26558       {
26559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26560       };
26561     }
26562   }
26563   jresult = new Dali::Degree((const Dali::Degree &)result);
26564   return jresult;
26565 }
26566
26567
26568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26569   void * jresult ;
26570   Dali::GestureDetector *result = 0 ;
26571
26572   {
26573     try {
26574       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26575     } catch (std::out_of_range& e) {
26576       {
26577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26578       };
26579     } catch (std::exception& e) {
26580       {
26581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26582       };
26583     } catch (...) {
26584       {
26585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26586       };
26587     }
26588   }
26589   jresult = (void *)result;
26590   return jresult;
26591 }
26592
26593
26594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26595   void * jresult ;
26596   Dali::BaseHandle arg1 ;
26597   Dali::BaseHandle *argp1 ;
26598   Dali::GestureDetector result;
26599
26600   argp1 = (Dali::BaseHandle *)jarg1;
26601   if (!argp1) {
26602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26603     return 0;
26604   }
26605   arg1 = *argp1;
26606   {
26607     try {
26608       result = Dali::GestureDetector::DownCast(arg1);
26609     } catch (std::out_of_range& e) {
26610       {
26611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26612       };
26613     } catch (std::exception& e) {
26614       {
26615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26616       };
26617     } catch (...) {
26618       {
26619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26620       };
26621     }
26622   }
26623   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26624   return jresult;
26625 }
26626
26627
26628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26629   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26630
26631   arg1 = (Dali::GestureDetector *)jarg1;
26632   {
26633     try {
26634       delete arg1;
26635     } catch (std::out_of_range& e) {
26636       {
26637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26638       };
26639     } catch (std::exception& e) {
26640       {
26641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26642       };
26643     } catch (...) {
26644       {
26645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26646       };
26647     }
26648   }
26649 }
26650
26651
26652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26653   void * jresult ;
26654   Dali::GestureDetector *arg1 = 0 ;
26655   Dali::GestureDetector *result = 0 ;
26656
26657   arg1 = (Dali::GestureDetector *)jarg1;
26658   if (!arg1) {
26659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26660     return 0;
26661   }
26662   {
26663     try {
26664       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26665     } catch (std::out_of_range& e) {
26666       {
26667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26668       };
26669     } catch (std::exception& e) {
26670       {
26671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26672       };
26673     } catch (...) {
26674       {
26675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26676       };
26677     }
26678   }
26679   jresult = (void *)result;
26680   return jresult;
26681 }
26682
26683
26684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26685   void * jresult ;
26686   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26687   Dali::GestureDetector *arg2 = 0 ;
26688   Dali::GestureDetector *result = 0 ;
26689
26690   arg1 = (Dali::GestureDetector *)jarg1;
26691   arg2 = (Dali::GestureDetector *)jarg2;
26692   if (!arg2) {
26693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26694     return 0;
26695   }
26696   {
26697     try {
26698       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26699     } catch (std::out_of_range& e) {
26700       {
26701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26702       };
26703     } catch (std::exception& e) {
26704       {
26705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26706       };
26707     } catch (...) {
26708       {
26709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26710       };
26711     }
26712   }
26713   jresult = (void *)result;
26714   return jresult;
26715 }
26716
26717
26718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26719   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26720   Dali::Actor arg2 ;
26721   Dali::Actor *argp2 ;
26722
26723   arg1 = (Dali::GestureDetector *)jarg1;
26724   argp2 = (Dali::Actor *)jarg2;
26725   if (!argp2) {
26726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26727     return ;
26728   }
26729   arg2 = *argp2;
26730   {
26731     try {
26732       (arg1)->Attach(arg2);
26733     } catch (std::out_of_range& e) {
26734       {
26735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26736       };
26737     } catch (std::exception& e) {
26738       {
26739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26740       };
26741     } catch (...) {
26742       {
26743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26744       };
26745     }
26746   }
26747 }
26748
26749
26750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26751   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26752   Dali::Actor arg2 ;
26753   Dali::Actor *argp2 ;
26754
26755   arg1 = (Dali::GestureDetector *)jarg1;
26756   argp2 = (Dali::Actor *)jarg2;
26757   if (!argp2) {
26758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26759     return ;
26760   }
26761   arg2 = *argp2;
26762   {
26763     try {
26764       (arg1)->Detach(arg2);
26765     } catch (std::out_of_range& e) {
26766       {
26767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26768       };
26769     } catch (std::exception& e) {
26770       {
26771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26772       };
26773     } catch (...) {
26774       {
26775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26776       };
26777     }
26778   }
26779 }
26780
26781
26782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26783   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26784
26785   arg1 = (Dali::GestureDetector *)jarg1;
26786   {
26787     try {
26788       (arg1)->DetachAll();
26789     } catch (std::out_of_range& e) {
26790       {
26791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26792       };
26793     } catch (std::exception& e) {
26794       {
26795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26796       };
26797     } catch (...) {
26798       {
26799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26800       };
26801     }
26802   }
26803 }
26804
26805
26806 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26807   unsigned long jresult ;
26808   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26809   size_t result;
26810
26811   arg1 = (Dali::GestureDetector *)jarg1;
26812   {
26813     try {
26814       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26815     } catch (std::out_of_range& e) {
26816       {
26817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26818       };
26819     } catch (std::exception& e) {
26820       {
26821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26822       };
26823     } catch (...) {
26824       {
26825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26826       };
26827     }
26828   }
26829   jresult = (unsigned long)result;
26830   return jresult;
26831 }
26832
26833
26834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26835   void * jresult ;
26836   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26837   size_t arg2 ;
26838   Dali::Actor result;
26839
26840   arg1 = (Dali::GestureDetector *)jarg1;
26841   arg2 = (size_t)jarg2;
26842   {
26843     try {
26844       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26845     } catch (std::out_of_range& e) {
26846       {
26847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26848       };
26849     } catch (std::exception& e) {
26850       {
26851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26852       };
26853     } catch (...) {
26854       {
26855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26856       };
26857     }
26858   }
26859   jresult = new Dali::Actor((const Dali::Actor &)result);
26860   return jresult;
26861 }
26862
26863
26864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26865   void * jresult ;
26866   Dali::Gesture *arg1 = 0 ;
26867   Dali::Gesture *result = 0 ;
26868
26869   arg1 = (Dali::Gesture *)jarg1;
26870   if (!arg1) {
26871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26872     return 0;
26873   }
26874   {
26875     try {
26876       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26877     } catch (std::out_of_range& e) {
26878       {
26879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26880       };
26881     } catch (std::exception& e) {
26882       {
26883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26884       };
26885     } catch (...) {
26886       {
26887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26888       };
26889     }
26890   }
26891   jresult = (void *)result;
26892   return jresult;
26893 }
26894
26895
26896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26897   void * jresult ;
26898   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26899   Dali::Gesture *arg2 = 0 ;
26900   Dali::Gesture *result = 0 ;
26901
26902   arg1 = (Dali::Gesture *)jarg1;
26903   arg2 = (Dali::Gesture *)jarg2;
26904   if (!arg2) {
26905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26906     return 0;
26907   }
26908   {
26909     try {
26910       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26911     } catch (std::out_of_range& e) {
26912       {
26913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26914       };
26915     } catch (std::exception& e) {
26916       {
26917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26918       };
26919     } catch (...) {
26920       {
26921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26922       };
26923     }
26924   }
26925   jresult = (void *)result;
26926   return jresult;
26927 }
26928
26929
26930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26931   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26932
26933   arg1 = (Dali::Gesture *)jarg1;
26934   {
26935     try {
26936       delete arg1;
26937     } catch (std::out_of_range& e) {
26938       {
26939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26940       };
26941     } catch (std::exception& e) {
26942       {
26943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26944       };
26945     } catch (...) {
26946       {
26947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26948       };
26949     }
26950   }
26951 }
26952
26953
26954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26955   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26956   Dali::Gesture::Type arg2 ;
26957
26958   arg1 = (Dali::Gesture *)jarg1;
26959   arg2 = (Dali::Gesture::Type)jarg2;
26960   if (arg1) (arg1)->type = arg2;
26961 }
26962
26963
26964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26965   int jresult ;
26966   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26967   Dali::Gesture::Type result;
26968
26969   arg1 = (Dali::Gesture *)jarg1;
26970   result = (Dali::Gesture::Type) ((arg1)->type);
26971   jresult = (int)result;
26972   return jresult;
26973 }
26974
26975
26976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26977   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26978   Dali::Gesture::State arg2 ;
26979
26980   arg1 = (Dali::Gesture *)jarg1;
26981   arg2 = (Dali::Gesture::State)jarg2;
26982   if (arg1) (arg1)->state = arg2;
26983 }
26984
26985
26986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26987   int jresult ;
26988   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26989   Dali::Gesture::State result;
26990
26991   arg1 = (Dali::Gesture *)jarg1;
26992   result = (Dali::Gesture::State) ((arg1)->state);
26993   jresult = (int)result;
26994   return jresult;
26995 }
26996
26997
26998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26999   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27000   unsigned int arg2 ;
27001
27002   arg1 = (Dali::Gesture *)jarg1;
27003   arg2 = (unsigned int)jarg2;
27004   if (arg1) (arg1)->time = arg2;
27005 }
27006
27007
27008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
27009   unsigned int jresult ;
27010   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27011   unsigned int result;
27012
27013   arg1 = (Dali::Gesture *)jarg1;
27014   result = (unsigned int) ((arg1)->time);
27015   jresult = result;
27016   return jresult;
27017 }
27018
27019
27020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
27021   void * jresult ;
27022   Dali::HoverEvent *result = 0 ;
27023
27024   {
27025     try {
27026       result = (Dali::HoverEvent *)new Dali::HoverEvent();
27027     } catch (std::out_of_range& e) {
27028       {
27029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27030       };
27031     } catch (std::exception& e) {
27032       {
27033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27034       };
27035     } catch (...) {
27036       {
27037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27038       };
27039     }
27040   }
27041   jresult = (void *)result;
27042   return jresult;
27043 }
27044
27045
27046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
27047   void * jresult ;
27048   unsigned long arg1 ;
27049   Dali::HoverEvent *result = 0 ;
27050
27051   arg1 = (unsigned long)jarg1;
27052   {
27053     try {
27054       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
27055     } catch (std::out_of_range& e) {
27056       {
27057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27058       };
27059     } catch (std::exception& e) {
27060       {
27061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27062       };
27063     } catch (...) {
27064       {
27065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27066       };
27067     }
27068   }
27069   jresult = (void *)result;
27070   return jresult;
27071 }
27072
27073
27074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27075   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27076
27077   arg1 = (Dali::HoverEvent *)jarg1;
27078   {
27079     try {
27080       delete arg1;
27081     } catch (std::out_of_range& e) {
27082       {
27083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27084       };
27085     } catch (std::exception& e) {
27086       {
27087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27088       };
27089     } catch (...) {
27090       {
27091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27092       };
27093     }
27094   }
27095 }
27096
27097
27098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27099   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27100   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27101
27102   arg1 = (Dali::HoverEvent *)jarg1;
27103   arg2 = (Dali::TouchPointContainer *)jarg2;
27104   if (arg1) (arg1)->points = *arg2;
27105 }
27106
27107
27108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27109   void * jresult ;
27110   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27111   Dali::TouchPointContainer *result = 0 ;
27112
27113   arg1 = (Dali::HoverEvent *)jarg1;
27114   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27115   jresult = (void *)result;
27116   return jresult;
27117 }
27118
27119
27120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27121   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27122   unsigned long arg2 ;
27123
27124   arg1 = (Dali::HoverEvent *)jarg1;
27125   arg2 = (unsigned long)jarg2;
27126   if (arg1) (arg1)->time = arg2;
27127 }
27128
27129
27130 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27131   unsigned long jresult ;
27132   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27133   unsigned long result;
27134
27135   arg1 = (Dali::HoverEvent *)jarg1;
27136   result = (unsigned long) ((arg1)->time);
27137   jresult = (unsigned long)result;
27138   return jresult;
27139 }
27140
27141
27142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27143   unsigned int jresult ;
27144   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27145   unsigned int result;
27146
27147   arg1 = (Dali::HoverEvent *)jarg1;
27148   {
27149     try {
27150       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27151     } catch (std::out_of_range& e) {
27152       {
27153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27154       };
27155     } catch (std::exception& e) {
27156       {
27157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27158       };
27159     } catch (...) {
27160       {
27161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27162       };
27163     }
27164   }
27165   jresult = result;
27166   return jresult;
27167 }
27168
27169
27170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27171   void * jresult ;
27172   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27173   unsigned int arg2 ;
27174   Dali::TouchPoint *result = 0 ;
27175
27176   arg1 = (Dali::HoverEvent *)jarg1;
27177   arg2 = (unsigned int)jarg2;
27178   {
27179     try {
27180       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27181     } catch (std::out_of_range& e) {
27182       {
27183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27184       };
27185     } catch (std::exception& e) {
27186       {
27187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27188       };
27189     } catch (...) {
27190       {
27191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27192       };
27193     }
27194   }
27195   jresult = (void *)result;
27196   return jresult;
27197 }
27198
27199
27200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27201   void * jresult ;
27202   Dali::KeyEvent *result = 0 ;
27203
27204   {
27205     try {
27206       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27207     } catch (std::out_of_range& e) {
27208       {
27209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27210       };
27211     } catch (std::exception& e) {
27212       {
27213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27214       };
27215     } catch (...) {
27216       {
27217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27218       };
27219     }
27220   }
27221   jresult = (void *)result;
27222   return jresult;
27223 }
27224
27225
27226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27227   void * jresult ;
27228   std::string *arg1 = 0 ;
27229   std::string *arg2 = 0 ;
27230   int arg3 ;
27231   int arg4 ;
27232   unsigned long arg5 ;
27233   Dali::KeyEvent::State *arg6 = 0 ;
27234   Dali::KeyEvent::State temp6 ;
27235   Dali::KeyEvent *result = 0 ;
27236
27237   if (!jarg1) {
27238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27239     return 0;
27240   }
27241   std::string arg1_str(jarg1);
27242   arg1 = &arg1_str;
27243   if (!jarg2) {
27244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27245     return 0;
27246   }
27247   std::string arg2_str(jarg2);
27248   arg2 = &arg2_str;
27249   arg3 = (int)jarg3;
27250   arg4 = (int)jarg4;
27251   arg5 = (unsigned long)jarg5;
27252   temp6 = (Dali::KeyEvent::State)jarg6;
27253   arg6 = &temp6;
27254   {
27255     try {
27256       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27257     } catch (std::out_of_range& e) {
27258       {
27259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27260       };
27261     } catch (std::exception& e) {
27262       {
27263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27264       };
27265     } catch (...) {
27266       {
27267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27268       };
27269     }
27270   }
27271   jresult = (void *)result;
27272
27273   //argout typemap for const std::string&
27274
27275
27276   //argout typemap for const std::string&
27277
27278   return jresult;
27279 }
27280
27281
27282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27283   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27284
27285   arg1 = (Dali::KeyEvent *)jarg1;
27286   {
27287     try {
27288       delete arg1;
27289     } catch (std::out_of_range& e) {
27290       {
27291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27292       };
27293     } catch (std::exception& e) {
27294       {
27295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27296       };
27297     } catch (...) {
27298       {
27299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27300       };
27301     }
27302   }
27303 }
27304
27305
27306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27307   unsigned int jresult ;
27308   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27309   bool result;
27310
27311   arg1 = (Dali::KeyEvent *)jarg1;
27312   {
27313     try {
27314       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27315     } catch (std::out_of_range& e) {
27316       {
27317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27318       };
27319     } catch (std::exception& e) {
27320       {
27321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27322       };
27323     } catch (...) {
27324       {
27325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27326       };
27327     }
27328   }
27329   jresult = result;
27330   return jresult;
27331 }
27332
27333
27334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27335   unsigned int jresult ;
27336   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27337   bool result;
27338
27339   arg1 = (Dali::KeyEvent *)jarg1;
27340   {
27341     try {
27342       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27343     } catch (std::out_of_range& e) {
27344       {
27345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27346       };
27347     } catch (std::exception& e) {
27348       {
27349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27350       };
27351     } catch (...) {
27352       {
27353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27354       };
27355     }
27356   }
27357   jresult = result;
27358   return jresult;
27359 }
27360
27361
27362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27363   unsigned int jresult ;
27364   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27365   bool result;
27366
27367   arg1 = (Dali::KeyEvent *)jarg1;
27368   {
27369     try {
27370       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27371     } catch (std::out_of_range& e) {
27372       {
27373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27374       };
27375     } catch (std::exception& e) {
27376       {
27377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27378       };
27379     } catch (...) {
27380       {
27381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27382       };
27383     }
27384   }
27385   jresult = result;
27386   return jresult;
27387 }
27388
27389
27390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27391   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27392   std::string *arg2 = 0 ;
27393
27394   arg1 = (Dali::KeyEvent *)jarg1;
27395   if (!jarg2) {
27396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27397     return ;
27398   }
27399   std::string arg2_str(jarg2);
27400   arg2 = &arg2_str;
27401   if (arg1) (arg1)->keyPressedName = *arg2;
27402
27403   //argout typemap for const std::string&
27404
27405 }
27406
27407
27408 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27409   char * jresult ;
27410   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27411   std::string *result = 0 ;
27412
27413   arg1 = (Dali::KeyEvent *)jarg1;
27414   result = (std::string *) & ((arg1)->keyPressedName);
27415   jresult = SWIG_csharp_string_callback(result->c_str());
27416   return jresult;
27417 }
27418
27419
27420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27421   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27422   std::string *arg2 = 0 ;
27423
27424   arg1 = (Dali::KeyEvent *)jarg1;
27425   if (!jarg2) {
27426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27427     return ;
27428   }
27429   std::string arg2_str(jarg2);
27430   arg2 = &arg2_str;
27431   if (arg1) (arg1)->keyPressed = *arg2;
27432
27433   //argout typemap for const std::string&
27434
27435 }
27436
27437
27438 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27439   char * jresult ;
27440   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27441   std::string *result = 0 ;
27442
27443   arg1 = (Dali::KeyEvent *)jarg1;
27444   result = (std::string *) & ((arg1)->keyPressed);
27445   jresult = SWIG_csharp_string_callback(result->c_str());
27446   return jresult;
27447 }
27448
27449
27450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27451   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27452   int arg2 ;
27453
27454   arg1 = (Dali::KeyEvent *)jarg1;
27455   arg2 = (int)jarg2;
27456   if (arg1) (arg1)->keyCode = arg2;
27457 }
27458
27459
27460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27461   int jresult ;
27462   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27463   int result;
27464
27465   arg1 = (Dali::KeyEvent *)jarg1;
27466   result = (int) ((arg1)->keyCode);
27467   jresult = result;
27468   return jresult;
27469 }
27470
27471
27472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27473   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27474   int arg2 ;
27475
27476   arg1 = (Dali::KeyEvent *)jarg1;
27477   arg2 = (int)jarg2;
27478   if (arg1) (arg1)->keyModifier = arg2;
27479 }
27480
27481
27482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27483   int jresult ;
27484   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27485   int result;
27486
27487   arg1 = (Dali::KeyEvent *)jarg1;
27488   result = (int) ((arg1)->keyModifier);
27489   jresult = result;
27490   return jresult;
27491 }
27492
27493
27494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27495   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27496   unsigned long arg2 ;
27497
27498   arg1 = (Dali::KeyEvent *)jarg1;
27499   arg2 = (unsigned long)jarg2;
27500   if (arg1) (arg1)->time = arg2;
27501 }
27502
27503
27504 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27505   unsigned long jresult ;
27506   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27507   unsigned long result;
27508
27509   arg1 = (Dali::KeyEvent *)jarg1;
27510   result = (unsigned long) ((arg1)->time);
27511   jresult = (unsigned long)result;
27512   return jresult;
27513 }
27514
27515
27516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27517   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27518   Dali::KeyEvent::State arg2 ;
27519
27520   arg1 = (Dali::KeyEvent *)jarg1;
27521   arg2 = (Dali::KeyEvent::State)jarg2;
27522   if (arg1) (arg1)->state = arg2;
27523 }
27524
27525
27526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27527   int jresult ;
27528   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27529   Dali::KeyEvent::State result;
27530
27531   arg1 = (Dali::KeyEvent *)jarg1;
27532   result = (Dali::KeyEvent::State) ((arg1)->state);
27533   jresult = (int)result;
27534   return jresult;
27535 }
27536
27537
27538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27539   void * jresult ;
27540   Dali::LongPressGestureDetector *result = 0 ;
27541
27542   {
27543     try {
27544       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27545     } catch (std::out_of_range& e) {
27546       {
27547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27548       };
27549     } catch (std::exception& e) {
27550       {
27551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27552       };
27553     } catch (...) {
27554       {
27555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27556       };
27557     }
27558   }
27559   jresult = (void *)result;
27560   return jresult;
27561 }
27562
27563
27564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27565   void * jresult ;
27566   Dali::LongPressGestureDetector result;
27567
27568   {
27569     try {
27570       result = Dali::LongPressGestureDetector::New();
27571     } catch (std::out_of_range& e) {
27572       {
27573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27574       };
27575     } catch (std::exception& e) {
27576       {
27577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27578       };
27579     } catch (...) {
27580       {
27581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27582       };
27583     }
27584   }
27585   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27586   return jresult;
27587 }
27588
27589
27590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27591   void * jresult ;
27592   unsigned int arg1 ;
27593   Dali::LongPressGestureDetector result;
27594
27595   arg1 = (unsigned int)jarg1;
27596   {
27597     try {
27598       result = Dali::LongPressGestureDetector::New(arg1);
27599     } catch (std::out_of_range& e) {
27600       {
27601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27602       };
27603     } catch (std::exception& e) {
27604       {
27605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27606       };
27607     } catch (...) {
27608       {
27609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27610       };
27611     }
27612   }
27613   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27614   return jresult;
27615 }
27616
27617
27618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27619   void * jresult ;
27620   unsigned int arg1 ;
27621   unsigned int arg2 ;
27622   Dali::LongPressGestureDetector result;
27623
27624   arg1 = (unsigned int)jarg1;
27625   arg2 = (unsigned int)jarg2;
27626   {
27627     try {
27628       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27629     } catch (std::out_of_range& e) {
27630       {
27631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27632       };
27633     } catch (std::exception& e) {
27634       {
27635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27636       };
27637     } catch (...) {
27638       {
27639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27640       };
27641     }
27642   }
27643   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27644   return jresult;
27645 }
27646
27647
27648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27649   void * jresult ;
27650   Dali::BaseHandle arg1 ;
27651   Dali::BaseHandle *argp1 ;
27652   Dali::LongPressGestureDetector result;
27653
27654   argp1 = (Dali::BaseHandle *)jarg1;
27655   if (!argp1) {
27656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27657     return 0;
27658   }
27659   arg1 = *argp1;
27660   {
27661     try {
27662       result = Dali::LongPressGestureDetector::DownCast(arg1);
27663     } catch (std::out_of_range& e) {
27664       {
27665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27666       };
27667     } catch (std::exception& e) {
27668       {
27669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27670       };
27671     } catch (...) {
27672       {
27673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27674       };
27675     }
27676   }
27677   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27678   return jresult;
27679 }
27680
27681
27682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27683   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27684
27685   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27686   {
27687     try {
27688       delete arg1;
27689     } catch (std::out_of_range& e) {
27690       {
27691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27692       };
27693     } catch (std::exception& e) {
27694       {
27695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27696       };
27697     } catch (...) {
27698       {
27699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27700       };
27701     }
27702   }
27703 }
27704
27705
27706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27707   void * jresult ;
27708   Dali::LongPressGestureDetector *arg1 = 0 ;
27709   Dali::LongPressGestureDetector *result = 0 ;
27710
27711   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27712   if (!arg1) {
27713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27714     return 0;
27715   }
27716   {
27717     try {
27718       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27719     } catch (std::out_of_range& e) {
27720       {
27721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27722       };
27723     } catch (std::exception& e) {
27724       {
27725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27726       };
27727     } catch (...) {
27728       {
27729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27730       };
27731     }
27732   }
27733   jresult = (void *)result;
27734   return jresult;
27735 }
27736
27737
27738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27739   void * jresult ;
27740   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27741   Dali::LongPressGestureDetector *arg2 = 0 ;
27742   Dali::LongPressGestureDetector *result = 0 ;
27743
27744   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27745   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27746   if (!arg2) {
27747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27748     return 0;
27749   }
27750   {
27751     try {
27752       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27753     } catch (std::out_of_range& e) {
27754       {
27755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27756       };
27757     } catch (std::exception& e) {
27758       {
27759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27760       };
27761     } catch (...) {
27762       {
27763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27764       };
27765     }
27766   }
27767   jresult = (void *)result;
27768   return jresult;
27769 }
27770
27771
27772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27773   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27774   unsigned int arg2 ;
27775
27776   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27777   arg2 = (unsigned int)jarg2;
27778   {
27779     try {
27780       (arg1)->SetTouchesRequired(arg2);
27781     } catch (std::out_of_range& e) {
27782       {
27783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27784       };
27785     } catch (std::exception& e) {
27786       {
27787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27788       };
27789     } catch (...) {
27790       {
27791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27792       };
27793     }
27794   }
27795 }
27796
27797
27798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27799   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27800   unsigned int arg2 ;
27801   unsigned int arg3 ;
27802
27803   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27804   arg2 = (unsigned int)jarg2;
27805   arg3 = (unsigned int)jarg3;
27806   {
27807     try {
27808       (arg1)->SetTouchesRequired(arg2,arg3);
27809     } catch (std::out_of_range& e) {
27810       {
27811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27812       };
27813     } catch (std::exception& e) {
27814       {
27815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27816       };
27817     } catch (...) {
27818       {
27819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27820       };
27821     }
27822   }
27823 }
27824
27825
27826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27827   unsigned int jresult ;
27828   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27829   unsigned int result;
27830
27831   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27832   {
27833     try {
27834       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27835     } catch (std::out_of_range& e) {
27836       {
27837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27838       };
27839     } catch (std::exception& e) {
27840       {
27841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27842       };
27843     } catch (...) {
27844       {
27845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27846       };
27847     }
27848   }
27849   jresult = result;
27850   return jresult;
27851 }
27852
27853
27854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27855   unsigned int jresult ;
27856   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27857   unsigned int result;
27858
27859   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27860   {
27861     try {
27862       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27863     } catch (std::out_of_range& e) {
27864       {
27865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27866       };
27867     } catch (std::exception& e) {
27868       {
27869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27870       };
27871     } catch (...) {
27872       {
27873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27874       };
27875     }
27876   }
27877   jresult = result;
27878   return jresult;
27879 }
27880
27881
27882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27883   void * jresult ;
27884   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27885   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27886
27887   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27888   {
27889     try {
27890       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27891     } catch (std::out_of_range& e) {
27892       {
27893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27894       };
27895     } catch (std::exception& e) {
27896       {
27897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27898       };
27899     } catch (...) {
27900       {
27901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27902       };
27903     }
27904   }
27905   jresult = (void *)result;
27906   return jresult;
27907 }
27908
27909
27910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27911   void * jresult ;
27912   Dali::Gesture::State arg1 ;
27913   Dali::LongPressGesture *result = 0 ;
27914
27915   arg1 = (Dali::Gesture::State)jarg1;
27916   {
27917     try {
27918       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27919     } catch (std::out_of_range& e) {
27920       {
27921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27922       };
27923     } catch (std::exception& e) {
27924       {
27925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27926       };
27927     } catch (...) {
27928       {
27929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27930       };
27931     }
27932   }
27933   jresult = (void *)result;
27934   return jresult;
27935 }
27936
27937
27938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27939   void * jresult ;
27940   Dali::LongPressGesture *arg1 = 0 ;
27941   Dali::LongPressGesture *result = 0 ;
27942
27943   arg1 = (Dali::LongPressGesture *)jarg1;
27944   if (!arg1) {
27945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27946     return 0;
27947   }
27948   {
27949     try {
27950       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27951     } catch (std::out_of_range& e) {
27952       {
27953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27954       };
27955     } catch (std::exception& e) {
27956       {
27957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27958       };
27959     } catch (...) {
27960       {
27961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27962       };
27963     }
27964   }
27965   jresult = (void *)result;
27966   return jresult;
27967 }
27968
27969
27970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27971   void * jresult ;
27972   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27973   Dali::LongPressGesture *arg2 = 0 ;
27974   Dali::LongPressGesture *result = 0 ;
27975
27976   arg1 = (Dali::LongPressGesture *)jarg1;
27977   arg2 = (Dali::LongPressGesture *)jarg2;
27978   if (!arg2) {
27979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27980     return 0;
27981   }
27982   {
27983     try {
27984       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27985     } catch (std::out_of_range& e) {
27986       {
27987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27988       };
27989     } catch (std::exception& e) {
27990       {
27991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27992       };
27993     } catch (...) {
27994       {
27995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27996       };
27997     }
27998   }
27999   jresult = (void *)result;
28000   return jresult;
28001 }
28002
28003
28004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28005   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28006
28007   arg1 = (Dali::LongPressGesture *)jarg1;
28008   {
28009     try {
28010       delete arg1;
28011     } catch (std::out_of_range& e) {
28012       {
28013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28014       };
28015     } catch (std::exception& e) {
28016       {
28017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28018       };
28019     } catch (...) {
28020       {
28021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28022       };
28023     }
28024   }
28025 }
28026
28027
28028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28029   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28030   unsigned int arg2 ;
28031
28032   arg1 = (Dali::LongPressGesture *)jarg1;
28033   arg2 = (unsigned int)jarg2;
28034   if (arg1) (arg1)->numberOfTouches = arg2;
28035 }
28036
28037
28038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28039   unsigned int jresult ;
28040   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28041   unsigned int result;
28042
28043   arg1 = (Dali::LongPressGesture *)jarg1;
28044   result = (unsigned int) ((arg1)->numberOfTouches);
28045   jresult = result;
28046   return jresult;
28047 }
28048
28049
28050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28051   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28052   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28053
28054   arg1 = (Dali::LongPressGesture *)jarg1;
28055   arg2 = (Dali::Vector2 *)jarg2;
28056   if (arg1) (arg1)->screenPoint = *arg2;
28057 }
28058
28059
28060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28061   void * jresult ;
28062   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28063   Dali::Vector2 *result = 0 ;
28064
28065   arg1 = (Dali::LongPressGesture *)jarg1;
28066   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28067   jresult = (void *)result;
28068   return jresult;
28069 }
28070
28071
28072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28073   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28074   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28075
28076   arg1 = (Dali::LongPressGesture *)jarg1;
28077   arg2 = (Dali::Vector2 *)jarg2;
28078   if (arg1) (arg1)->localPoint = *arg2;
28079 }
28080
28081
28082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28083   void * jresult ;
28084   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28085   Dali::Vector2 *result = 0 ;
28086
28087   arg1 = (Dali::LongPressGesture *)jarg1;
28088   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28089   jresult = (void *)result;
28090   return jresult;
28091 }
28092
28093
28094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28095   void * jresult ;
28096   Dali::WheelEvent *result = 0 ;
28097
28098   {
28099     try {
28100       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28101     } catch (std::out_of_range& e) {
28102       {
28103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28104       };
28105     } catch (std::exception& e) {
28106       {
28107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28108       };
28109     } catch (...) {
28110       {
28111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28112       };
28113     }
28114   }
28115   jresult = (void *)result;
28116   return jresult;
28117 }
28118
28119
28120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28121   void * jresult ;
28122   Dali::WheelEvent::Type arg1 ;
28123   int arg2 ;
28124   unsigned int arg3 ;
28125   Dali::Vector2 arg4 ;
28126   int arg5 ;
28127   unsigned int arg6 ;
28128   Dali::Vector2 *argp4 ;
28129   Dali::WheelEvent *result = 0 ;
28130
28131   arg1 = (Dali::WheelEvent::Type)jarg1;
28132   arg2 = (int)jarg2;
28133   arg3 = (unsigned int)jarg3;
28134   argp4 = (Dali::Vector2 *)jarg4;
28135   if (!argp4) {
28136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28137     return 0;
28138   }
28139   arg4 = *argp4;
28140   arg5 = (int)jarg5;
28141   arg6 = (unsigned int)jarg6;
28142   {
28143     try {
28144       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28145     } catch (std::out_of_range& e) {
28146       {
28147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28148       };
28149     } catch (std::exception& e) {
28150       {
28151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28152       };
28153     } catch (...) {
28154       {
28155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28156       };
28157     }
28158   }
28159   jresult = (void *)result;
28160   return jresult;
28161 }
28162
28163
28164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28165   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28166
28167   arg1 = (Dali::WheelEvent *)jarg1;
28168   {
28169     try {
28170       delete arg1;
28171     } catch (std::out_of_range& e) {
28172       {
28173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28174       };
28175     } catch (std::exception& e) {
28176       {
28177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28178       };
28179     } catch (...) {
28180       {
28181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28182       };
28183     }
28184   }
28185 }
28186
28187
28188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28189   unsigned int jresult ;
28190   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28191   bool result;
28192
28193   arg1 = (Dali::WheelEvent *)jarg1;
28194   {
28195     try {
28196       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28197     } catch (std::out_of_range& e) {
28198       {
28199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28200       };
28201     } catch (std::exception& e) {
28202       {
28203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28204       };
28205     } catch (...) {
28206       {
28207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28208       };
28209     }
28210   }
28211   jresult = result;
28212   return jresult;
28213 }
28214
28215
28216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28217   unsigned int jresult ;
28218   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28219   bool result;
28220
28221   arg1 = (Dali::WheelEvent *)jarg1;
28222   {
28223     try {
28224       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28225     } catch (std::out_of_range& e) {
28226       {
28227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28228       };
28229     } catch (std::exception& e) {
28230       {
28231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28232       };
28233     } catch (...) {
28234       {
28235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28236       };
28237     }
28238   }
28239   jresult = result;
28240   return jresult;
28241 }
28242
28243
28244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28245   unsigned int jresult ;
28246   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28247   bool result;
28248
28249   arg1 = (Dali::WheelEvent *)jarg1;
28250   {
28251     try {
28252       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28253     } catch (std::out_of_range& e) {
28254       {
28255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28256       };
28257     } catch (std::exception& e) {
28258       {
28259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28260       };
28261     } catch (...) {
28262       {
28263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28264       };
28265     }
28266   }
28267   jresult = result;
28268   return jresult;
28269 }
28270
28271
28272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28273   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28274   Dali::WheelEvent::Type arg2 ;
28275
28276   arg1 = (Dali::WheelEvent *)jarg1;
28277   arg2 = (Dali::WheelEvent::Type)jarg2;
28278   if (arg1) (arg1)->type = arg2;
28279 }
28280
28281
28282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28283   int jresult ;
28284   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28285   Dali::WheelEvent::Type result;
28286
28287   arg1 = (Dali::WheelEvent *)jarg1;
28288   result = (Dali::WheelEvent::Type) ((arg1)->type);
28289   jresult = (int)result;
28290   return jresult;
28291 }
28292
28293
28294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28295   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28296   int arg2 ;
28297
28298   arg1 = (Dali::WheelEvent *)jarg1;
28299   arg2 = (int)jarg2;
28300   if (arg1) (arg1)->direction = arg2;
28301 }
28302
28303
28304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28305   int jresult ;
28306   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28307   int result;
28308
28309   arg1 = (Dali::WheelEvent *)jarg1;
28310   result = (int) ((arg1)->direction);
28311   jresult = result;
28312   return jresult;
28313 }
28314
28315
28316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28317   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28318   unsigned int arg2 ;
28319
28320   arg1 = (Dali::WheelEvent *)jarg1;
28321   arg2 = (unsigned int)jarg2;
28322   if (arg1) (arg1)->modifiers = arg2;
28323 }
28324
28325
28326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28327   unsigned int jresult ;
28328   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28329   unsigned int result;
28330
28331   arg1 = (Dali::WheelEvent *)jarg1;
28332   result = (unsigned int) ((arg1)->modifiers);
28333   jresult = result;
28334   return jresult;
28335 }
28336
28337
28338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28339   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28340   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28341
28342   arg1 = (Dali::WheelEvent *)jarg1;
28343   arg2 = (Dali::Vector2 *)jarg2;
28344   if (arg1) (arg1)->point = *arg2;
28345 }
28346
28347
28348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28349   void * jresult ;
28350   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28351   Dali::Vector2 *result = 0 ;
28352
28353   arg1 = (Dali::WheelEvent *)jarg1;
28354   result = (Dali::Vector2 *)& ((arg1)->point);
28355   jresult = (void *)result;
28356   return jresult;
28357 }
28358
28359
28360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28361   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28362   int arg2 ;
28363
28364   arg1 = (Dali::WheelEvent *)jarg1;
28365   arg2 = (int)jarg2;
28366   if (arg1) (arg1)->z = arg2;
28367 }
28368
28369
28370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28371   int jresult ;
28372   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28373   int result;
28374
28375   arg1 = (Dali::WheelEvent *)jarg1;
28376   result = (int) ((arg1)->z);
28377   jresult = result;
28378   return jresult;
28379 }
28380
28381
28382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28383   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28384   unsigned int arg2 ;
28385
28386   arg1 = (Dali::WheelEvent *)jarg1;
28387   arg2 = (unsigned int)jarg2;
28388   if (arg1) (arg1)->timeStamp = arg2;
28389 }
28390
28391
28392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28393   unsigned int jresult ;
28394   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28395   unsigned int result;
28396
28397   arg1 = (Dali::WheelEvent *)jarg1;
28398   result = (unsigned int) ((arg1)->timeStamp);
28399   jresult = result;
28400   return jresult;
28401 }
28402
28403
28404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28405   int jresult ;
28406   int result;
28407
28408   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28409   jresult = (int)result;
28410   return jresult;
28411 }
28412
28413
28414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28415   int jresult ;
28416   int result;
28417
28418   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28419   jresult = (int)result;
28420   return jresult;
28421 }
28422
28423
28424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28425   int jresult ;
28426   int result;
28427
28428   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28429   jresult = (int)result;
28430   return jresult;
28431 }
28432
28433
28434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28435   int jresult ;
28436   int result;
28437
28438   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28439   jresult = (int)result;
28440   return jresult;
28441 }
28442
28443
28444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28445   int jresult ;
28446   int result;
28447
28448   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28449   jresult = (int)result;
28450   return jresult;
28451 }
28452
28453
28454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28455   int jresult ;
28456   int result;
28457
28458   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28459   jresult = (int)result;
28460   return jresult;
28461 }
28462
28463
28464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28465   int jresult ;
28466   int result;
28467
28468   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28469   jresult = (int)result;
28470   return jresult;
28471 }
28472
28473
28474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28475   int jresult ;
28476   int result;
28477
28478   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28479   jresult = (int)result;
28480   return jresult;
28481 }
28482
28483
28484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28485   int jresult ;
28486   int result;
28487
28488   result = (int)Dali::Actor::Property::SIZE;
28489   jresult = (int)result;
28490   return jresult;
28491 }
28492
28493
28494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28495   int jresult ;
28496   int result;
28497
28498   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28499   jresult = (int)result;
28500   return jresult;
28501 }
28502
28503
28504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28505   int jresult ;
28506   int result;
28507
28508   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28509   jresult = (int)result;
28510   return jresult;
28511 }
28512
28513
28514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28515   int jresult ;
28516   int result;
28517
28518   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28519   jresult = (int)result;
28520   return jresult;
28521 }
28522
28523
28524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28525   int jresult ;
28526   int result;
28527
28528   result = (int)Dali::Actor::Property::POSITION;
28529   jresult = (int)result;
28530   return jresult;
28531 }
28532
28533
28534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28535   int jresult ;
28536   int result;
28537
28538   result = (int)Dali::Actor::Property::POSITION_X;
28539   jresult = (int)result;
28540   return jresult;
28541 }
28542
28543
28544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28545   int jresult ;
28546   int result;
28547
28548   result = (int)Dali::Actor::Property::POSITION_Y;
28549   jresult = (int)result;
28550   return jresult;
28551 }
28552
28553
28554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28555   int jresult ;
28556   int result;
28557
28558   result = (int)Dali::Actor::Property::POSITION_Z;
28559   jresult = (int)result;
28560   return jresult;
28561 }
28562
28563
28564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28565   int jresult ;
28566   int result;
28567
28568   result = (int)Dali::Actor::Property::WORLD_POSITION;
28569   jresult = (int)result;
28570   return jresult;
28571 }
28572
28573
28574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28575   int jresult ;
28576   int result;
28577
28578   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28579   jresult = (int)result;
28580   return jresult;
28581 }
28582
28583
28584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28585   int jresult ;
28586   int result;
28587
28588   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28589   jresult = (int)result;
28590   return jresult;
28591 }
28592
28593
28594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28595   int jresult ;
28596   int result;
28597
28598   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28599   jresult = (int)result;
28600   return jresult;
28601 }
28602
28603
28604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28605   int jresult ;
28606   int result;
28607
28608   result = (int)Dali::Actor::Property::ORIENTATION;
28609   jresult = (int)result;
28610   return jresult;
28611 }
28612
28613
28614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28615   int jresult ;
28616   int result;
28617
28618   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28619   jresult = (int)result;
28620   return jresult;
28621 }
28622
28623
28624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28625   int jresult ;
28626   int result;
28627
28628   result = (int)Dali::Actor::Property::SCALE;
28629   jresult = (int)result;
28630   return jresult;
28631 }
28632
28633
28634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28635   int jresult ;
28636   int result;
28637
28638   result = (int)Dali::Actor::Property::SCALE_X;
28639   jresult = (int)result;
28640   return jresult;
28641 }
28642
28643
28644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28645   int jresult ;
28646   int result;
28647
28648   result = (int)Dali::Actor::Property::SCALE_Y;
28649   jresult = (int)result;
28650   return jresult;
28651 }
28652
28653
28654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28655   int jresult ;
28656   int result;
28657
28658   result = (int)Dali::Actor::Property::SCALE_Z;
28659   jresult = (int)result;
28660   return jresult;
28661 }
28662
28663
28664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28665   int jresult ;
28666   int result;
28667
28668   result = (int)Dali::Actor::Property::WORLD_SCALE;
28669   jresult = (int)result;
28670   return jresult;
28671 }
28672
28673
28674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28675   int jresult ;
28676   int result;
28677
28678   result = (int)Dali::Actor::Property::VISIBLE;
28679   jresult = (int)result;
28680   return jresult;
28681 }
28682
28683
28684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28685   int jresult ;
28686   int result;
28687
28688   result = (int)Dali::Actor::Property::COLOR;
28689   jresult = (int)result;
28690   return jresult;
28691 }
28692
28693
28694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28695   int jresult ;
28696   int result;
28697
28698   result = (int)Dali::Actor::Property::COLOR_RED;
28699   jresult = (int)result;
28700   return jresult;
28701 }
28702
28703
28704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28705   int jresult ;
28706   int result;
28707
28708   result = (int)Dali::Actor::Property::COLOR_GREEN;
28709   jresult = (int)result;
28710   return jresult;
28711 }
28712
28713
28714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28715   int jresult ;
28716   int result;
28717
28718   result = (int)Dali::Actor::Property::COLOR_BLUE;
28719   jresult = (int)result;
28720   return jresult;
28721 }
28722
28723
28724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
28725   int jresult ;
28726   int result;
28727
28728   result = (int)Dali::Actor::Property::COLOR_ALPHA;
28729   jresult = (int)result;
28730   return jresult;
28731 }
28732
28733
28734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
28735   int jresult ;
28736   int result;
28737
28738   result = (int)Dali::Actor::Property::WORLD_COLOR;
28739   jresult = (int)result;
28740   return jresult;
28741 }
28742
28743
28744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
28745   int jresult ;
28746   int result;
28747
28748   result = (int)Dali::Actor::Property::WORLD_MATRIX;
28749   jresult = (int)result;
28750   return jresult;
28751 }
28752
28753
28754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
28755   int jresult ;
28756   int result;
28757
28758   result = (int)Dali::Actor::Property::NAME;
28759   jresult = (int)result;
28760   return jresult;
28761 }
28762
28763
28764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
28765   int jresult ;
28766   int result;
28767
28768   result = (int)Dali::Actor::Property::SENSITIVE;
28769   jresult = (int)result;
28770   return jresult;
28771 }
28772
28773
28774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
28775   int jresult ;
28776   int result;
28777
28778   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
28779   jresult = (int)result;
28780   return jresult;
28781 }
28782
28783
28784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
28785   int jresult ;
28786   int result;
28787
28788   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
28789   jresult = (int)result;
28790   return jresult;
28791 }
28792
28793
28794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
28795   int jresult ;
28796   int result;
28797
28798   result = (int)Dali::Actor::Property::INHERIT_SCALE;
28799   jresult = (int)result;
28800   return jresult;
28801 }
28802
28803
28804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
28805   int jresult ;
28806   int result;
28807
28808   result = (int)Dali::Actor::Property::COLOR_MODE;
28809   jresult = (int)result;
28810   return jresult;
28811 }
28812
28813
28814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
28815   int jresult ;
28816   int result;
28817
28818   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
28819   jresult = (int)result;
28820   return jresult;
28821 }
28822
28823
28824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
28825   int jresult ;
28826   int result;
28827
28828   result = (int)Dali::Actor::Property::DRAW_MODE;
28829   jresult = (int)result;
28830   return jresult;
28831 }
28832
28833
28834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
28835   int jresult ;
28836   int result;
28837
28838   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
28839   jresult = (int)result;
28840   return jresult;
28841 }
28842
28843
28844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
28845   int jresult ;
28846   int result;
28847
28848   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
28849   jresult = (int)result;
28850   return jresult;
28851 }
28852
28853
28854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
28855   int jresult ;
28856   int result;
28857
28858   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
28859   jresult = (int)result;
28860   return jresult;
28861 }
28862
28863
28864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
28865   int jresult ;
28866   int result;
28867
28868   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
28869   jresult = (int)result;
28870   return jresult;
28871 }
28872
28873
28874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
28875   int jresult ;
28876   int result;
28877
28878   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
28879   jresult = (int)result;
28880   return jresult;
28881 }
28882
28883
28884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
28885   int jresult ;
28886   int result;
28887
28888   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
28889   jresult = (int)result;
28890   return jresult;
28891 }
28892
28893
28894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
28895   int jresult ;
28896   int result;
28897
28898   result = (int)Dali::Actor::Property::PADDING;
28899   jresult = (int)result;
28900   return jresult;
28901 }
28902
28903
28904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
28905   int jresult ;
28906   int result;
28907
28908   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
28909   jresult = (int)result;
28910   return jresult;
28911 }
28912
28913
28914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
28915   int jresult ;
28916   int result;
28917
28918   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
28919   jresult = (int)result;
28920   return jresult;
28921 }
28922
28923
28924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
28925   int jresult ;
28926   int result;
28927
28928   result = (int)Dali::Actor::Property::INHERIT_POSITION;
28929   jresult = (int)result;
28930   return jresult;
28931 }
28932
28933
28934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
28935   int jresult ;
28936   int result;
28937
28938   result = (int)Dali::Actor::Property::CLIPPING_MODE;
28939   jresult = (int)result;
28940   return jresult;
28941 }
28942
28943
28944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
28945   void * jresult ;
28946   Dali::Actor::Property *result = 0 ;
28947
28948   {
28949     try {
28950       result = (Dali::Actor::Property *)new Dali::Actor::Property();
28951     } catch (std::out_of_range& e) {
28952       {
28953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28954       };
28955     } catch (std::exception& e) {
28956       {
28957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28958       };
28959     } catch (...) {
28960       {
28961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28962       };
28963     }
28964   }
28965   jresult = (void *)result;
28966   return jresult;
28967 }
28968
28969
28970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
28971   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
28972
28973   arg1 = (Dali::Actor::Property *)jarg1;
28974   {
28975     try {
28976       delete arg1;
28977     } catch (std::out_of_range& e) {
28978       {
28979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28980       };
28981     } catch (std::exception& e) {
28982       {
28983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28984       };
28985     } catch (...) {
28986       {
28987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28988       };
28989     }
28990   }
28991 }
28992
28993
28994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
28995   void * jresult ;
28996   Dali::Actor *result = 0 ;
28997
28998   {
28999     try {
29000       result = (Dali::Actor *)new Dali::Actor();
29001     } catch (std::out_of_range& e) {
29002       {
29003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29004       };
29005     } catch (std::exception& e) {
29006       {
29007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29008       };
29009     } catch (...) {
29010       {
29011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29012       };
29013     }
29014   }
29015   jresult = (void *)result;
29016   return jresult;
29017 }
29018
29019
29020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29021   void * jresult ;
29022   Dali::Actor result;
29023
29024   {
29025     try {
29026       result = Dali::Actor::New();
29027     } catch (std::out_of_range& e) {
29028       {
29029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29030       };
29031     } catch (std::exception& e) {
29032       {
29033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29034       };
29035     } catch (...) {
29036       {
29037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29038       };
29039     }
29040   }
29041   jresult = new Dali::Actor((const Dali::Actor &)result);
29042   return jresult;
29043 }
29044
29045
29046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29047   void * jresult ;
29048   Dali::BaseHandle arg1 ;
29049   Dali::BaseHandle *argp1 ;
29050   Dali::Actor result;
29051
29052   argp1 = (Dali::BaseHandle *)jarg1;
29053   if (!argp1) {
29054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29055     return 0;
29056   }
29057   arg1 = *argp1;
29058   {
29059     try {
29060       result = Dali::Actor::DownCast(arg1);
29061     } catch (std::out_of_range& e) {
29062       {
29063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29064       };
29065     } catch (std::exception& e) {
29066       {
29067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29068       };
29069     } catch (...) {
29070       {
29071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29072       };
29073     }
29074   }
29075   jresult = new Dali::Actor((const Dali::Actor &)result);
29076   return jresult;
29077 }
29078
29079
29080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29081   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29082
29083   arg1 = (Dali::Actor *)jarg1;
29084   {
29085     try {
29086       delete arg1;
29087     } catch (std::out_of_range& e) {
29088       {
29089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29090       };
29091     } catch (std::exception& e) {
29092       {
29093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29094       };
29095     } catch (...) {
29096       {
29097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29098       };
29099     }
29100   }
29101 }
29102
29103
29104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29105   void * jresult ;
29106   Dali::Actor *arg1 = 0 ;
29107   Dali::Actor *result = 0 ;
29108
29109   arg1 = (Dali::Actor *)jarg1;
29110   if (!arg1) {
29111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29112     return 0;
29113   }
29114   {
29115     try {
29116       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29117     } catch (std::out_of_range& e) {
29118       {
29119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29120       };
29121     } catch (std::exception& e) {
29122       {
29123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29124       };
29125     } catch (...) {
29126       {
29127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29128       };
29129     }
29130   }
29131   jresult = (void *)result;
29132   return jresult;
29133 }
29134
29135
29136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29137   void * jresult ;
29138   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29139   Dali::Actor *arg2 = 0 ;
29140   Dali::Actor *result = 0 ;
29141
29142   arg1 = (Dali::Actor *)jarg1;
29143   arg2 = (Dali::Actor *)jarg2;
29144   if (!arg2) {
29145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29146     return 0;
29147   }
29148   {
29149     try {
29150       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29151     } catch (std::out_of_range& e) {
29152       {
29153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29154       };
29155     } catch (std::exception& e) {
29156       {
29157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29158       };
29159     } catch (...) {
29160       {
29161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29162       };
29163     }
29164   }
29165   jresult = (void *)result;
29166   return jresult;
29167 }
29168
29169
29170 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29171   char * jresult ;
29172   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29173   std::string *result = 0 ;
29174
29175   arg1 = (Dali::Actor *)jarg1;
29176   {
29177     try {
29178       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29179     } catch (std::out_of_range& e) {
29180       {
29181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29182       };
29183     } catch (std::exception& e) {
29184       {
29185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29186       };
29187     } catch (...) {
29188       {
29189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29190       };
29191     }
29192   }
29193   jresult = SWIG_csharp_string_callback(result->c_str());
29194   return jresult;
29195 }
29196
29197
29198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29199   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29200   std::string *arg2 = 0 ;
29201
29202   arg1 = (Dali::Actor *)jarg1;
29203   if (!jarg2) {
29204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29205     return ;
29206   }
29207   std::string arg2_str(jarg2);
29208   arg2 = &arg2_str;
29209   {
29210     try {
29211       (arg1)->SetName((std::string const &)*arg2);
29212     } catch (std::out_of_range& e) {
29213       {
29214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29215       };
29216     } catch (std::exception& e) {
29217       {
29218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29219       };
29220     } catch (...) {
29221       {
29222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29223       };
29224     }
29225   }
29226
29227   //argout typemap for const std::string&
29228
29229 }
29230
29231
29232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29233   unsigned int jresult ;
29234   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29235   unsigned int result;
29236
29237   arg1 = (Dali::Actor *)jarg1;
29238   {
29239     try {
29240       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29241     } catch (std::out_of_range& e) {
29242       {
29243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29244       };
29245     } catch (std::exception& e) {
29246       {
29247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29248       };
29249     } catch (...) {
29250       {
29251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29252       };
29253     }
29254   }
29255   jresult = result;
29256   return jresult;
29257 }
29258
29259
29260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29261   unsigned int jresult ;
29262   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29263   bool result;
29264
29265   arg1 = (Dali::Actor *)jarg1;
29266   {
29267     try {
29268       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29269     } catch (std::out_of_range& e) {
29270       {
29271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29272       };
29273     } catch (std::exception& e) {
29274       {
29275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29276       };
29277     } catch (...) {
29278       {
29279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29280       };
29281     }
29282   }
29283   jresult = result;
29284   return jresult;
29285 }
29286
29287
29288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29289   unsigned int jresult ;
29290   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29291   bool result;
29292
29293   arg1 = (Dali::Actor *)jarg1;
29294   {
29295     try {
29296       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29297     } catch (std::out_of_range& e) {
29298       {
29299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29300       };
29301     } catch (std::exception& e) {
29302       {
29303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29304       };
29305     } catch (...) {
29306       {
29307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29308       };
29309     }
29310   }
29311   jresult = result;
29312   return jresult;
29313 }
29314
29315
29316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29317   unsigned int jresult ;
29318   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29319   bool result;
29320
29321   arg1 = (Dali::Actor *)jarg1;
29322   {
29323     try {
29324       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29325     } catch (std::out_of_range& e) {
29326       {
29327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29328       };
29329     } catch (std::exception& e) {
29330       {
29331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29332       };
29333     } catch (...) {
29334       {
29335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29336       };
29337     }
29338   }
29339   jresult = result;
29340   return jresult;
29341 }
29342
29343
29344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29345   void * jresult ;
29346   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29347   Dali::Layer result;
29348
29349   arg1 = (Dali::Actor *)jarg1;
29350   {
29351     try {
29352       result = (arg1)->GetLayer();
29353     } catch (std::out_of_range& e) {
29354       {
29355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29356       };
29357     } catch (std::exception& e) {
29358       {
29359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29360       };
29361     } catch (...) {
29362       {
29363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29364       };
29365     }
29366   }
29367   jresult = new Dali::Layer((const Dali::Layer &)result);
29368   return jresult;
29369 }
29370
29371
29372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29373   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29374   Dali::Actor arg2 ;
29375   Dali::Actor *argp2 ;
29376
29377   arg1 = (Dali::Actor *)jarg1;
29378   argp2 = (Dali::Actor *)jarg2;
29379   if (!argp2) {
29380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29381     return ;
29382   }
29383   arg2 = *argp2;
29384   {
29385     try {
29386       (arg1)->Add(arg2);
29387     } catch (std::out_of_range& e) {
29388       {
29389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29390       };
29391     } catch (std::exception& e) {
29392       {
29393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29394       };
29395     } catch (...) {
29396       {
29397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29398       };
29399     }
29400   }
29401 }
29402
29403
29404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29405   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29406   Dali::Actor arg2 ;
29407   Dali::Actor *argp2 ;
29408
29409   arg1 = (Dali::Actor *)jarg1;
29410   argp2 = (Dali::Actor *)jarg2;
29411   if (!argp2) {
29412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29413     return ;
29414   }
29415   arg2 = *argp2;
29416   {
29417     try {
29418       (arg1)->Remove(arg2);
29419     } catch (std::out_of_range& e) {
29420       {
29421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29422       };
29423     } catch (std::exception& e) {
29424       {
29425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29426       };
29427     } catch (...) {
29428       {
29429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29430       };
29431     }
29432   }
29433 }
29434
29435
29436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29437   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29438
29439   arg1 = (Dali::Actor *)jarg1;
29440   {
29441     try {
29442       (arg1)->Unparent();
29443     } catch (std::out_of_range& e) {
29444       {
29445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29446       };
29447     } catch (std::exception& e) {
29448       {
29449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29450       };
29451     } catch (...) {
29452       {
29453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29454       };
29455     }
29456   }
29457 }
29458
29459
29460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29461   unsigned int jresult ;
29462   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29463   unsigned int result;
29464
29465   arg1 = (Dali::Actor *)jarg1;
29466   {
29467     try {
29468       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29469     } catch (std::out_of_range& e) {
29470       {
29471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29472       };
29473     } catch (std::exception& e) {
29474       {
29475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29476       };
29477     } catch (...) {
29478       {
29479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29480       };
29481     }
29482   }
29483   jresult = result;
29484   return jresult;
29485 }
29486
29487
29488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29489   void * jresult ;
29490   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29491   unsigned int arg2 ;
29492   Dali::Actor result;
29493
29494   arg1 = (Dali::Actor *)jarg1;
29495   arg2 = (unsigned int)jarg2;
29496   {
29497     try {
29498       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29499     } catch (std::out_of_range& e) {
29500       {
29501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29502       };
29503     } catch (std::exception& e) {
29504       {
29505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29506       };
29507     } catch (...) {
29508       {
29509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29510       };
29511     }
29512   }
29513   jresult = new Dali::Actor((const Dali::Actor &)result);
29514   return jresult;
29515 }
29516
29517
29518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29519   void * jresult ;
29520   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29521   std::string *arg2 = 0 ;
29522   Dali::Actor result;
29523
29524   arg1 = (Dali::Actor *)jarg1;
29525   if (!jarg2) {
29526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29527     return 0;
29528   }
29529   std::string arg2_str(jarg2);
29530   arg2 = &arg2_str;
29531   {
29532     try {
29533       result = (arg1)->FindChildByName((std::string const &)*arg2);
29534     } catch (std::out_of_range& e) {
29535       {
29536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29537       };
29538     } catch (std::exception& e) {
29539       {
29540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29541       };
29542     } catch (...) {
29543       {
29544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29545       };
29546     }
29547   }
29548   jresult = new Dali::Actor((const Dali::Actor &)result);
29549
29550   //argout typemap for const std::string&
29551
29552   return jresult;
29553 }
29554
29555
29556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29557   void * jresult ;
29558   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29559   unsigned int arg2 ;
29560   Dali::Actor result;
29561
29562   arg1 = (Dali::Actor *)jarg1;
29563   arg2 = (unsigned int)jarg2;
29564   {
29565     try {
29566       result = (arg1)->FindChildById(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   return jresult;
29583 }
29584
29585
29586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29587   void * jresult ;
29588   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29589   Dali::Actor result;
29590
29591   arg1 = (Dali::Actor *)jarg1;
29592   {
29593     try {
29594       result = ((Dali::Actor const *)arg1)->GetParent();
29595     } catch (std::out_of_range& e) {
29596       {
29597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29598       };
29599     } catch (std::exception& e) {
29600       {
29601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29602       };
29603     } catch (...) {
29604       {
29605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29606       };
29607     }
29608   }
29609   jresult = new Dali::Actor((const Dali::Actor &)result);
29610   return jresult;
29611 }
29612
29613
29614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29615   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29616   Dali::Vector3 *arg2 = 0 ;
29617
29618   arg1 = (Dali::Actor *)jarg1;
29619   arg2 = (Dali::Vector3 *)jarg2;
29620   if (!arg2) {
29621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29622     return ;
29623   }
29624   {
29625     try {
29626       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29627     } catch (std::out_of_range& e) {
29628       {
29629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29630       };
29631     } catch (std::exception& e) {
29632       {
29633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29634       };
29635     } catch (...) {
29636       {
29637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29638       };
29639     }
29640   }
29641 }
29642
29643
29644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29645   void * jresult ;
29646   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29647   Dali::Vector3 result;
29648
29649   arg1 = (Dali::Actor *)jarg1;
29650   {
29651     try {
29652       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29653     } catch (std::out_of_range& e) {
29654       {
29655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29656       };
29657     } catch (std::exception& e) {
29658       {
29659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29660       };
29661     } catch (...) {
29662       {
29663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29664       };
29665     }
29666   }
29667   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29668   return jresult;
29669 }
29670
29671
29672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29673   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29674   Dali::Vector3 *arg2 = 0 ;
29675
29676   arg1 = (Dali::Actor *)jarg1;
29677   arg2 = (Dali::Vector3 *)jarg2;
29678   if (!arg2) {
29679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29680     return ;
29681   }
29682   {
29683     try {
29684       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29685     } catch (std::out_of_range& e) {
29686       {
29687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29688       };
29689     } catch (std::exception& e) {
29690       {
29691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29692       };
29693     } catch (...) {
29694       {
29695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29696       };
29697     }
29698   }
29699 }
29700
29701
29702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29703   void * jresult ;
29704   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29705   Dali::Vector3 result;
29706
29707   arg1 = (Dali::Actor *)jarg1;
29708   {
29709     try {
29710       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29711     } catch (std::out_of_range& e) {
29712       {
29713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29714       };
29715     } catch (std::exception& e) {
29716       {
29717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29718       };
29719     } catch (...) {
29720       {
29721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29722       };
29723     }
29724   }
29725   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29726   return jresult;
29727 }
29728
29729
29730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29731   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29732   float arg2 ;
29733   float arg3 ;
29734
29735   arg1 = (Dali::Actor *)jarg1;
29736   arg2 = (float)jarg2;
29737   arg3 = (float)jarg3;
29738   {
29739     try {
29740       (arg1)->SetSize(arg2,arg3);
29741     } catch (std::out_of_range& e) {
29742       {
29743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29744       };
29745     } catch (std::exception& e) {
29746       {
29747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29748       };
29749     } catch (...) {
29750       {
29751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29752       };
29753     }
29754   }
29755 }
29756
29757
29758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29759   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29760   float arg2 ;
29761   float arg3 ;
29762   float arg4 ;
29763
29764   arg1 = (Dali::Actor *)jarg1;
29765   arg2 = (float)jarg2;
29766   arg3 = (float)jarg3;
29767   arg4 = (float)jarg4;
29768   {
29769     try {
29770       (arg1)->SetSize(arg2,arg3,arg4);
29771     } catch (std::out_of_range& e) {
29772       {
29773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29774       };
29775     } catch (std::exception& e) {
29776       {
29777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29778       };
29779     } catch (...) {
29780       {
29781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29782       };
29783     }
29784   }
29785 }
29786
29787
29788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
29789   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29790   Dali::Vector2 *arg2 = 0 ;
29791
29792   arg1 = (Dali::Actor *)jarg1;
29793   arg2 = (Dali::Vector2 *)jarg2;
29794   if (!arg2) {
29795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29796     return ;
29797   }
29798   {
29799     try {
29800       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
29801     } catch (std::out_of_range& e) {
29802       {
29803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29804       };
29805     } catch (std::exception& e) {
29806       {
29807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29808       };
29809     } catch (...) {
29810       {
29811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29812       };
29813     }
29814   }
29815 }
29816
29817
29818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
29819   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29820   Dali::Vector3 *arg2 = 0 ;
29821
29822   arg1 = (Dali::Actor *)jarg1;
29823   arg2 = (Dali::Vector3 *)jarg2;
29824   if (!arg2) {
29825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29826     return ;
29827   }
29828   {
29829     try {
29830       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
29831     } catch (std::out_of_range& e) {
29832       {
29833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29834       };
29835     } catch (std::exception& e) {
29836       {
29837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29838       };
29839     } catch (...) {
29840       {
29841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29842       };
29843     }
29844   }
29845 }
29846
29847
29848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
29849   void * jresult ;
29850   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29851   Dali::Vector3 result;
29852
29853   arg1 = (Dali::Actor *)jarg1;
29854   {
29855     try {
29856       result = ((Dali::Actor const *)arg1)->GetTargetSize();
29857     } catch (std::out_of_range& e) {
29858       {
29859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29860       };
29861     } catch (std::exception& e) {
29862       {
29863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29864       };
29865     } catch (...) {
29866       {
29867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29868       };
29869     }
29870   }
29871   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29872   return jresult;
29873 }
29874
29875
29876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
29877   void * jresult ;
29878   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29879   Dali::Vector3 result;
29880
29881   arg1 = (Dali::Actor *)jarg1;
29882   {
29883     try {
29884       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
29885     } catch (std::out_of_range& e) {
29886       {
29887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29888       };
29889     } catch (std::exception& e) {
29890       {
29891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29892       };
29893     } catch (...) {
29894       {
29895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29896       };
29897     }
29898   }
29899   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29900   return jresult;
29901 }
29902
29903
29904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
29905   void * jresult ;
29906   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29907   Dali::Vector3 result;
29908
29909   arg1 = (Dali::Actor *)jarg1;
29910   {
29911     try {
29912       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
29913     } catch (std::out_of_range& e) {
29914       {
29915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29916       };
29917     } catch (std::exception& e) {
29918       {
29919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29920       };
29921     } catch (...) {
29922       {
29923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29924       };
29925     }
29926   }
29927   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29928   return jresult;
29929 }
29930
29931
29932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29933   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29934   float arg2 ;
29935   float arg3 ;
29936
29937   arg1 = (Dali::Actor *)jarg1;
29938   arg2 = (float)jarg2;
29939   arg3 = (float)jarg3;
29940   {
29941     try {
29942       (arg1)->SetPosition(arg2,arg3);
29943     } catch (std::out_of_range& e) {
29944       {
29945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29946       };
29947     } catch (std::exception& e) {
29948       {
29949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29950       };
29951     } catch (...) {
29952       {
29953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29954       };
29955     }
29956   }
29957 }
29958
29959
29960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29961   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29962   float arg2 ;
29963   float arg3 ;
29964   float arg4 ;
29965
29966   arg1 = (Dali::Actor *)jarg1;
29967   arg2 = (float)jarg2;
29968   arg3 = (float)jarg3;
29969   arg4 = (float)jarg4;
29970   {
29971     try {
29972       (arg1)->SetPosition(arg2,arg3,arg4);
29973     } catch (std::out_of_range& e) {
29974       {
29975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29976       };
29977     } catch (std::exception& e) {
29978       {
29979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29980       };
29981     } catch (...) {
29982       {
29983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29984       };
29985     }
29986   }
29987 }
29988
29989
29990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
29991   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29992   Dali::Vector3 *arg2 = 0 ;
29993
29994   arg1 = (Dali::Actor *)jarg1;
29995   arg2 = (Dali::Vector3 *)jarg2;
29996   if (!arg2) {
29997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29998     return ;
29999   }
30000   {
30001     try {
30002       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30003     } catch (std::out_of_range& e) {
30004       {
30005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30006       };
30007     } catch (std::exception& e) {
30008       {
30009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30010       };
30011     } catch (...) {
30012       {
30013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30014       };
30015     }
30016   }
30017 }
30018
30019
30020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30021   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30022   float arg2 ;
30023
30024   arg1 = (Dali::Actor *)jarg1;
30025   arg2 = (float)jarg2;
30026   {
30027     try {
30028       (arg1)->SetX(arg2);
30029     } catch (std::out_of_range& e) {
30030       {
30031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30032       };
30033     } catch (std::exception& e) {
30034       {
30035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30036       };
30037     } catch (...) {
30038       {
30039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30040       };
30041     }
30042   }
30043 }
30044
30045
30046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30048   float arg2 ;
30049
30050   arg1 = (Dali::Actor *)jarg1;
30051   arg2 = (float)jarg2;
30052   {
30053     try {
30054       (arg1)->SetY(arg2);
30055     } catch (std::out_of_range& e) {
30056       {
30057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30058       };
30059     } catch (std::exception& e) {
30060       {
30061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30062       };
30063     } catch (...) {
30064       {
30065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30066       };
30067     }
30068   }
30069 }
30070
30071
30072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30073   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30074   float arg2 ;
30075
30076   arg1 = (Dali::Actor *)jarg1;
30077   arg2 = (float)jarg2;
30078   {
30079     try {
30080       (arg1)->SetZ(arg2);
30081     } catch (std::out_of_range& e) {
30082       {
30083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30084       };
30085     } catch (std::exception& e) {
30086       {
30087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30088       };
30089     } catch (...) {
30090       {
30091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30092       };
30093     }
30094   }
30095 }
30096
30097
30098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30099   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30100   Dali::Vector3 *arg2 = 0 ;
30101
30102   arg1 = (Dali::Actor *)jarg1;
30103   arg2 = (Dali::Vector3 *)jarg2;
30104   if (!arg2) {
30105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30106     return ;
30107   }
30108   {
30109     try {
30110       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30111     } catch (std::out_of_range& e) {
30112       {
30113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30114       };
30115     } catch (std::exception& e) {
30116       {
30117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30118       };
30119     } catch (...) {
30120       {
30121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30122       };
30123     }
30124   }
30125 }
30126
30127
30128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30129   void * jresult ;
30130   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30131   Dali::Vector3 result;
30132
30133   arg1 = (Dali::Actor *)jarg1;
30134   {
30135     try {
30136       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30137     } catch (std::out_of_range& e) {
30138       {
30139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30140       };
30141     } catch (std::exception& e) {
30142       {
30143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30144       };
30145     } catch (...) {
30146       {
30147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30148       };
30149     }
30150   }
30151   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30152   return jresult;
30153 }
30154
30155
30156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30157   void * jresult ;
30158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30159   Dali::Vector3 result;
30160
30161   arg1 = (Dali::Actor *)jarg1;
30162   {
30163     try {
30164       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30165     } catch (std::out_of_range& e) {
30166       {
30167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30168       };
30169     } catch (std::exception& e) {
30170       {
30171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30172       };
30173     } catch (...) {
30174       {
30175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30176       };
30177     }
30178   }
30179   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30180   return jresult;
30181 }
30182
30183
30184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30186   bool arg2 ;
30187
30188   arg1 = (Dali::Actor *)jarg1;
30189   arg2 = jarg2 ? true : false;
30190   {
30191     try {
30192       (arg1)->SetInheritPosition(arg2);
30193     } catch (std::out_of_range& e) {
30194       {
30195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30196       };
30197     } catch (std::exception& e) {
30198       {
30199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30200       };
30201     } catch (...) {
30202       {
30203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30204       };
30205     }
30206   }
30207 }
30208
30209
30210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30211   int jresult ;
30212   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30213   Dali::PositionInheritanceMode result;
30214
30215   arg1 = (Dali::Actor *)jarg1;
30216   {
30217     try {
30218       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30219     } catch (std::out_of_range& e) {
30220       {
30221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30222       };
30223     } catch (std::exception& e) {
30224       {
30225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30226       };
30227     } catch (...) {
30228       {
30229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30230       };
30231     }
30232   }
30233   jresult = (int)result;
30234   return jresult;
30235 }
30236
30237
30238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30239   unsigned int jresult ;
30240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30241   bool result;
30242
30243   arg1 = (Dali::Actor *)jarg1;
30244   {
30245     try {
30246       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30247     } catch (std::out_of_range& e) {
30248       {
30249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30250       };
30251     } catch (std::exception& e) {
30252       {
30253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30254       };
30255     } catch (...) {
30256       {
30257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30258       };
30259     }
30260   }
30261   jresult = result;
30262   return jresult;
30263 }
30264
30265
30266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30267   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30268   Dali::Degree *arg2 = 0 ;
30269   Dali::Vector3 *arg3 = 0 ;
30270
30271   arg1 = (Dali::Actor *)jarg1;
30272   arg2 = (Dali::Degree *)jarg2;
30273   if (!arg2) {
30274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30275     return ;
30276   }
30277   arg3 = (Dali::Vector3 *)jarg3;
30278   if (!arg3) {
30279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30280     return ;
30281   }
30282   {
30283     try {
30284       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30285     } catch (std::out_of_range& e) {
30286       {
30287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30288       };
30289     } catch (std::exception& e) {
30290       {
30291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30292       };
30293     } catch (...) {
30294       {
30295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30296       };
30297     }
30298   }
30299 }
30300
30301
30302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30303   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30304   Dali::Radian *arg2 = 0 ;
30305   Dali::Vector3 *arg3 = 0 ;
30306
30307   arg1 = (Dali::Actor *)jarg1;
30308   arg2 = (Dali::Radian *)jarg2;
30309   if (!arg2) {
30310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30311     return ;
30312   }
30313   arg3 = (Dali::Vector3 *)jarg3;
30314   if (!arg3) {
30315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30316     return ;
30317   }
30318   {
30319     try {
30320       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30321     } catch (std::out_of_range& e) {
30322       {
30323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30324       };
30325     } catch (std::exception& e) {
30326       {
30327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30328       };
30329     } catch (...) {
30330       {
30331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30332       };
30333     }
30334   }
30335 }
30336
30337
30338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30339   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30340   Dali::Quaternion *arg2 = 0 ;
30341
30342   arg1 = (Dali::Actor *)jarg1;
30343   arg2 = (Dali::Quaternion *)jarg2;
30344   if (!arg2) {
30345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30346     return ;
30347   }
30348   {
30349     try {
30350       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30351     } catch (std::out_of_range& e) {
30352       {
30353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30354       };
30355     } catch (std::exception& e) {
30356       {
30357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30358       };
30359     } catch (...) {
30360       {
30361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30362       };
30363     }
30364   }
30365 }
30366
30367
30368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30369   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30370   Dali::Degree *arg2 = 0 ;
30371   Dali::Vector3 *arg3 = 0 ;
30372
30373   arg1 = (Dali::Actor *)jarg1;
30374   arg2 = (Dali::Degree *)jarg2;
30375   if (!arg2) {
30376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30377     return ;
30378   }
30379   arg3 = (Dali::Vector3 *)jarg3;
30380   if (!arg3) {
30381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30382     return ;
30383   }
30384   {
30385     try {
30386       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30387     } catch (std::out_of_range& e) {
30388       {
30389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30390       };
30391     } catch (std::exception& e) {
30392       {
30393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30394       };
30395     } catch (...) {
30396       {
30397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30398       };
30399     }
30400   }
30401 }
30402
30403
30404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30405   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30406   Dali::Radian *arg2 = 0 ;
30407   Dali::Vector3 *arg3 = 0 ;
30408
30409   arg1 = (Dali::Actor *)jarg1;
30410   arg2 = (Dali::Radian *)jarg2;
30411   if (!arg2) {
30412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30413     return ;
30414   }
30415   arg3 = (Dali::Vector3 *)jarg3;
30416   if (!arg3) {
30417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30418     return ;
30419   }
30420   {
30421     try {
30422       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30423     } catch (std::out_of_range& e) {
30424       {
30425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30426       };
30427     } catch (std::exception& e) {
30428       {
30429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30430       };
30431     } catch (...) {
30432       {
30433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30434       };
30435     }
30436   }
30437 }
30438
30439
30440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30441   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30442   Dali::Quaternion *arg2 = 0 ;
30443
30444   arg1 = (Dali::Actor *)jarg1;
30445   arg2 = (Dali::Quaternion *)jarg2;
30446   if (!arg2) {
30447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30448     return ;
30449   }
30450   {
30451     try {
30452       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30453     } catch (std::out_of_range& e) {
30454       {
30455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30456       };
30457     } catch (std::exception& e) {
30458       {
30459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30460       };
30461     } catch (...) {
30462       {
30463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30464       };
30465     }
30466   }
30467 }
30468
30469
30470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30471   void * jresult ;
30472   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30473   Dali::Quaternion result;
30474
30475   arg1 = (Dali::Actor *)jarg1;
30476   {
30477     try {
30478       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30479     } catch (std::out_of_range& e) {
30480       {
30481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30482       };
30483     } catch (std::exception& e) {
30484       {
30485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30486       };
30487     } catch (...) {
30488       {
30489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30490       };
30491     }
30492   }
30493   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30494   return jresult;
30495 }
30496
30497
30498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30499   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30500   bool arg2 ;
30501
30502   arg1 = (Dali::Actor *)jarg1;
30503   arg2 = jarg2 ? true : false;
30504   {
30505     try {
30506       (arg1)->SetInheritOrientation(arg2);
30507     } catch (std::out_of_range& e) {
30508       {
30509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30510       };
30511     } catch (std::exception& e) {
30512       {
30513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30514       };
30515     } catch (...) {
30516       {
30517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30518       };
30519     }
30520   }
30521 }
30522
30523
30524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30525   unsigned int jresult ;
30526   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30527   bool result;
30528
30529   arg1 = (Dali::Actor *)jarg1;
30530   {
30531     try {
30532       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30533     } catch (std::out_of_range& e) {
30534       {
30535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30536       };
30537     } catch (std::exception& e) {
30538       {
30539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30540       };
30541     } catch (...) {
30542       {
30543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30544       };
30545     }
30546   }
30547   jresult = result;
30548   return jresult;
30549 }
30550
30551
30552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30553   void * jresult ;
30554   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30555   Dali::Quaternion result;
30556
30557   arg1 = (Dali::Actor *)jarg1;
30558   {
30559     try {
30560       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30561     } catch (std::out_of_range& e) {
30562       {
30563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30564       };
30565     } catch (std::exception& e) {
30566       {
30567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30568       };
30569     } catch (...) {
30570       {
30571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30572       };
30573     }
30574   }
30575   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30576   return jresult;
30577 }
30578
30579
30580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30581   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30582   float arg2 ;
30583
30584   arg1 = (Dali::Actor *)jarg1;
30585   arg2 = (float)jarg2;
30586   {
30587     try {
30588       (arg1)->SetScale(arg2);
30589     } catch (std::out_of_range& e) {
30590       {
30591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30592       };
30593     } catch (std::exception& e) {
30594       {
30595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30596       };
30597     } catch (...) {
30598       {
30599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30600       };
30601     }
30602   }
30603 }
30604
30605
30606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30607   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30608   float arg2 ;
30609   float arg3 ;
30610   float arg4 ;
30611
30612   arg1 = (Dali::Actor *)jarg1;
30613   arg2 = (float)jarg2;
30614   arg3 = (float)jarg3;
30615   arg4 = (float)jarg4;
30616   {
30617     try {
30618       (arg1)->SetScale(arg2,arg3,arg4);
30619     } catch (std::out_of_range& e) {
30620       {
30621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30622       };
30623     } catch (std::exception& e) {
30624       {
30625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30626       };
30627     } catch (...) {
30628       {
30629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30630       };
30631     }
30632   }
30633 }
30634
30635
30636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30637   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30638   Dali::Vector3 *arg2 = 0 ;
30639
30640   arg1 = (Dali::Actor *)jarg1;
30641   arg2 = (Dali::Vector3 *)jarg2;
30642   if (!arg2) {
30643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30644     return ;
30645   }
30646   {
30647     try {
30648       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30649     } catch (std::out_of_range& e) {
30650       {
30651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30652       };
30653     } catch (std::exception& e) {
30654       {
30655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30656       };
30657     } catch (...) {
30658       {
30659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30660       };
30661     }
30662   }
30663 }
30664
30665
30666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30667   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30668   Dali::Vector3 *arg2 = 0 ;
30669
30670   arg1 = (Dali::Actor *)jarg1;
30671   arg2 = (Dali::Vector3 *)jarg2;
30672   if (!arg2) {
30673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30674     return ;
30675   }
30676   {
30677     try {
30678       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30679     } catch (std::out_of_range& e) {
30680       {
30681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30682       };
30683     } catch (std::exception& e) {
30684       {
30685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30686       };
30687     } catch (...) {
30688       {
30689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30690       };
30691     }
30692   }
30693 }
30694
30695
30696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30697   void * jresult ;
30698   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30699   Dali::Vector3 result;
30700
30701   arg1 = (Dali::Actor *)jarg1;
30702   {
30703     try {
30704       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30705     } catch (std::out_of_range& e) {
30706       {
30707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30708       };
30709     } catch (std::exception& e) {
30710       {
30711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30712       };
30713     } catch (...) {
30714       {
30715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30716       };
30717     }
30718   }
30719   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30720   return jresult;
30721 }
30722
30723
30724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
30725   void * jresult ;
30726   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30727   Dali::Vector3 result;
30728
30729   arg1 = (Dali::Actor *)jarg1;
30730   {
30731     try {
30732       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
30733     } catch (std::out_of_range& e) {
30734       {
30735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30736       };
30737     } catch (std::exception& e) {
30738       {
30739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30740       };
30741     } catch (...) {
30742       {
30743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30744       };
30745     }
30746   }
30747   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30748   return jresult;
30749 }
30750
30751
30752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
30753   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30754   bool arg2 ;
30755
30756   arg1 = (Dali::Actor *)jarg1;
30757   arg2 = jarg2 ? true : false;
30758   {
30759     try {
30760       (arg1)->SetInheritScale(arg2);
30761     } catch (std::out_of_range& e) {
30762       {
30763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30764       };
30765     } catch (std::exception& e) {
30766       {
30767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30768       };
30769     } catch (...) {
30770       {
30771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30772       };
30773     }
30774   }
30775 }
30776
30777
30778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
30779   unsigned int jresult ;
30780   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30781   bool result;
30782
30783   arg1 = (Dali::Actor *)jarg1;
30784   {
30785     try {
30786       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
30787     } catch (std::out_of_range& e) {
30788       {
30789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30790       };
30791     } catch (std::exception& e) {
30792       {
30793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30794       };
30795     } catch (...) {
30796       {
30797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30798       };
30799     }
30800   }
30801   jresult = result;
30802   return jresult;
30803 }
30804
30805
30806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
30807   void * jresult ;
30808   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30809   Dali::Matrix result;
30810
30811   arg1 = (Dali::Actor *)jarg1;
30812   {
30813     try {
30814       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
30815     } catch (std::out_of_range& e) {
30816       {
30817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30818       };
30819     } catch (std::exception& e) {
30820       {
30821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30822       };
30823     } catch (...) {
30824       {
30825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30826       };
30827     }
30828   }
30829   jresult = new Dali::Matrix((const Dali::Matrix &)result);
30830   return jresult;
30831 }
30832
30833
30834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
30835   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30836   bool arg2 ;
30837
30838   arg1 = (Dali::Actor *)jarg1;
30839   arg2 = jarg2 ? true : false;
30840   {
30841     try {
30842       (arg1)->SetVisible(arg2);
30843     } catch (std::out_of_range& e) {
30844       {
30845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30846       };
30847     } catch (std::exception& e) {
30848       {
30849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30850       };
30851     } catch (...) {
30852       {
30853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30854       };
30855     }
30856   }
30857 }
30858
30859
30860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
30861   unsigned int jresult ;
30862   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30863   bool result;
30864
30865   arg1 = (Dali::Actor *)jarg1;
30866   {
30867     try {
30868       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
30869     } catch (std::out_of_range& e) {
30870       {
30871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30872       };
30873     } catch (std::exception& e) {
30874       {
30875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30876       };
30877     } catch (...) {
30878       {
30879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30880       };
30881     }
30882   }
30883   jresult = result;
30884   return jresult;
30885 }
30886
30887
30888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
30889   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30890   float arg2 ;
30891
30892   arg1 = (Dali::Actor *)jarg1;
30893   arg2 = (float)jarg2;
30894   {
30895     try {
30896       (arg1)->SetOpacity(arg2);
30897     } catch (std::out_of_range& e) {
30898       {
30899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30900       };
30901     } catch (std::exception& e) {
30902       {
30903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30904       };
30905     } catch (...) {
30906       {
30907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30908       };
30909     }
30910   }
30911 }
30912
30913
30914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
30915   float jresult ;
30916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30917   float result;
30918
30919   arg1 = (Dali::Actor *)jarg1;
30920   {
30921     try {
30922       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
30923     } catch (std::out_of_range& e) {
30924       {
30925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30926       };
30927     } catch (std::exception& e) {
30928       {
30929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30930       };
30931     } catch (...) {
30932       {
30933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30934       };
30935     }
30936   }
30937   jresult = result;
30938   return jresult;
30939 }
30940
30941
30942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
30943   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30944   Dali::Vector4 *arg2 = 0 ;
30945
30946   arg1 = (Dali::Actor *)jarg1;
30947   arg2 = (Dali::Vector4 *)jarg2;
30948   if (!arg2) {
30949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
30950     return ;
30951   }
30952   {
30953     try {
30954       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
30955     } catch (std::out_of_range& e) {
30956       {
30957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30958       };
30959     } catch (std::exception& e) {
30960       {
30961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30962       };
30963     } catch (...) {
30964       {
30965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30966       };
30967     }
30968   }
30969 }
30970
30971
30972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
30973   void * jresult ;
30974   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30975   Dali::Vector4 result;
30976
30977   arg1 = (Dali::Actor *)jarg1;
30978   {
30979     try {
30980       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
30981     } catch (std::out_of_range& e) {
30982       {
30983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30984       };
30985     } catch (std::exception& e) {
30986       {
30987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30988       };
30989     } catch (...) {
30990       {
30991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30992       };
30993     }
30994   }
30995   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
30996   return jresult;
30997 }
30998
30999
31000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31001   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31002   Dali::ColorMode arg2 ;
31003
31004   arg1 = (Dali::Actor *)jarg1;
31005   arg2 = (Dali::ColorMode)jarg2;
31006   {
31007     try {
31008       (arg1)->SetColorMode(arg2);
31009     } catch (std::out_of_range& e) {
31010       {
31011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31012       };
31013     } catch (std::exception& e) {
31014       {
31015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31016       };
31017     } catch (...) {
31018       {
31019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31020       };
31021     }
31022   }
31023 }
31024
31025
31026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31027   int jresult ;
31028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31029   Dali::ColorMode result;
31030
31031   arg1 = (Dali::Actor *)jarg1;
31032   {
31033     try {
31034       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31035     } catch (std::out_of_range& e) {
31036       {
31037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31038       };
31039     } catch (std::exception& e) {
31040       {
31041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31042       };
31043     } catch (...) {
31044       {
31045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31046       };
31047     }
31048   }
31049   jresult = (int)result;
31050   return jresult;
31051 }
31052
31053
31054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31055   void * jresult ;
31056   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31057   Dali::Vector4 result;
31058
31059   arg1 = (Dali::Actor *)jarg1;
31060   {
31061     try {
31062       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31063     } catch (std::out_of_range& e) {
31064       {
31065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31066       };
31067     } catch (std::exception& e) {
31068       {
31069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31070       };
31071     } catch (...) {
31072       {
31073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31074       };
31075     }
31076   }
31077   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31078   return jresult;
31079 }
31080
31081
31082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31083   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31084   Dali::DrawMode::Type arg2 ;
31085
31086   arg1 = (Dali::Actor *)jarg1;
31087   arg2 = (Dali::DrawMode::Type)jarg2;
31088   {
31089     try {
31090       (arg1)->SetDrawMode(arg2);
31091     } catch (std::out_of_range& e) {
31092       {
31093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31094       };
31095     } catch (std::exception& e) {
31096       {
31097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31098       };
31099     } catch (...) {
31100       {
31101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31102       };
31103     }
31104   }
31105 }
31106
31107
31108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31109   int jresult ;
31110   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31111   Dali::DrawMode::Type result;
31112
31113   arg1 = (Dali::Actor *)jarg1;
31114   {
31115     try {
31116       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31117     } catch (std::out_of_range& e) {
31118       {
31119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31120       };
31121     } catch (std::exception& e) {
31122       {
31123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31124       };
31125     } catch (...) {
31126       {
31127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31128       };
31129     }
31130   }
31131   jresult = (int)result;
31132   return jresult;
31133 }
31134
31135
31136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31137   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31138   bool arg2 ;
31139
31140   arg1 = (Dali::Actor *)jarg1;
31141   arg2 = jarg2 ? true : false;
31142   {
31143     try {
31144       (arg1)->SetSensitive(arg2);
31145     } catch (std::out_of_range& e) {
31146       {
31147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31148       };
31149     } catch (std::exception& e) {
31150       {
31151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31152       };
31153     } catch (...) {
31154       {
31155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31156       };
31157     }
31158   }
31159 }
31160
31161
31162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31163   unsigned int jresult ;
31164   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31165   bool result;
31166
31167   arg1 = (Dali::Actor *)jarg1;
31168   {
31169     try {
31170       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31171     } catch (std::out_of_range& e) {
31172       {
31173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31174       };
31175     } catch (std::exception& e) {
31176       {
31177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31178       };
31179     } catch (...) {
31180       {
31181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31182       };
31183     }
31184   }
31185   jresult = result;
31186   return jresult;
31187 }
31188
31189
31190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31191   unsigned int jresult ;
31192   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31193   float *arg2 = 0 ;
31194   float *arg3 = 0 ;
31195   float arg4 ;
31196   float arg5 ;
31197   bool result;
31198
31199   arg1 = (Dali::Actor *)jarg1;
31200   arg2 = (float *)jarg2;
31201   arg3 = (float *)jarg3;
31202   arg4 = (float)jarg4;
31203   arg5 = (float)jarg5;
31204   {
31205     try {
31206       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31207     } catch (std::out_of_range& e) {
31208       {
31209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31210       };
31211     } catch (std::exception& e) {
31212       {
31213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31214       };
31215     } catch (...) {
31216       {
31217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31218       };
31219     }
31220   }
31221   jresult = result;
31222   return jresult;
31223 }
31224
31225
31226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31227   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31228   bool arg2 ;
31229
31230   arg1 = (Dali::Actor *)jarg1;
31231   arg2 = jarg2 ? true : false;
31232   {
31233     try {
31234       (arg1)->SetLeaveRequired(arg2);
31235     } catch (std::out_of_range& e) {
31236       {
31237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31238       };
31239     } catch (std::exception& e) {
31240       {
31241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31242       };
31243     } catch (...) {
31244       {
31245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31246       };
31247     }
31248   }
31249 }
31250
31251
31252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31253   unsigned int jresult ;
31254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31255   bool result;
31256
31257   arg1 = (Dali::Actor *)jarg1;
31258   {
31259     try {
31260       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31261     } catch (std::out_of_range& e) {
31262       {
31263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31264       };
31265     } catch (std::exception& e) {
31266       {
31267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31268       };
31269     } catch (...) {
31270       {
31271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31272       };
31273     }
31274   }
31275   jresult = result;
31276   return jresult;
31277 }
31278
31279
31280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31281   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31282   bool arg2 ;
31283
31284   arg1 = (Dali::Actor *)jarg1;
31285   arg2 = jarg2 ? true : false;
31286   {
31287     try {
31288       (arg1)->SetKeyboardFocusable(arg2);
31289     } catch (std::out_of_range& e) {
31290       {
31291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31292       };
31293     } catch (std::exception& e) {
31294       {
31295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31296       };
31297     } catch (...) {
31298       {
31299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31300       };
31301     }
31302   }
31303 }
31304
31305
31306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31307   unsigned int jresult ;
31308   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31309   bool result;
31310
31311   arg1 = (Dali::Actor *)jarg1;
31312   {
31313     try {
31314       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31315     } catch (std::out_of_range& e) {
31316       {
31317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31318       };
31319     } catch (std::exception& e) {
31320       {
31321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31322       };
31323     } catch (...) {
31324       {
31325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31326       };
31327     }
31328   }
31329   jresult = result;
31330   return jresult;
31331 }
31332
31333
31334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31335   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31336   Dali::ResizePolicy::Type arg2 ;
31337   Dali::Dimension::Type arg3 ;
31338
31339   arg1 = (Dali::Actor *)jarg1;
31340   arg2 = (Dali::ResizePolicy::Type)jarg2;
31341   arg3 = (Dali::Dimension::Type)jarg3;
31342   {
31343     try {
31344       (arg1)->SetResizePolicy(arg2,arg3);
31345     } catch (std::out_of_range& e) {
31346       {
31347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31348       };
31349     } catch (std::exception& e) {
31350       {
31351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31352       };
31353     } catch (...) {
31354       {
31355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31356       };
31357     }
31358   }
31359 }
31360
31361
31362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31363   int jresult ;
31364   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31365   Dali::Dimension::Type arg2 ;
31366   Dali::ResizePolicy::Type result;
31367
31368   arg1 = (Dali::Actor *)jarg1;
31369   arg2 = (Dali::Dimension::Type)jarg2;
31370   {
31371     try {
31372       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31373     } catch (std::out_of_range& e) {
31374       {
31375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31376       };
31377     } catch (std::exception& e) {
31378       {
31379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31380       };
31381     } catch (...) {
31382       {
31383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31384       };
31385     }
31386   }
31387   jresult = (int)result;
31388   return jresult;
31389 }
31390
31391
31392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31393   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31394   Dali::SizeScalePolicy::Type arg2 ;
31395
31396   arg1 = (Dali::Actor *)jarg1;
31397   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31398   {
31399     try {
31400       (arg1)->SetSizeScalePolicy(arg2);
31401     } catch (std::out_of_range& e) {
31402       {
31403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31404       };
31405     } catch (std::exception& e) {
31406       {
31407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31408       };
31409     } catch (...) {
31410       {
31411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31412       };
31413     }
31414   }
31415 }
31416
31417
31418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31419   int jresult ;
31420   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31421   Dali::SizeScalePolicy::Type result;
31422
31423   arg1 = (Dali::Actor *)jarg1;
31424   {
31425     try {
31426       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31427     } catch (std::out_of_range& e) {
31428       {
31429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31430       };
31431     } catch (std::exception& e) {
31432       {
31433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31434       };
31435     } catch (...) {
31436       {
31437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31438       };
31439     }
31440   }
31441   jresult = (int)result;
31442   return jresult;
31443 }
31444
31445
31446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31447   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31448   Dali::Vector3 *arg2 = 0 ;
31449
31450   arg1 = (Dali::Actor *)jarg1;
31451   arg2 = (Dali::Vector3 *)jarg2;
31452   if (!arg2) {
31453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31454     return ;
31455   }
31456   {
31457     try {
31458       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31459     } catch (std::out_of_range& e) {
31460       {
31461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31462       };
31463     } catch (std::exception& e) {
31464       {
31465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31466       };
31467     } catch (...) {
31468       {
31469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31470       };
31471     }
31472   }
31473 }
31474
31475
31476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31477   void * jresult ;
31478   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31479   Dali::Vector3 result;
31480
31481   arg1 = (Dali::Actor *)jarg1;
31482   {
31483     try {
31484       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31485     } catch (std::out_of_range& e) {
31486       {
31487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31488       };
31489     } catch (std::exception& e) {
31490       {
31491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31492       };
31493     } catch (...) {
31494       {
31495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31496       };
31497     }
31498   }
31499   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31500   return jresult;
31501 }
31502
31503
31504 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31505   float jresult ;
31506   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31507   float arg2 ;
31508   float result;
31509
31510   arg1 = (Dali::Actor *)jarg1;
31511   arg2 = (float)jarg2;
31512   {
31513     try {
31514       result = (float)(arg1)->GetHeightForWidth(arg2);
31515     } catch (std::out_of_range& e) {
31516       {
31517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31518       };
31519     } catch (std::exception& e) {
31520       {
31521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31522       };
31523     } catch (...) {
31524       {
31525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31526       };
31527     }
31528   }
31529   jresult = result;
31530   return jresult;
31531 }
31532
31533
31534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31535   float jresult ;
31536   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31537   float arg2 ;
31538   float result;
31539
31540   arg1 = (Dali::Actor *)jarg1;
31541   arg2 = (float)jarg2;
31542   {
31543     try {
31544       result = (float)(arg1)->GetWidthForHeight(arg2);
31545     } catch (std::out_of_range& e) {
31546       {
31547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31548       };
31549     } catch (std::exception& e) {
31550       {
31551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31552       };
31553     } catch (...) {
31554       {
31555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31556       };
31557     }
31558   }
31559   jresult = result;
31560   return jresult;
31561 }
31562
31563
31564 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31565   float jresult ;
31566   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31567   Dali::Dimension::Type arg2 ;
31568   float result;
31569
31570   arg1 = (Dali::Actor *)jarg1;
31571   arg2 = (Dali::Dimension::Type)jarg2;
31572   {
31573     try {
31574       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31575     } catch (std::out_of_range& e) {
31576       {
31577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31578       };
31579     } catch (std::exception& e) {
31580       {
31581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31582       };
31583     } catch (...) {
31584       {
31585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31586       };
31587     }
31588   }
31589   jresult = result;
31590   return jresult;
31591 }
31592
31593
31594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31595   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31596   Dali::Padding *arg2 = 0 ;
31597
31598   arg1 = (Dali::Actor *)jarg1;
31599   arg2 = (Dali::Padding *)jarg2;
31600   if (!arg2) {
31601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31602     return ;
31603   }
31604   {
31605     try {
31606       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31607     } catch (std::out_of_range& e) {
31608       {
31609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31610       };
31611     } catch (std::exception& e) {
31612       {
31613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31614       };
31615     } catch (...) {
31616       {
31617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31618       };
31619     }
31620   }
31621 }
31622
31623
31624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31625   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31626   Dali::Padding *arg2 = 0 ;
31627
31628   arg1 = (Dali::Actor *)jarg1;
31629   arg2 = (Dali::Padding *)jarg2;
31630   if (!arg2) {
31631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31632     return ;
31633   }
31634   {
31635     try {
31636       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31637     } catch (std::out_of_range& e) {
31638       {
31639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31640       };
31641     } catch (std::exception& e) {
31642       {
31643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31644       };
31645     } catch (...) {
31646       {
31647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31648       };
31649     }
31650   }
31651 }
31652
31653
31654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31655   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31656   Dali::Vector2 *arg2 = 0 ;
31657
31658   arg1 = (Dali::Actor *)jarg1;
31659   arg2 = (Dali::Vector2 *)jarg2;
31660   if (!arg2) {
31661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31662     return ;
31663   }
31664   {
31665     try {
31666       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31667     } catch (std::out_of_range& e) {
31668       {
31669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31670       };
31671     } catch (std::exception& e) {
31672       {
31673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31674       };
31675     } catch (...) {
31676       {
31677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31678       };
31679     }
31680   }
31681 }
31682
31683
31684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31685   void * jresult ;
31686   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31687   Dali::Vector2 result;
31688
31689   arg1 = (Dali::Actor *)jarg1;
31690   {
31691     try {
31692       result = (arg1)->GetMinimumSize();
31693     } catch (std::out_of_range& e) {
31694       {
31695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31696       };
31697     } catch (std::exception& e) {
31698       {
31699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31700       };
31701     } catch (...) {
31702       {
31703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31704       };
31705     }
31706   }
31707   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31708   return jresult;
31709 }
31710
31711
31712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31713   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31714   Dali::Vector2 *arg2 = 0 ;
31715
31716   arg1 = (Dali::Actor *)jarg1;
31717   arg2 = (Dali::Vector2 *)jarg2;
31718   if (!arg2) {
31719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31720     return ;
31721   }
31722   {
31723     try {
31724       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
31725     } catch (std::out_of_range& e) {
31726       {
31727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31728       };
31729     } catch (std::exception& e) {
31730       {
31731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31732       };
31733     } catch (...) {
31734       {
31735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31736       };
31737     }
31738   }
31739 }
31740
31741
31742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
31743   void * jresult ;
31744   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31745   Dali::Vector2 result;
31746
31747   arg1 = (Dali::Actor *)jarg1;
31748   {
31749     try {
31750       result = (arg1)->GetMaximumSize();
31751     } catch (std::out_of_range& e) {
31752       {
31753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31754       };
31755     } catch (std::exception& e) {
31756       {
31757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31758       };
31759     } catch (...) {
31760       {
31761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31762       };
31763     }
31764   }
31765   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31766   return jresult;
31767 }
31768
31769
31770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
31771   int jresult ;
31772   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31773   int result;
31774
31775   arg1 = (Dali::Actor *)jarg1;
31776   {
31777     try {
31778       result = (int)(arg1)->GetHierarchyDepth();
31779     } catch (std::out_of_range& e) {
31780       {
31781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31782       };
31783     } catch (std::exception& e) {
31784       {
31785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31786       };
31787     } catch (...) {
31788       {
31789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31790       };
31791     }
31792   }
31793   jresult = result;
31794   return jresult;
31795 }
31796
31797
31798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
31799   unsigned int jresult ;
31800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31801   Dali::Renderer *arg2 = 0 ;
31802   unsigned int result;
31803
31804   arg1 = (Dali::Actor *)jarg1;
31805   arg2 = (Dali::Renderer *)jarg2;
31806   if (!arg2) {
31807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31808     return 0;
31809   }
31810   {
31811     try {
31812       result = (unsigned int)(arg1)->AddRenderer(*arg2);
31813     } catch (std::out_of_range& e) {
31814       {
31815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31816       };
31817     } catch (std::exception& e) {
31818       {
31819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31820       };
31821     } catch (...) {
31822       {
31823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31824       };
31825     }
31826   }
31827   jresult = result;
31828   return jresult;
31829 }
31830
31831
31832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
31833   unsigned int jresult ;
31834   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31835   unsigned int result;
31836
31837   arg1 = (Dali::Actor *)jarg1;
31838   {
31839     try {
31840       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
31841     } catch (std::out_of_range& e) {
31842       {
31843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31844       };
31845     } catch (std::exception& e) {
31846       {
31847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31848       };
31849     } catch (...) {
31850       {
31851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31852       };
31853     }
31854   }
31855   jresult = result;
31856   return jresult;
31857 }
31858
31859
31860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
31861   void * jresult ;
31862   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31863   unsigned int arg2 ;
31864   Dali::Renderer result;
31865
31866   arg1 = (Dali::Actor *)jarg1;
31867   arg2 = (unsigned int)jarg2;
31868   {
31869     try {
31870       result = (arg1)->GetRendererAt(arg2);
31871     } catch (std::out_of_range& e) {
31872       {
31873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31874       };
31875     } catch (std::exception& e) {
31876       {
31877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31878       };
31879     } catch (...) {
31880       {
31881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31882       };
31883     }
31884   }
31885   jresult = new Dali::Renderer((const Dali::Renderer &)result);
31886   return jresult;
31887 }
31888
31889
31890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
31891   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31892   Dali::Renderer *arg2 = 0 ;
31893
31894   arg1 = (Dali::Actor *)jarg1;
31895   arg2 = (Dali::Renderer *)jarg2;
31896   if (!arg2) {
31897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31898     return ;
31899   }
31900   {
31901     try {
31902       (arg1)->RemoveRenderer(*arg2);
31903     } catch (std::out_of_range& e) {
31904       {
31905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31906       };
31907     } catch (std::exception& e) {
31908       {
31909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31910       };
31911     } catch (...) {
31912       {
31913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31914       };
31915     }
31916   }
31917 }
31918
31919
31920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
31921   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31922   unsigned int arg2 ;
31923
31924   arg1 = (Dali::Actor *)jarg1;
31925   arg2 = (unsigned int)jarg2;
31926   {
31927     try {
31928       (arg1)->RemoveRenderer(arg2);
31929     } catch (std::out_of_range& e) {
31930       {
31931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31932       };
31933     } catch (std::exception& e) {
31934       {
31935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31936       };
31937     } catch (...) {
31938       {
31939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31940       };
31941     }
31942   }
31943 }
31944
31945
31946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
31947   void * jresult ;
31948   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31949   Dali::Actor::TouchSignalType *result = 0 ;
31950
31951   arg1 = (Dali::Actor *)jarg1;
31952   {
31953     try {
31954       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
31955     } catch (std::out_of_range& e) {
31956       {
31957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31958       };
31959     } catch (std::exception& e) {
31960       {
31961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31962       };
31963     } catch (...) {
31964       {
31965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31966       };
31967     }
31968   }
31969   jresult = (void *)result;
31970   return jresult;
31971 }
31972
31973
31974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
31975   void * jresult ;
31976   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31977   Dali::Actor::TouchDataSignalType *result = 0 ;
31978
31979   arg1 = (Dali::Actor *)jarg1;
31980   {
31981     try {
31982       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
31983     } catch (std::out_of_range& e) {
31984       {
31985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31986       };
31987     } catch (std::exception& e) {
31988       {
31989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31990       };
31991     } catch (...) {
31992       {
31993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31994       };
31995     }
31996   }
31997   jresult = (void *)result;
31998   return jresult;
31999 }
32000
32001
32002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32003   void * jresult ;
32004   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32005   Dali::Actor::HoverSignalType *result = 0 ;
32006
32007   arg1 = (Dali::Actor *)jarg1;
32008   {
32009     try {
32010       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32011     } catch (std::out_of_range& e) {
32012       {
32013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32014       };
32015     } catch (std::exception& e) {
32016       {
32017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32018       };
32019     } catch (...) {
32020       {
32021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32022       };
32023     }
32024   }
32025   jresult = (void *)result;
32026   return jresult;
32027 }
32028
32029
32030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32031   void * jresult ;
32032   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32033   Dali::Actor::WheelEventSignalType *result = 0 ;
32034
32035   arg1 = (Dali::Actor *)jarg1;
32036   {
32037     try {
32038       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32039     } catch (std::out_of_range& e) {
32040       {
32041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32042       };
32043     } catch (std::exception& e) {
32044       {
32045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32046       };
32047     } catch (...) {
32048       {
32049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32050       };
32051     }
32052   }
32053   jresult = (void *)result;
32054   return jresult;
32055 }
32056
32057
32058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32059   void * jresult ;
32060   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32061   Dali::Actor::OnStageSignalType *result = 0 ;
32062
32063   arg1 = (Dali::Actor *)jarg1;
32064   {
32065     try {
32066       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32067     } catch (std::out_of_range& e) {
32068       {
32069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32070       };
32071     } catch (std::exception& e) {
32072       {
32073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32074       };
32075     } catch (...) {
32076       {
32077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32078       };
32079     }
32080   }
32081   jresult = (void *)result;
32082   return jresult;
32083 }
32084
32085
32086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32087   void * jresult ;
32088   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32089   Dali::Actor::OffStageSignalType *result = 0 ;
32090
32091   arg1 = (Dali::Actor *)jarg1;
32092   {
32093     try {
32094       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32095     } catch (std::out_of_range& e) {
32096       {
32097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32098       };
32099     } catch (std::exception& e) {
32100       {
32101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32102       };
32103     } catch (...) {
32104       {
32105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32106       };
32107     }
32108   }
32109   jresult = (void *)result;
32110   return jresult;
32111 }
32112
32113
32114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32115   void * jresult ;
32116   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32117   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32118
32119   arg1 = (Dali::Actor *)jarg1;
32120   {
32121     try {
32122       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32123     } catch (std::out_of_range& e) {
32124       {
32125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32126       };
32127     } catch (std::exception& e) {
32128       {
32129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32130       };
32131     } catch (...) {
32132       {
32133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32134       };
32135     }
32136   }
32137   jresult = (void *)result;
32138   return jresult;
32139 }
32140
32141
32142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32143   Dali::Actor *arg1 = 0 ;
32144
32145   arg1 = (Dali::Actor *)jarg1;
32146   if (!arg1) {
32147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32148     return ;
32149   }
32150   {
32151     try {
32152       Dali::UnparentAndReset(*arg1);
32153     } catch (std::out_of_range& e) {
32154       {
32155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32156       };
32157     } catch (std::exception& e) {
32158       {
32159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32160       };
32161     } catch (...) {
32162       {
32163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32164       };
32165     }
32166   }
32167 }
32168
32169
32170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32171   Dali::Actor arg1 ;
32172   Dali::Actor *argp1 ;
32173
32174   argp1 = (Dali::Actor *)jarg1;
32175   if (!argp1) {
32176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32177     return ;
32178   }
32179   arg1 = *argp1;
32180   {
32181     try {
32182       Dali::DevelActor::Raise(arg1);
32183     } catch (std::out_of_range& e) {
32184       {
32185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32186       };
32187     } catch (std::exception& e) {
32188       {
32189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32190       };
32191     } catch (...) {
32192       {
32193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32194       };
32195     }
32196   }
32197 }
32198
32199
32200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32201   Dali::Actor arg1 ;
32202   Dali::Actor *argp1 ;
32203
32204   argp1 = (Dali::Actor *)jarg1;
32205   if (!argp1) {
32206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32207     return ;
32208   }
32209   arg1 = *argp1;
32210   {
32211     try {
32212       Dali::DevelActor::Lower(arg1);
32213     } catch (std::out_of_range& e) {
32214       {
32215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32216       };
32217     } catch (std::exception& e) {
32218       {
32219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32220       };
32221     } catch (...) {
32222       {
32223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32224       };
32225     }
32226   }
32227 }
32228
32229
32230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32231   Dali::Actor arg1 ;
32232   Dali::Actor *argp1 ;
32233
32234   argp1 = (Dali::Actor *)jarg1;
32235   if (!argp1) {
32236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32237     return ;
32238   }
32239   arg1 = *argp1;
32240   {
32241     try {
32242       Dali::DevelActor::RaiseToTop(arg1);
32243     } catch (std::out_of_range& e) {
32244       {
32245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32246       };
32247     } catch (std::exception& e) {
32248       {
32249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32250       };
32251     } catch (...) {
32252       {
32253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32254       };
32255     }
32256   }
32257 }
32258
32259
32260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32261   Dali::Actor arg1 ;
32262   Dali::Actor *argp1 ;
32263
32264   argp1 = (Dali::Actor *)jarg1;
32265   if (!argp1) {
32266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32267     return ;
32268   }
32269   arg1 = *argp1;
32270   {
32271     try {
32272       Dali::DevelActor::LowerToBottom(arg1);
32273     } catch (std::out_of_range& e) {
32274       {
32275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32276       };
32277     } catch (std::exception& e) {
32278       {
32279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32280       };
32281     } catch (...) {
32282       {
32283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32284       };
32285     }
32286   }
32287 }
32288
32289
32290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32291   Dali::Actor arg1 ;
32292   Dali::Actor arg2 ;
32293   Dali::Actor *argp1 ;
32294   Dali::Actor *argp2 ;
32295
32296   argp1 = (Dali::Actor *)jarg1;
32297   if (!argp1) {
32298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32299     return ;
32300   }
32301   arg1 = *argp1;
32302   argp2 = (Dali::Actor *)jarg2;
32303   if (!argp2) {
32304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32305     return ;
32306   }
32307   arg2 = *argp2;
32308   {
32309     try {
32310       Dali::DevelActor::RaiseAbove(arg1,arg2);
32311     } catch (std::out_of_range& e) {
32312       {
32313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32314       };
32315     } catch (std::exception& e) {
32316       {
32317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32318       };
32319     } catch (...) {
32320       {
32321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32322       };
32323     }
32324   }
32325 }
32326
32327
32328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32329   Dali::Actor arg1 ;
32330   Dali::Actor arg2 ;
32331   Dali::Actor *argp1 ;
32332   Dali::Actor *argp2 ;
32333
32334   argp1 = (Dali::Actor *)jarg1;
32335   if (!argp1) {
32336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32337     return ;
32338   }
32339   arg1 = *argp1;
32340   argp2 = (Dali::Actor *)jarg2;
32341   if (!argp2) {
32342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32343     return ;
32344   }
32345   arg2 = *argp2;
32346   {
32347     try {
32348       Dali::DevelActor::LowerBelow(arg1,arg2);
32349     } catch (std::out_of_range& e) {
32350       {
32351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32352       };
32353     } catch (std::exception& e) {
32354       {
32355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32356       };
32357     } catch (...) {
32358       {
32359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32360       };
32361     }
32362   }
32363 }
32364
32365
32366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32367   int jresult ;
32368   int result;
32369
32370   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32371   jresult = (int)result;
32372   return jresult;
32373 }
32374
32375
32376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32377   int jresult ;
32378   int result;
32379
32380   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32381   jresult = (int)result;
32382   return jresult;
32383 }
32384
32385
32386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32387   int jresult ;
32388   int result;
32389
32390   result = (int)Dali::Layer::Property::BEHAVIOR;
32391   jresult = (int)result;
32392   return jresult;
32393 }
32394
32395
32396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32397   void * jresult ;
32398   Dali::Layer::Property *result = 0 ;
32399
32400   {
32401     try {
32402       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32403     } catch (std::out_of_range& e) {
32404       {
32405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32406       };
32407     } catch (std::exception& e) {
32408       {
32409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32410       };
32411     } catch (...) {
32412       {
32413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32414       };
32415     }
32416   }
32417   jresult = (void *)result;
32418   return jresult;
32419 }
32420
32421
32422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32423   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32424
32425   arg1 = (Dali::Layer::Property *)jarg1;
32426   {
32427     try {
32428       delete arg1;
32429     } catch (std::out_of_range& e) {
32430       {
32431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32432       };
32433     } catch (std::exception& e) {
32434       {
32435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32436       };
32437     } catch (...) {
32438       {
32439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32440       };
32441     }
32442   }
32443 }
32444
32445
32446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32447   void * jresult ;
32448   Dali::Layer *result = 0 ;
32449
32450   {
32451     try {
32452       result = (Dali::Layer *)new Dali::Layer();
32453     } catch (std::out_of_range& e) {
32454       {
32455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32456       };
32457     } catch (std::exception& e) {
32458       {
32459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32460       };
32461     } catch (...) {
32462       {
32463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32464       };
32465     }
32466   }
32467   jresult = (void *)result;
32468   return jresult;
32469 }
32470
32471
32472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32473   void * jresult ;
32474   Dali::Layer result;
32475
32476   {
32477     try {
32478       result = Dali::Layer::New();
32479     } catch (std::out_of_range& e) {
32480       {
32481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32482       };
32483     } catch (std::exception& e) {
32484       {
32485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32486       };
32487     } catch (...) {
32488       {
32489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32490       };
32491     }
32492   }
32493   jresult = new Dali::Layer((const Dali::Layer &)result);
32494   return jresult;
32495 }
32496
32497
32498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32499   void * jresult ;
32500   Dali::BaseHandle arg1 ;
32501   Dali::BaseHandle *argp1 ;
32502   Dali::Layer result;
32503
32504   argp1 = (Dali::BaseHandle *)jarg1;
32505   if (!argp1) {
32506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32507     return 0;
32508   }
32509   arg1 = *argp1;
32510   {
32511     try {
32512       result = Dali::Layer::DownCast(arg1);
32513     } catch (std::out_of_range& e) {
32514       {
32515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32516       };
32517     } catch (std::exception& e) {
32518       {
32519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32520       };
32521     } catch (...) {
32522       {
32523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32524       };
32525     }
32526   }
32527   jresult = new Dali::Layer((const Dali::Layer &)result);
32528   return jresult;
32529 }
32530
32531
32532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32533   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32534
32535   arg1 = (Dali::Layer *)jarg1;
32536   {
32537     try {
32538       delete arg1;
32539     } catch (std::out_of_range& e) {
32540       {
32541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32542       };
32543     } catch (std::exception& e) {
32544       {
32545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32546       };
32547     } catch (...) {
32548       {
32549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32550       };
32551     }
32552   }
32553 }
32554
32555
32556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32557   void * jresult ;
32558   Dali::Layer *arg1 = 0 ;
32559   Dali::Layer *result = 0 ;
32560
32561   arg1 = (Dali::Layer *)jarg1;
32562   if (!arg1) {
32563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32564     return 0;
32565   }
32566   {
32567     try {
32568       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32569     } catch (std::out_of_range& e) {
32570       {
32571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32572       };
32573     } catch (std::exception& e) {
32574       {
32575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32576       };
32577     } catch (...) {
32578       {
32579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32580       };
32581     }
32582   }
32583   jresult = (void *)result;
32584   return jresult;
32585 }
32586
32587
32588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32589   void * jresult ;
32590   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32591   Dali::Layer *arg2 = 0 ;
32592   Dali::Layer *result = 0 ;
32593
32594   arg1 = (Dali::Layer *)jarg1;
32595   arg2 = (Dali::Layer *)jarg2;
32596   if (!arg2) {
32597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32598     return 0;
32599   }
32600   {
32601     try {
32602       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32603     } catch (std::out_of_range& e) {
32604       {
32605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32606       };
32607     } catch (std::exception& e) {
32608       {
32609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32610       };
32611     } catch (...) {
32612       {
32613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32614       };
32615     }
32616   }
32617   jresult = (void *)result;
32618   return jresult;
32619 }
32620
32621
32622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32623   unsigned int jresult ;
32624   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32625   unsigned int result;
32626
32627   arg1 = (Dali::Layer *)jarg1;
32628   {
32629     try {
32630       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32631     } catch (std::out_of_range& e) {
32632       {
32633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32634       };
32635     } catch (std::exception& e) {
32636       {
32637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32638       };
32639     } catch (...) {
32640       {
32641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32642       };
32643     }
32644   }
32645   jresult = result;
32646   return jresult;
32647 }
32648
32649
32650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32651   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32652
32653   arg1 = (Dali::Layer *)jarg1;
32654   {
32655     try {
32656       (arg1)->Raise();
32657     } catch (std::out_of_range& e) {
32658       {
32659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32660       };
32661     } catch (std::exception& e) {
32662       {
32663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32664       };
32665     } catch (...) {
32666       {
32667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32668       };
32669     }
32670   }
32671 }
32672
32673
32674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32675   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32676
32677   arg1 = (Dali::Layer *)jarg1;
32678   {
32679     try {
32680       (arg1)->Lower();
32681     } catch (std::out_of_range& e) {
32682       {
32683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32684       };
32685     } catch (std::exception& e) {
32686       {
32687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32688       };
32689     } catch (...) {
32690       {
32691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32692       };
32693     }
32694   }
32695 }
32696
32697
32698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32699   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32700   Dali::Layer arg2 ;
32701   Dali::Layer *argp2 ;
32702
32703   arg1 = (Dali::Layer *)jarg1;
32704   argp2 = (Dali::Layer *)jarg2;
32705   if (!argp2) {
32706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32707     return ;
32708   }
32709   arg2 = *argp2;
32710   {
32711     try {
32712       (arg1)->RaiseAbove(arg2);
32713     } catch (std::out_of_range& e) {
32714       {
32715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32716       };
32717     } catch (std::exception& e) {
32718       {
32719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32720       };
32721     } catch (...) {
32722       {
32723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32724       };
32725     }
32726   }
32727 }
32728
32729
32730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32731   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32732   Dali::Layer arg2 ;
32733   Dali::Layer *argp2 ;
32734
32735   arg1 = (Dali::Layer *)jarg1;
32736   argp2 = (Dali::Layer *)jarg2;
32737   if (!argp2) {
32738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32739     return ;
32740   }
32741   arg2 = *argp2;
32742   {
32743     try {
32744       (arg1)->LowerBelow(arg2);
32745     } catch (std::out_of_range& e) {
32746       {
32747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32748       };
32749     } catch (std::exception& e) {
32750       {
32751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32752       };
32753     } catch (...) {
32754       {
32755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32756       };
32757     }
32758   }
32759 }
32760
32761
32762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32763   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32764
32765   arg1 = (Dali::Layer *)jarg1;
32766   {
32767     try {
32768       (arg1)->RaiseToTop();
32769     } catch (std::out_of_range& e) {
32770       {
32771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32772       };
32773     } catch (std::exception& e) {
32774       {
32775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32776       };
32777     } catch (...) {
32778       {
32779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32780       };
32781     }
32782   }
32783 }
32784
32785
32786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32787   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32788
32789   arg1 = (Dali::Layer *)jarg1;
32790   {
32791     try {
32792       (arg1)->LowerToBottom();
32793     } catch (std::out_of_range& e) {
32794       {
32795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32796       };
32797     } catch (std::exception& e) {
32798       {
32799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32800       };
32801     } catch (...) {
32802       {
32803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32804       };
32805     }
32806   }
32807 }
32808
32809
32810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32811   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32812   Dali::Layer arg2 ;
32813   Dali::Layer *argp2 ;
32814
32815   arg1 = (Dali::Layer *)jarg1;
32816   argp2 = (Dali::Layer *)jarg2;
32817   if (!argp2) {
32818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32819     return ;
32820   }
32821   arg2 = *argp2;
32822   {
32823     try {
32824       (arg1)->MoveAbove(arg2);
32825     } catch (std::out_of_range& e) {
32826       {
32827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32828       };
32829     } catch (std::exception& e) {
32830       {
32831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32832       };
32833     } catch (...) {
32834       {
32835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32836       };
32837     }
32838   }
32839 }
32840
32841
32842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32843   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32844   Dali::Layer arg2 ;
32845   Dali::Layer *argp2 ;
32846
32847   arg1 = (Dali::Layer *)jarg1;
32848   argp2 = (Dali::Layer *)jarg2;
32849   if (!argp2) {
32850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32851     return ;
32852   }
32853   arg2 = *argp2;
32854   {
32855     try {
32856       (arg1)->MoveBelow(arg2);
32857     } catch (std::out_of_range& e) {
32858       {
32859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32860       };
32861     } catch (std::exception& e) {
32862       {
32863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32864       };
32865     } catch (...) {
32866       {
32867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32868       };
32869     }
32870   }
32871 }
32872
32873
32874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32875   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32876   Dali::Layer::Behavior arg2 ;
32877
32878   arg1 = (Dali::Layer *)jarg1;
32879   arg2 = (Dali::Layer::Behavior)jarg2;
32880   {
32881     try {
32882       (arg1)->SetBehavior(arg2);
32883     } catch (std::out_of_range& e) {
32884       {
32885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32886       };
32887     } catch (std::exception& e) {
32888       {
32889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32890       };
32891     } catch (...) {
32892       {
32893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32894       };
32895     }
32896   }
32897 }
32898
32899
32900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
32901   int jresult ;
32902   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32903   Dali::Layer::Behavior result;
32904
32905   arg1 = (Dali::Layer *)jarg1;
32906   {
32907     try {
32908       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32909     } catch (std::out_of_range& e) {
32910       {
32911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32912       };
32913     } catch (std::exception& e) {
32914       {
32915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32916       };
32917     } catch (...) {
32918       {
32919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32920       };
32921     }
32922   }
32923   jresult = (int)result;
32924   return jresult;
32925 }
32926
32927
32928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
32929   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32930   bool arg2 ;
32931
32932   arg1 = (Dali::Layer *)jarg1;
32933   arg2 = jarg2 ? true : false;
32934   {
32935     try {
32936       (arg1)->SetClipping(arg2);
32937     } catch (std::out_of_range& e) {
32938       {
32939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32940       };
32941     } catch (std::exception& e) {
32942       {
32943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32944       };
32945     } catch (...) {
32946       {
32947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32948       };
32949     }
32950   }
32951 }
32952
32953
32954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
32955   unsigned int jresult ;
32956   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32957   bool result;
32958
32959   arg1 = (Dali::Layer *)jarg1;
32960   {
32961     try {
32962       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
32963     } catch (std::out_of_range& e) {
32964       {
32965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32966       };
32967     } catch (std::exception& e) {
32968       {
32969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32970       };
32971     } catch (...) {
32972       {
32973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32974       };
32975     }
32976   }
32977   jresult = result;
32978   return jresult;
32979 }
32980
32981
32982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
32983   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32984   int arg2 ;
32985   int arg3 ;
32986   int arg4 ;
32987   int arg5 ;
32988
32989   arg1 = (Dali::Layer *)jarg1;
32990   arg2 = (int)jarg2;
32991   arg3 = (int)jarg3;
32992   arg4 = (int)jarg4;
32993   arg5 = (int)jarg5;
32994   {
32995     try {
32996       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
32997     } catch (std::out_of_range& e) {
32998       {
32999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33000       };
33001     } catch (std::exception& e) {
33002       {
33003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33004       };
33005     } catch (...) {
33006       {
33007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33008       };
33009     }
33010   }
33011 }
33012
33013
33014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33015   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33016   Dali::ClippingBox arg2 ;
33017   Dali::ClippingBox *argp2 ;
33018
33019   arg1 = (Dali::Layer *)jarg1;
33020   argp2 = (Dali::ClippingBox *)jarg2;
33021   if (!argp2) {
33022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33023     return ;
33024   }
33025   arg2 = *argp2;
33026   {
33027     try {
33028       (arg1)->SetClippingBox(arg2);
33029     } catch (std::out_of_range& e) {
33030       {
33031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33032       };
33033     } catch (std::exception& e) {
33034       {
33035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33036       };
33037     } catch (...) {
33038       {
33039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33040       };
33041     }
33042   }
33043 }
33044
33045
33046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33047   void * jresult ;
33048   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33049   Dali::ClippingBox result;
33050
33051   arg1 = (Dali::Layer *)jarg1;
33052   {
33053     try {
33054       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33055     } catch (std::out_of_range& e) {
33056       {
33057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33058       };
33059     } catch (std::exception& e) {
33060       {
33061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33062       };
33063     } catch (...) {
33064       {
33065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33066       };
33067     }
33068   }
33069   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33070   return jresult;
33071 }
33072
33073
33074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33075   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33076   bool arg2 ;
33077
33078   arg1 = (Dali::Layer *)jarg1;
33079   arg2 = jarg2 ? true : false;
33080   {
33081     try {
33082       (arg1)->SetDepthTestDisabled(arg2);
33083     } catch (std::out_of_range& e) {
33084       {
33085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33086       };
33087     } catch (std::exception& e) {
33088       {
33089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33090       };
33091     } catch (...) {
33092       {
33093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33094       };
33095     }
33096   }
33097 }
33098
33099
33100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33101   unsigned int jresult ;
33102   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33103   bool result;
33104
33105   arg1 = (Dali::Layer *)jarg1;
33106   {
33107     try {
33108       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33109     } catch (std::out_of_range& e) {
33110       {
33111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33112       };
33113     } catch (std::exception& e) {
33114       {
33115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33116       };
33117     } catch (...) {
33118       {
33119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33120       };
33121     }
33122   }
33123   jresult = result;
33124   return jresult;
33125 }
33126
33127
33128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33129   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33130   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33131
33132   arg1 = (Dali::Layer *)jarg1;
33133   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33134   {
33135     try {
33136       (arg1)->SetSortFunction(arg2);
33137     } catch (std::out_of_range& e) {
33138       {
33139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33140       };
33141     } catch (std::exception& e) {
33142       {
33143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33144       };
33145     } catch (...) {
33146       {
33147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33148       };
33149     }
33150   }
33151 }
33152
33153
33154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33155   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33156   bool arg2 ;
33157
33158   arg1 = (Dali::Layer *)jarg1;
33159   arg2 = jarg2 ? true : false;
33160   {
33161     try {
33162       (arg1)->SetTouchConsumed(arg2);
33163     } catch (std::out_of_range& e) {
33164       {
33165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33166       };
33167     } catch (std::exception& e) {
33168       {
33169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33170       };
33171     } catch (...) {
33172       {
33173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33174       };
33175     }
33176   }
33177 }
33178
33179
33180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33181   unsigned int jresult ;
33182   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33183   bool result;
33184
33185   arg1 = (Dali::Layer *)jarg1;
33186   {
33187     try {
33188       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33189     } catch (std::out_of_range& e) {
33190       {
33191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33192       };
33193     } catch (std::exception& e) {
33194       {
33195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33196       };
33197     } catch (...) {
33198       {
33199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33200       };
33201     }
33202   }
33203   jresult = result;
33204   return jresult;
33205 }
33206
33207
33208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33209   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33210   bool arg2 ;
33211
33212   arg1 = (Dali::Layer *)jarg1;
33213   arg2 = jarg2 ? true : false;
33214   {
33215     try {
33216       (arg1)->SetHoverConsumed(arg2);
33217     } catch (std::out_of_range& e) {
33218       {
33219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33220       };
33221     } catch (std::exception& e) {
33222       {
33223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33224       };
33225     } catch (...) {
33226       {
33227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33228       };
33229     }
33230   }
33231 }
33232
33233
33234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33235   unsigned int jresult ;
33236   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33237   bool result;
33238
33239   arg1 = (Dali::Layer *)jarg1;
33240   {
33241     try {
33242       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33243     } catch (std::out_of_range& e) {
33244       {
33245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33246       };
33247     } catch (std::exception& e) {
33248       {
33249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33250       };
33251     } catch (...) {
33252       {
33253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33254       };
33255     }
33256   }
33257   jresult = result;
33258   return jresult;
33259 }
33260
33261
33262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33263   void * jresult ;
33264   Dali::Vector4 *result = 0 ;
33265
33266   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33267   jresult = (void *)result;
33268   return jresult;
33269 }
33270
33271
33272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33273   void * jresult ;
33274   Dali::Vector4 *result = 0 ;
33275
33276   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33277   jresult = (void *)result;
33278   return jresult;
33279 }
33280
33281
33282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33283   void * jresult ;
33284   Dali::Stage *result = 0 ;
33285
33286   {
33287     try {
33288       result = (Dali::Stage *)new Dali::Stage();
33289     } catch (std::out_of_range& e) {
33290       {
33291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33292       };
33293     } catch (std::exception& e) {
33294       {
33295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33296       };
33297     } catch (...) {
33298       {
33299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33300       };
33301     }
33302   }
33303   jresult = (void *)result;
33304   return jresult;
33305 }
33306
33307
33308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33309   void * jresult ;
33310   Dali::Stage result;
33311
33312   {
33313     try {
33314       result = Dali::Stage::GetCurrent();
33315     } catch (std::out_of_range& e) {
33316       {
33317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33318       };
33319     } catch (std::exception& e) {
33320       {
33321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33322       };
33323     } catch (...) {
33324       {
33325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33326       };
33327     }
33328   }
33329   jresult = new Dali::Stage((const Dali::Stage &)result);
33330   return jresult;
33331 }
33332
33333
33334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33335   unsigned int jresult ;
33336   bool result;
33337
33338   {
33339     try {
33340       result = (bool)Dali::Stage::IsInstalled();
33341     } catch (std::out_of_range& e) {
33342       {
33343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33344       };
33345     } catch (std::exception& e) {
33346       {
33347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33348       };
33349     } catch (...) {
33350       {
33351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33352       };
33353     }
33354   }
33355   jresult = result;
33356   return jresult;
33357 }
33358
33359
33360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33361   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33362
33363   arg1 = (Dali::Stage *)jarg1;
33364   {
33365     try {
33366       delete arg1;
33367     } catch (std::out_of_range& e) {
33368       {
33369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33370       };
33371     } catch (std::exception& e) {
33372       {
33373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33374       };
33375     } catch (...) {
33376       {
33377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33378       };
33379     }
33380   }
33381 }
33382
33383
33384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33385   void * jresult ;
33386   Dali::Stage *arg1 = 0 ;
33387   Dali::Stage *result = 0 ;
33388
33389   arg1 = (Dali::Stage *)jarg1;
33390   if (!arg1) {
33391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33392     return 0;
33393   }
33394   {
33395     try {
33396       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33397     } catch (std::out_of_range& e) {
33398       {
33399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33400       };
33401     } catch (std::exception& e) {
33402       {
33403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33404       };
33405     } catch (...) {
33406       {
33407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33408       };
33409     }
33410   }
33411   jresult = (void *)result;
33412   return jresult;
33413 }
33414
33415
33416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33417   void * jresult ;
33418   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33419   Dali::Stage *arg2 = 0 ;
33420   Dali::Stage *result = 0 ;
33421
33422   arg1 = (Dali::Stage *)jarg1;
33423   arg2 = (Dali::Stage *)jarg2;
33424   if (!arg2) {
33425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33426     return 0;
33427   }
33428   {
33429     try {
33430       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33431     } catch (std::out_of_range& e) {
33432       {
33433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33434       };
33435     } catch (std::exception& e) {
33436       {
33437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33438       };
33439     } catch (...) {
33440       {
33441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33442       };
33443     }
33444   }
33445   jresult = (void *)result;
33446   return jresult;
33447 }
33448
33449
33450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33451   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33452   Dali::Actor *arg2 = 0 ;
33453
33454   arg1 = (Dali::Stage *)jarg1;
33455   arg2 = (Dali::Actor *)jarg2;
33456   if (!arg2) {
33457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33458     return ;
33459   }
33460   {
33461     try {
33462       (arg1)->Add(*arg2);
33463     } catch (std::out_of_range& e) {
33464       {
33465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33466       };
33467     } catch (std::exception& e) {
33468       {
33469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33470       };
33471     } catch (...) {
33472       {
33473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33474       };
33475     }
33476   }
33477 }
33478
33479
33480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33481   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33482   Dali::Actor *arg2 = 0 ;
33483
33484   arg1 = (Dali::Stage *)jarg1;
33485   arg2 = (Dali::Actor *)jarg2;
33486   if (!arg2) {
33487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33488     return ;
33489   }
33490   {
33491     try {
33492       (arg1)->Remove(*arg2);
33493     } catch (std::out_of_range& e) {
33494       {
33495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33496       };
33497     } catch (std::exception& e) {
33498       {
33499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33500       };
33501     } catch (...) {
33502       {
33503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33504       };
33505     }
33506   }
33507 }
33508
33509
33510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33511   void * jresult ;
33512   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33513   Dali::Vector2 result;
33514
33515   arg1 = (Dali::Stage *)jarg1;
33516   {
33517     try {
33518       result = ((Dali::Stage const *)arg1)->GetSize();
33519     } catch (std::out_of_range& e) {
33520       {
33521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33522       };
33523     } catch (std::exception& e) {
33524       {
33525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33526       };
33527     } catch (...) {
33528       {
33529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33530       };
33531     }
33532   }
33533   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33534   return jresult;
33535 }
33536
33537
33538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33539   void * jresult ;
33540   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33541   Dali::RenderTaskList result;
33542
33543   arg1 = (Dali::Stage *)jarg1;
33544   {
33545     try {
33546       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33547     } catch (std::out_of_range& e) {
33548       {
33549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33550       };
33551     } catch (std::exception& e) {
33552       {
33553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33554       };
33555     } catch (...) {
33556       {
33557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33558       };
33559     }
33560   }
33561   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33562   return jresult;
33563 }
33564
33565
33566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33567   unsigned int jresult ;
33568   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33569   unsigned int result;
33570
33571   arg1 = (Dali::Stage *)jarg1;
33572   {
33573     try {
33574       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33575     } catch (std::out_of_range& e) {
33576       {
33577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33578       };
33579     } catch (std::exception& e) {
33580       {
33581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33582       };
33583     } catch (...) {
33584       {
33585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33586       };
33587     }
33588   }
33589   jresult = result;
33590   return jresult;
33591 }
33592
33593
33594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33595   void * jresult ;
33596   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33597   unsigned int arg2 ;
33598   Dali::Layer result;
33599
33600   arg1 = (Dali::Stage *)jarg1;
33601   arg2 = (unsigned int)jarg2;
33602   {
33603     try {
33604       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33605     } catch (std::out_of_range& e) {
33606       {
33607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33608       };
33609     } catch (std::exception& e) {
33610       {
33611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33612       };
33613     } catch (...) {
33614       {
33615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33616       };
33617     }
33618   }
33619   jresult = new Dali::Layer((const Dali::Layer &)result);
33620   return jresult;
33621 }
33622
33623
33624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33625   void * jresult ;
33626   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33627   Dali::Layer result;
33628
33629   arg1 = (Dali::Stage *)jarg1;
33630   {
33631     try {
33632       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33633     } catch (std::out_of_range& e) {
33634       {
33635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33636       };
33637     } catch (std::exception& e) {
33638       {
33639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33640       };
33641     } catch (...) {
33642       {
33643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33644       };
33645     }
33646   }
33647   jresult = new Dali::Layer((const Dali::Layer &)result);
33648   return jresult;
33649 }
33650
33651
33652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33653   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33654   Dali::Vector4 arg2 ;
33655   Dali::Vector4 *argp2 ;
33656
33657   arg1 = (Dali::Stage *)jarg1;
33658   argp2 = (Dali::Vector4 *)jarg2;
33659   if (!argp2) {
33660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33661     return ;
33662   }
33663   arg2 = *argp2;
33664   {
33665     try {
33666       (arg1)->SetBackgroundColor(arg2);
33667     } catch (std::out_of_range& e) {
33668       {
33669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33670       };
33671     } catch (std::exception& e) {
33672       {
33673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33674       };
33675     } catch (...) {
33676       {
33677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33678       };
33679     }
33680   }
33681 }
33682
33683
33684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33685   void * jresult ;
33686   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33687   Dali::Vector4 result;
33688
33689   arg1 = (Dali::Stage *)jarg1;
33690   {
33691     try {
33692       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33693     } catch (std::out_of_range& e) {
33694       {
33695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33696       };
33697     } catch (std::exception& e) {
33698       {
33699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33700       };
33701     } catch (...) {
33702       {
33703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33704       };
33705     }
33706   }
33707   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33708   return jresult;
33709 }
33710
33711
33712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33713   void * jresult ;
33714   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33715   Dali::Vector2 result;
33716
33717   arg1 = (Dali::Stage *)jarg1;
33718   {
33719     try {
33720       result = ((Dali::Stage const *)arg1)->GetDpi();
33721     } catch (std::out_of_range& e) {
33722       {
33723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33724       };
33725     } catch (std::exception& e) {
33726       {
33727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33728       };
33729     } catch (...) {
33730       {
33731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33732       };
33733     }
33734   }
33735   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33736   return jresult;
33737 }
33738
33739
33740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33741   void * jresult ;
33742   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33743   Dali::ObjectRegistry result;
33744
33745   arg1 = (Dali::Stage *)jarg1;
33746   {
33747     try {
33748       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33749     } catch (std::out_of_range& e) {
33750       {
33751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33752       };
33753     } catch (std::exception& e) {
33754       {
33755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33756       };
33757     } catch (...) {
33758       {
33759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33760       };
33761     }
33762   }
33763   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33764   return jresult;
33765 }
33766
33767
33768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33769   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33770   float arg2 ;
33771
33772   arg1 = (Dali::Stage *)jarg1;
33773   arg2 = (float)jarg2;
33774   {
33775     try {
33776       (arg1)->KeepRendering(arg2);
33777     } catch (std::out_of_range& e) {
33778       {
33779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33780       };
33781     } catch (std::exception& e) {
33782       {
33783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33784       };
33785     } catch (...) {
33786       {
33787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33788       };
33789     }
33790   }
33791 }
33792
33793
33794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33795   void * jresult ;
33796   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33797   Dali::Stage::KeyEventSignalType *result = 0 ;
33798
33799   arg1 = (Dali::Stage *)jarg1;
33800   {
33801     try {
33802       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33803     } catch (std::out_of_range& e) {
33804       {
33805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33806       };
33807     } catch (std::exception& e) {
33808       {
33809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33810       };
33811     } catch (...) {
33812       {
33813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33814       };
33815     }
33816   }
33817   jresult = (void *)result;
33818   return jresult;
33819 }
33820
33821
33822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33823   void * jresult ;
33824   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33825   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33826
33827   arg1 = (Dali::Stage *)jarg1;
33828   {
33829     try {
33830       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33831     } catch (std::out_of_range& e) {
33832       {
33833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33834       };
33835     } catch (std::exception& e) {
33836       {
33837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33838       };
33839     } catch (...) {
33840       {
33841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33842       };
33843     }
33844   }
33845   jresult = (void *)result;
33846   return jresult;
33847 }
33848
33849
33850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33851   void * jresult ;
33852   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33853   Dali::Stage::TouchSignalType *result = 0 ;
33854
33855   arg1 = (Dali::Stage *)jarg1;
33856   {
33857     try {
33858       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33859     } catch (std::out_of_range& e) {
33860       {
33861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33862       };
33863     } catch (std::exception& e) {
33864       {
33865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33866       };
33867     } catch (...) {
33868       {
33869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33870       };
33871     }
33872   }
33873   jresult = (void *)result;
33874   return jresult;
33875 }
33876
33877
33878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33879   void * jresult ;
33880   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33881   Dali::Stage::WheelEventSignalType *result = 0 ;
33882
33883   arg1 = (Dali::Stage *)jarg1;
33884   {
33885     try {
33886       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33887     } catch (std::out_of_range& e) {
33888       {
33889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33890       };
33891     } catch (std::exception& e) {
33892       {
33893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33894       };
33895     } catch (...) {
33896       {
33897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33898       };
33899     }
33900   }
33901   jresult = (void *)result;
33902   return jresult;
33903 }
33904
33905
33906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
33907   void * jresult ;
33908   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33909   Dali::Stage::ContextStatusSignal *result = 0 ;
33910
33911   arg1 = (Dali::Stage *)jarg1;
33912   {
33913     try {
33914       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33915     } catch (std::out_of_range& e) {
33916       {
33917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33918       };
33919     } catch (std::exception& e) {
33920       {
33921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33922       };
33923     } catch (...) {
33924       {
33925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33926       };
33927     }
33928   }
33929   jresult = (void *)result;
33930   return jresult;
33931 }
33932
33933
33934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
33935   void * jresult ;
33936   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33937   Dali::Stage::ContextStatusSignal *result = 0 ;
33938
33939   arg1 = (Dali::Stage *)jarg1;
33940   {
33941     try {
33942       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
33943     } catch (std::out_of_range& e) {
33944       {
33945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33946       };
33947     } catch (std::exception& e) {
33948       {
33949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33950       };
33951     } catch (...) {
33952       {
33953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33954       };
33955     }
33956   }
33957   jresult = (void *)result;
33958   return jresult;
33959 }
33960
33961
33962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
33963   void * jresult ;
33964   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33965   Dali::Stage::SceneCreatedSignalType *result = 0 ;
33966
33967   arg1 = (Dali::Stage *)jarg1;
33968   {
33969     try {
33970       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
33971     } catch (std::out_of_range& e) {
33972       {
33973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33974       };
33975     } catch (std::exception& e) {
33976       {
33977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33978       };
33979     } catch (...) {
33980       {
33981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33982       };
33983     }
33984   }
33985   jresult = (void *)result;
33986   return jresult;
33987 }
33988
33989
33990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
33991   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33992
33993   arg1 = (Dali::RelayoutContainer *)jarg1;
33994   {
33995     try {
33996       delete arg1;
33997     } catch (std::out_of_range& e) {
33998       {
33999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34000       };
34001     } catch (std::exception& e) {
34002       {
34003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34004       };
34005     } catch (...) {
34006       {
34007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34008       };
34009     }
34010   }
34011 }
34012
34013
34014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34015   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34016   Dali::Actor *arg2 = 0 ;
34017   Dali::Vector2 *arg3 = 0 ;
34018
34019   arg1 = (Dali::RelayoutContainer *)jarg1;
34020   arg2 = (Dali::Actor *)jarg2;
34021   if (!arg2) {
34022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34023     return ;
34024   }
34025   arg3 = (Dali::Vector2 *)jarg3;
34026   if (!arg3) {
34027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34028     return ;
34029   }
34030   {
34031     try {
34032       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34033     } catch (std::out_of_range& e) {
34034       {
34035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34036       };
34037     } catch (std::exception& e) {
34038       {
34039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34040       };
34041     } catch (...) {
34042       {
34043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34044       };
34045     }
34046   }
34047 }
34048
34049
34050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34051   void * jresult ;
34052   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34053   Dali::CustomActor result;
34054
34055   arg1 = (Dali::CustomActorImpl *)jarg1;
34056   {
34057     try {
34058       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34059     } catch (std::out_of_range& e) {
34060       {
34061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34062       };
34063     } catch (std::exception& e) {
34064       {
34065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34066       };
34067     } catch (...) {
34068       {
34069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34070       };
34071     }
34072   }
34073   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34074   return jresult;
34075 }
34076
34077
34078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34079   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34080   int arg2 ;
34081
34082   arg1 = (Dali::CustomActorImpl *)jarg1;
34083   arg2 = (int)jarg2;
34084   {
34085     try {
34086       (arg1)->OnStageConnection(arg2);
34087     } catch (std::out_of_range& e) {
34088       {
34089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34090       };
34091     } catch (std::exception& e) {
34092       {
34093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34094       };
34095     } catch (...) {
34096       {
34097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34098       };
34099     }
34100   }
34101 }
34102
34103
34104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34105   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34106
34107   arg1 = (Dali::CustomActorImpl *)jarg1;
34108   {
34109     try {
34110       (arg1)->OnStageDisconnection();
34111     } catch (std::out_of_range& e) {
34112       {
34113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34114       };
34115     } catch (std::exception& e) {
34116       {
34117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34118       };
34119     } catch (...) {
34120       {
34121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34122       };
34123     }
34124   }
34125 }
34126
34127
34128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34129   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34130   Dali::Actor *arg2 = 0 ;
34131
34132   arg1 = (Dali::CustomActorImpl *)jarg1;
34133   arg2 = (Dali::Actor *)jarg2;
34134   if (!arg2) {
34135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34136     return ;
34137   }
34138   {
34139     try {
34140       (arg1)->OnChildAdd(*arg2);
34141     } catch (std::out_of_range& e) {
34142       {
34143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34144       };
34145     } catch (std::exception& e) {
34146       {
34147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34148       };
34149     } catch (...) {
34150       {
34151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34152       };
34153     }
34154   }
34155 }
34156
34157
34158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34159   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34160   Dali::Actor *arg2 = 0 ;
34161
34162   arg1 = (Dali::CustomActorImpl *)jarg1;
34163   arg2 = (Dali::Actor *)jarg2;
34164   if (!arg2) {
34165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34166     return ;
34167   }
34168   {
34169     try {
34170       (arg1)->OnChildRemove(*arg2);
34171     } catch (std::out_of_range& e) {
34172       {
34173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34174       };
34175     } catch (std::exception& e) {
34176       {
34177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34178       };
34179     } catch (...) {
34180       {
34181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34182       };
34183     }
34184   }
34185 }
34186
34187
34188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34189   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34190   Dali::Property::Index arg2 ;
34191   Dali::Property::Value arg3 ;
34192   Dali::Property::Value *argp3 ;
34193
34194   arg1 = (Dali::CustomActorImpl *)jarg1;
34195   arg2 = (Dali::Property::Index)jarg2;
34196   argp3 = (Dali::Property::Value *)jarg3;
34197   if (!argp3) {
34198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34199     return ;
34200   }
34201   arg3 = *argp3;
34202   {
34203     try {
34204       (arg1)->OnPropertySet(arg2,arg3);
34205     } catch (std::out_of_range& e) {
34206       {
34207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34208       };
34209     } catch (std::exception& e) {
34210       {
34211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34212       };
34213     } catch (...) {
34214       {
34215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34216       };
34217     }
34218   }
34219 }
34220
34221
34222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34223   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34224   Dali::Vector3 *arg2 = 0 ;
34225
34226   arg1 = (Dali::CustomActorImpl *)jarg1;
34227   arg2 = (Dali::Vector3 *)jarg2;
34228   if (!arg2) {
34229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34230     return ;
34231   }
34232   {
34233     try {
34234       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34235     } catch (std::out_of_range& e) {
34236       {
34237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34238       };
34239     } catch (std::exception& e) {
34240       {
34241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34242       };
34243     } catch (...) {
34244       {
34245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34246       };
34247     }
34248   }
34249 }
34250
34251
34252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34253   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34254   Dali::Animation *arg2 = 0 ;
34255   Dali::Vector3 *arg3 = 0 ;
34256
34257   arg1 = (Dali::CustomActorImpl *)jarg1;
34258   arg2 = (Dali::Animation *)jarg2;
34259   if (!arg2) {
34260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34261     return ;
34262   }
34263   arg3 = (Dali::Vector3 *)jarg3;
34264   if (!arg3) {
34265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34266     return ;
34267   }
34268   {
34269     try {
34270       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34271     } catch (std::out_of_range& e) {
34272       {
34273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34274       };
34275     } catch (std::exception& e) {
34276       {
34277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34278       };
34279     } catch (...) {
34280       {
34281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34282       };
34283     }
34284   }
34285 }
34286
34287
34288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34289   unsigned int jresult ;
34290   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34291   Dali::TouchEvent *arg2 = 0 ;
34292   bool result;
34293
34294   arg1 = (Dali::CustomActorImpl *)jarg1;
34295   arg2 = (Dali::TouchEvent *)jarg2;
34296   if (!arg2) {
34297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34298     return 0;
34299   }
34300   {
34301     try {
34302       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34303     } catch (std::out_of_range& e) {
34304       {
34305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34306       };
34307     } catch (std::exception& e) {
34308       {
34309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34310       };
34311     } catch (...) {
34312       {
34313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34314       };
34315     }
34316   }
34317   jresult = result;
34318   return jresult;
34319 }
34320
34321
34322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34323   unsigned int jresult ;
34324   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34325   Dali::HoverEvent *arg2 = 0 ;
34326   bool result;
34327
34328   arg1 = (Dali::CustomActorImpl *)jarg1;
34329   arg2 = (Dali::HoverEvent *)jarg2;
34330   if (!arg2) {
34331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34332     return 0;
34333   }
34334   {
34335     try {
34336       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34337     } catch (std::out_of_range& e) {
34338       {
34339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34340       };
34341     } catch (std::exception& e) {
34342       {
34343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34344       };
34345     } catch (...) {
34346       {
34347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34348       };
34349     }
34350   }
34351   jresult = result;
34352   return jresult;
34353 }
34354
34355
34356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34357   unsigned int jresult ;
34358   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34359   Dali::KeyEvent *arg2 = 0 ;
34360   bool result;
34361
34362   arg1 = (Dali::CustomActorImpl *)jarg1;
34363   arg2 = (Dali::KeyEvent *)jarg2;
34364   if (!arg2) {
34365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34366     return 0;
34367   }
34368   {
34369     try {
34370       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34371     } catch (std::out_of_range& e) {
34372       {
34373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34374       };
34375     } catch (std::exception& e) {
34376       {
34377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34378       };
34379     } catch (...) {
34380       {
34381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34382       };
34383     }
34384   }
34385   jresult = result;
34386   return jresult;
34387 }
34388
34389
34390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34391   unsigned int jresult ;
34392   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34393   Dali::WheelEvent *arg2 = 0 ;
34394   bool result;
34395
34396   arg1 = (Dali::CustomActorImpl *)jarg1;
34397   arg2 = (Dali::WheelEvent *)jarg2;
34398   if (!arg2) {
34399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34400     return 0;
34401   }
34402   {
34403     try {
34404       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34405     } catch (std::out_of_range& e) {
34406       {
34407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34408       };
34409     } catch (std::exception& e) {
34410       {
34411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34412       };
34413     } catch (...) {
34414       {
34415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34416       };
34417     }
34418   }
34419   jresult = result;
34420   return jresult;
34421 }
34422
34423
34424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34425   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34426   Dali::Vector2 *arg2 = 0 ;
34427   Dali::RelayoutContainer *arg3 = 0 ;
34428
34429   arg1 = (Dali::CustomActorImpl *)jarg1;
34430   arg2 = (Dali::Vector2 *)jarg2;
34431   if (!arg2) {
34432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34433     return ;
34434   }
34435   arg3 = (Dali::RelayoutContainer *)jarg3;
34436   if (!arg3) {
34437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34438     return ;
34439   }
34440   {
34441     try {
34442       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34443     } catch (std::out_of_range& e) {
34444       {
34445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34446       };
34447     } catch (std::exception& e) {
34448       {
34449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34450       };
34451     } catch (...) {
34452       {
34453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34454       };
34455     }
34456   }
34457 }
34458
34459
34460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34461   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34462   Dali::ResizePolicy::Type arg2 ;
34463   Dali::Dimension::Type arg3 ;
34464
34465   arg1 = (Dali::CustomActorImpl *)jarg1;
34466   arg2 = (Dali::ResizePolicy::Type)jarg2;
34467   arg3 = (Dali::Dimension::Type)jarg3;
34468   {
34469     try {
34470       (arg1)->OnSetResizePolicy(arg2,arg3);
34471     } catch (std::out_of_range& e) {
34472       {
34473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34474       };
34475     } catch (std::exception& e) {
34476       {
34477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34478       };
34479     } catch (...) {
34480       {
34481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34482       };
34483     }
34484   }
34485 }
34486
34487
34488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34489   void * jresult ;
34490   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34491   Dali::Vector3 result;
34492
34493   arg1 = (Dali::CustomActorImpl *)jarg1;
34494   {
34495     try {
34496       result = (arg1)->GetNaturalSize();
34497     } catch (std::out_of_range& e) {
34498       {
34499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34500       };
34501     } catch (std::exception& e) {
34502       {
34503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34504       };
34505     } catch (...) {
34506       {
34507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34508       };
34509     }
34510   }
34511   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34512   return jresult;
34513 }
34514
34515
34516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34517   float jresult ;
34518   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34519   Dali::Actor *arg2 = 0 ;
34520   Dali::Dimension::Type arg3 ;
34521   float result;
34522
34523   arg1 = (Dali::CustomActorImpl *)jarg1;
34524   arg2 = (Dali::Actor *)jarg2;
34525   if (!arg2) {
34526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34527     return 0;
34528   }
34529   arg3 = (Dali::Dimension::Type)jarg3;
34530   {
34531     try {
34532       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34533     } catch (std::out_of_range& e) {
34534       {
34535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34536       };
34537     } catch (std::exception& e) {
34538       {
34539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34540       };
34541     } catch (...) {
34542       {
34543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34544       };
34545     }
34546   }
34547   jresult = result;
34548   return jresult;
34549 }
34550
34551
34552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34553   float jresult ;
34554   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34555   float arg2 ;
34556   float result;
34557
34558   arg1 = (Dali::CustomActorImpl *)jarg1;
34559   arg2 = (float)jarg2;
34560   {
34561     try {
34562       result = (float)(arg1)->GetHeightForWidth(arg2);
34563     } catch (std::out_of_range& e) {
34564       {
34565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34566       };
34567     } catch (std::exception& e) {
34568       {
34569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34570       };
34571     } catch (...) {
34572       {
34573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34574       };
34575     }
34576   }
34577   jresult = result;
34578   return jresult;
34579 }
34580
34581
34582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34583   float jresult ;
34584   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34585   float arg2 ;
34586   float result;
34587
34588   arg1 = (Dali::CustomActorImpl *)jarg1;
34589   arg2 = (float)jarg2;
34590   {
34591     try {
34592       result = (float)(arg1)->GetWidthForHeight(arg2);
34593     } catch (std::out_of_range& e) {
34594       {
34595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34596       };
34597     } catch (std::exception& e) {
34598       {
34599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34600       };
34601     } catch (...) {
34602       {
34603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34604       };
34605     }
34606   }
34607   jresult = result;
34608   return jresult;
34609 }
34610
34611
34612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34613   unsigned int jresult ;
34614   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34615   Dali::Dimension::Type arg2 ;
34616   bool result;
34617
34618   arg1 = (Dali::CustomActorImpl *)jarg1;
34619   arg2 = (Dali::Dimension::Type)jarg2;
34620   {
34621     try {
34622       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34623     } catch (std::out_of_range& e) {
34624       {
34625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34626       };
34627     } catch (std::exception& e) {
34628       {
34629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34630       };
34631     } catch (...) {
34632       {
34633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34634       };
34635     }
34636   }
34637   jresult = result;
34638   return jresult;
34639 }
34640
34641
34642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34643   unsigned int jresult ;
34644   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34645   bool result;
34646
34647   arg1 = (Dali::CustomActorImpl *)jarg1;
34648   {
34649     try {
34650       result = (bool)(arg1)->RelayoutDependentOnChildren();
34651     } catch (std::out_of_range& e) {
34652       {
34653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34654       };
34655     } catch (std::exception& e) {
34656       {
34657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34658       };
34659     } catch (...) {
34660       {
34661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34662       };
34663     }
34664   }
34665   jresult = result;
34666   return jresult;
34667 }
34668
34669
34670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34671   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34672   Dali::Dimension::Type arg2 ;
34673
34674   arg1 = (Dali::CustomActorImpl *)jarg1;
34675   arg2 = (Dali::Dimension::Type)jarg2;
34676   {
34677     try {
34678       (arg1)->OnCalculateRelayoutSize(arg2);
34679     } catch (std::out_of_range& e) {
34680       {
34681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34682       };
34683     } catch (std::exception& e) {
34684       {
34685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34686       };
34687     } catch (...) {
34688       {
34689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34690       };
34691     }
34692   }
34693 }
34694
34695
34696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34697   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34698   float arg2 ;
34699   Dali::Dimension::Type arg3 ;
34700
34701   arg1 = (Dali::CustomActorImpl *)jarg1;
34702   arg2 = (float)jarg2;
34703   arg3 = (Dali::Dimension::Type)jarg3;
34704   {
34705     try {
34706       (arg1)->OnLayoutNegotiated(arg2,arg3);
34707     } catch (std::out_of_range& e) {
34708       {
34709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34710       };
34711     } catch (std::exception& e) {
34712       {
34713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34714       };
34715     } catch (...) {
34716       {
34717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34718       };
34719     }
34720   }
34721 }
34722
34723
34724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34725   unsigned int jresult ;
34726   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34727   bool result;
34728
34729   arg1 = (Dali::CustomActorImpl *)jarg1;
34730   {
34731     try {
34732       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34733     } catch (std::out_of_range& e) {
34734       {
34735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34736       };
34737     } catch (std::exception& e) {
34738       {
34739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34740       };
34741     } catch (...) {
34742       {
34743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34744       };
34745     }
34746   }
34747   jresult = result;
34748   return jresult;
34749 }
34750
34751
34752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34753   unsigned int jresult ;
34754   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34755   bool result;
34756
34757   arg1 = (Dali::CustomActorImpl *)jarg1;
34758   {
34759     try {
34760       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34761     } catch (std::out_of_range& e) {
34762       {
34763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34764       };
34765     } catch (std::exception& e) {
34766       {
34767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34768       };
34769     } catch (...) {
34770       {
34771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34772       };
34773     }
34774   }
34775   jresult = result;
34776   return jresult;
34777 }
34778
34779
34780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34781   unsigned int jresult ;
34782   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34783   bool result;
34784
34785   arg1 = (Dali::CustomActorImpl *)jarg1;
34786   {
34787     try {
34788       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34789     } catch (std::out_of_range& e) {
34790       {
34791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34792       };
34793     } catch (std::exception& e) {
34794       {
34795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34796       };
34797     } catch (...) {
34798       {
34799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34800       };
34801     }
34802   }
34803   jresult = result;
34804   return jresult;
34805 }
34806
34807
34808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34809   unsigned int jresult ;
34810   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34811   bool result;
34812
34813   arg1 = (Dali::CustomActorImpl *)jarg1;
34814   {
34815     try {
34816       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34817     } catch (std::out_of_range& e) {
34818       {
34819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34820       };
34821     } catch (std::exception& e) {
34822       {
34823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34824       };
34825     } catch (...) {
34826       {
34827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34828       };
34829     }
34830   }
34831   jresult = result;
34832   return jresult;
34833 }
34834
34835
34836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34837   void * jresult ;
34838   Dali::CustomActor *result = 0 ;
34839
34840   {
34841     try {
34842       result = (Dali::CustomActor *)new Dali::CustomActor();
34843     } catch (std::out_of_range& e) {
34844       {
34845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34846       };
34847     } catch (std::exception& e) {
34848       {
34849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34850       };
34851     } catch (...) {
34852       {
34853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34854       };
34855     }
34856   }
34857   jresult = (void *)result;
34858   return jresult;
34859 }
34860
34861
34862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34863   void * jresult ;
34864   Dali::BaseHandle arg1 ;
34865   Dali::BaseHandle *argp1 ;
34866   Dali::CustomActor result;
34867
34868   argp1 = (Dali::BaseHandle *)jarg1;
34869   if (!argp1) {
34870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34871     return 0;
34872   }
34873   arg1 = *argp1;
34874   {
34875     try {
34876       result = Dali::CustomActor::DownCast(arg1);
34877     } catch (std::out_of_range& e) {
34878       {
34879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34880       };
34881     } catch (std::exception& e) {
34882       {
34883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34884       };
34885     } catch (...) {
34886       {
34887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34888       };
34889     }
34890   }
34891   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34892   return jresult;
34893 }
34894
34895
34896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34897   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34898
34899   arg1 = (Dali::CustomActor *)jarg1;
34900   {
34901     try {
34902       delete arg1;
34903     } catch (std::out_of_range& e) {
34904       {
34905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34906       };
34907     } catch (std::exception& e) {
34908       {
34909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34910       };
34911     } catch (...) {
34912       {
34913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34914       };
34915     }
34916   }
34917 }
34918
34919
34920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
34921   void * jresult ;
34922   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34923   Dali::CustomActorImpl *result = 0 ;
34924
34925   arg1 = (Dali::CustomActor *)jarg1;
34926   {
34927     try {
34928       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
34929     } catch (std::out_of_range& e) {
34930       {
34931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34932       };
34933     } catch (std::exception& e) {
34934       {
34935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34936       };
34937     } catch (...) {
34938       {
34939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34940       };
34941     }
34942   }
34943   jresult = (void *)result;
34944   return jresult;
34945 }
34946
34947
34948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
34949   void * jresult ;
34950   Dali::CustomActorImpl *arg1 = 0 ;
34951   Dali::CustomActor *result = 0 ;
34952
34953   arg1 = (Dali::CustomActorImpl *)jarg1;
34954   if (!arg1) {
34955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
34956     return 0;
34957   }
34958   {
34959     try {
34960       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
34961     } catch (std::out_of_range& e) {
34962       {
34963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34964       };
34965     } catch (std::exception& e) {
34966       {
34967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34968       };
34969     } catch (...) {
34970       {
34971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34972       };
34973     }
34974   }
34975   jresult = (void *)result;
34976   return jresult;
34977 }
34978
34979
34980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
34981   void * jresult ;
34982   Dali::CustomActor *arg1 = 0 ;
34983   Dali::CustomActor *result = 0 ;
34984
34985   arg1 = (Dali::CustomActor *)jarg1;
34986   if (!arg1) {
34987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34988     return 0;
34989   }
34990   {
34991     try {
34992       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
34993     } catch (std::out_of_range& e) {
34994       {
34995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34996       };
34997     } catch (std::exception& e) {
34998       {
34999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35000       };
35001     } catch (...) {
35002       {
35003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35004       };
35005     }
35006   }
35007   jresult = (void *)result;
35008   return jresult;
35009 }
35010
35011
35012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35013   void * jresult ;
35014   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35015   Dali::CustomActor *arg2 = 0 ;
35016   Dali::CustomActor *result = 0 ;
35017
35018   arg1 = (Dali::CustomActor *)jarg1;
35019   arg2 = (Dali::CustomActor *)jarg2;
35020   if (!arg2) {
35021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35022     return 0;
35023   }
35024   {
35025     try {
35026       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35027     } catch (std::out_of_range& e) {
35028       {
35029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35030       };
35031     } catch (std::exception& e) {
35032       {
35033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35034       };
35035     } catch (...) {
35036       {
35037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35038       };
35039     }
35040   }
35041   jresult = (void *)result;
35042   return jresult;
35043 }
35044
35045
35046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35047   int jresult ;
35048   int result;
35049
35050   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35051   jresult = (int)result;
35052   return jresult;
35053 }
35054
35055
35056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35057   int jresult ;
35058   int result;
35059
35060   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35061   jresult = (int)result;
35062   return jresult;
35063 }
35064
35065
35066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35067   int jresult ;
35068   int result;
35069
35070   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35071   jresult = (int)result;
35072   return jresult;
35073 }
35074
35075
35076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35077   int jresult ;
35078   int result;
35079
35080   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35081   jresult = (int)result;
35082   return jresult;
35083 }
35084
35085
35086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35087   int jresult ;
35088   int result;
35089
35090   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35091   jresult = (int)result;
35092   return jresult;
35093 }
35094
35095
35096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35097   int jresult ;
35098   int result;
35099
35100   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35101   jresult = (int)result;
35102   return jresult;
35103 }
35104
35105
35106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35107   int jresult ;
35108   int result;
35109
35110   result = (int)Dali::PanGestureDetector::Property::PANNING;
35111   jresult = (int)result;
35112   return jresult;
35113 }
35114
35115
35116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35117   void * jresult ;
35118   Dali::PanGestureDetector::Property *result = 0 ;
35119
35120   {
35121     try {
35122       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35123     } catch (std::out_of_range& e) {
35124       {
35125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35126       };
35127     } catch (std::exception& e) {
35128       {
35129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35130       };
35131     } catch (...) {
35132       {
35133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35134       };
35135     }
35136   }
35137   jresult = (void *)result;
35138   return jresult;
35139 }
35140
35141
35142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35143   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35144
35145   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35146   {
35147     try {
35148       delete arg1;
35149     } catch (std::out_of_range& e) {
35150       {
35151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35152       };
35153     } catch (std::exception& e) {
35154       {
35155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35156       };
35157     } catch (...) {
35158       {
35159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35160       };
35161     }
35162   }
35163 }
35164
35165
35166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35167   void * jresult ;
35168   Dali::Radian *result = 0 ;
35169
35170   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35171   jresult = (void *)result;
35172   return jresult;
35173 }
35174
35175
35176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35177   void * jresult ;
35178   Dali::Radian *result = 0 ;
35179
35180   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35181   jresult = (void *)result;
35182   return jresult;
35183 }
35184
35185
35186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35187   void * jresult ;
35188   Dali::Radian *result = 0 ;
35189
35190   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35191   jresult = (void *)result;
35192   return jresult;
35193 }
35194
35195
35196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35197   void * jresult ;
35198   Dali::Radian *result = 0 ;
35199
35200   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35201   jresult = (void *)result;
35202   return jresult;
35203 }
35204
35205
35206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35207   void * jresult ;
35208   Dali::Radian *result = 0 ;
35209
35210   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35211   jresult = (void *)result;
35212   return jresult;
35213 }
35214
35215
35216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35217   void * jresult ;
35218   Dali::Radian *result = 0 ;
35219
35220   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35221   jresult = (void *)result;
35222   return jresult;
35223 }
35224
35225
35226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35227   void * jresult ;
35228   Dali::Radian *result = 0 ;
35229
35230   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35231   jresult = (void *)result;
35232   return jresult;
35233 }
35234
35235
35236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35237   void * jresult ;
35238   Dali::PanGestureDetector *result = 0 ;
35239
35240   {
35241     try {
35242       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35243     } catch (std::out_of_range& e) {
35244       {
35245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35246       };
35247     } catch (std::exception& e) {
35248       {
35249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35250       };
35251     } catch (...) {
35252       {
35253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35254       };
35255     }
35256   }
35257   jresult = (void *)result;
35258   return jresult;
35259 }
35260
35261
35262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35263   void * jresult ;
35264   Dali::PanGestureDetector result;
35265
35266   {
35267     try {
35268       result = Dali::PanGestureDetector::New();
35269     } catch (std::out_of_range& e) {
35270       {
35271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35272       };
35273     } catch (std::exception& e) {
35274       {
35275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35276       };
35277     } catch (...) {
35278       {
35279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35280       };
35281     }
35282   }
35283   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35284   return jresult;
35285 }
35286
35287
35288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35289   void * jresult ;
35290   Dali::BaseHandle arg1 ;
35291   Dali::BaseHandle *argp1 ;
35292   Dali::PanGestureDetector result;
35293
35294   argp1 = (Dali::BaseHandle *)jarg1;
35295   if (!argp1) {
35296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35297     return 0;
35298   }
35299   arg1 = *argp1;
35300   {
35301     try {
35302       result = Dali::PanGestureDetector::DownCast(arg1);
35303     } catch (std::out_of_range& e) {
35304       {
35305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35306       };
35307     } catch (std::exception& e) {
35308       {
35309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35310       };
35311     } catch (...) {
35312       {
35313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35314       };
35315     }
35316   }
35317   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35318   return jresult;
35319 }
35320
35321
35322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35323   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35324
35325   arg1 = (Dali::PanGestureDetector *)jarg1;
35326   {
35327     try {
35328       delete arg1;
35329     } catch (std::out_of_range& e) {
35330       {
35331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35332       };
35333     } catch (std::exception& e) {
35334       {
35335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35336       };
35337     } catch (...) {
35338       {
35339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35340       };
35341     }
35342   }
35343 }
35344
35345
35346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35347   void * jresult ;
35348   Dali::PanGestureDetector *arg1 = 0 ;
35349   Dali::PanGestureDetector *result = 0 ;
35350
35351   arg1 = (Dali::PanGestureDetector *)jarg1;
35352   if (!arg1) {
35353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35354     return 0;
35355   }
35356   {
35357     try {
35358       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35359     } catch (std::out_of_range& e) {
35360       {
35361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35362       };
35363     } catch (std::exception& e) {
35364       {
35365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35366       };
35367     } catch (...) {
35368       {
35369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35370       };
35371     }
35372   }
35373   jresult = (void *)result;
35374   return jresult;
35375 }
35376
35377
35378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35379   void * jresult ;
35380   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35381   Dali::PanGestureDetector *arg2 = 0 ;
35382   Dali::PanGestureDetector *result = 0 ;
35383
35384   arg1 = (Dali::PanGestureDetector *)jarg1;
35385   arg2 = (Dali::PanGestureDetector *)jarg2;
35386   if (!arg2) {
35387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35388     return 0;
35389   }
35390   {
35391     try {
35392       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35393     } catch (std::out_of_range& e) {
35394       {
35395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35396       };
35397     } catch (std::exception& e) {
35398       {
35399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35400       };
35401     } catch (...) {
35402       {
35403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35404       };
35405     }
35406   }
35407   jresult = (void *)result;
35408   return jresult;
35409 }
35410
35411
35412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35413   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35414   unsigned int arg2 ;
35415
35416   arg1 = (Dali::PanGestureDetector *)jarg1;
35417   arg2 = (unsigned int)jarg2;
35418   {
35419     try {
35420       (arg1)->SetMinimumTouchesRequired(arg2);
35421     } catch (std::out_of_range& e) {
35422       {
35423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35424       };
35425     } catch (std::exception& e) {
35426       {
35427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35428       };
35429     } catch (...) {
35430       {
35431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35432       };
35433     }
35434   }
35435 }
35436
35437
35438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35439   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35440   unsigned int arg2 ;
35441
35442   arg1 = (Dali::PanGestureDetector *)jarg1;
35443   arg2 = (unsigned int)jarg2;
35444   {
35445     try {
35446       (arg1)->SetMaximumTouchesRequired(arg2);
35447     } catch (std::out_of_range& e) {
35448       {
35449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35450       };
35451     } catch (std::exception& e) {
35452       {
35453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35454       };
35455     } catch (...) {
35456       {
35457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35458       };
35459     }
35460   }
35461 }
35462
35463
35464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35465   unsigned int jresult ;
35466   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35467   unsigned int result;
35468
35469   arg1 = (Dali::PanGestureDetector *)jarg1;
35470   {
35471     try {
35472       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35473     } catch (std::out_of_range& e) {
35474       {
35475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35476       };
35477     } catch (std::exception& e) {
35478       {
35479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35480       };
35481     } catch (...) {
35482       {
35483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35484       };
35485     }
35486   }
35487   jresult = result;
35488   return jresult;
35489 }
35490
35491
35492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35493   unsigned int jresult ;
35494   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35495   unsigned int result;
35496
35497   arg1 = (Dali::PanGestureDetector *)jarg1;
35498   {
35499     try {
35500       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35501     } catch (std::out_of_range& e) {
35502       {
35503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35504       };
35505     } catch (std::exception& e) {
35506       {
35507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35508       };
35509     } catch (...) {
35510       {
35511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35512       };
35513     }
35514   }
35515   jresult = result;
35516   return jresult;
35517 }
35518
35519
35520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35521   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35522   Dali::Radian arg2 ;
35523   Dali::Radian arg3 ;
35524   Dali::Radian *argp2 ;
35525   Dali::Radian *argp3 ;
35526
35527   arg1 = (Dali::PanGestureDetector *)jarg1;
35528   argp2 = (Dali::Radian *)jarg2;
35529   if (!argp2) {
35530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35531     return ;
35532   }
35533   arg2 = *argp2;
35534   argp3 = (Dali::Radian *)jarg3;
35535   if (!argp3) {
35536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35537     return ;
35538   }
35539   arg3 = *argp3;
35540   {
35541     try {
35542       (arg1)->AddAngle(arg2,arg3);
35543     } catch (std::out_of_range& e) {
35544       {
35545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35546       };
35547     } catch (std::exception& e) {
35548       {
35549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35550       };
35551     } catch (...) {
35552       {
35553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35554       };
35555     }
35556   }
35557 }
35558
35559
35560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35561   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35562   Dali::Radian arg2 ;
35563   Dali::Radian *argp2 ;
35564
35565   arg1 = (Dali::PanGestureDetector *)jarg1;
35566   argp2 = (Dali::Radian *)jarg2;
35567   if (!argp2) {
35568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35569     return ;
35570   }
35571   arg2 = *argp2;
35572   {
35573     try {
35574       (arg1)->AddAngle(arg2);
35575     } catch (std::out_of_range& e) {
35576       {
35577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35578       };
35579     } catch (std::exception& e) {
35580       {
35581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35582       };
35583     } catch (...) {
35584       {
35585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35586       };
35587     }
35588   }
35589 }
35590
35591
35592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35593   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35594   Dali::Radian arg2 ;
35595   Dali::Radian arg3 ;
35596   Dali::Radian *argp2 ;
35597   Dali::Radian *argp3 ;
35598
35599   arg1 = (Dali::PanGestureDetector *)jarg1;
35600   argp2 = (Dali::Radian *)jarg2;
35601   if (!argp2) {
35602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35603     return ;
35604   }
35605   arg2 = *argp2;
35606   argp3 = (Dali::Radian *)jarg3;
35607   if (!argp3) {
35608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35609     return ;
35610   }
35611   arg3 = *argp3;
35612   {
35613     try {
35614       (arg1)->AddDirection(arg2,arg3);
35615     } catch (std::out_of_range& e) {
35616       {
35617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35618       };
35619     } catch (std::exception& e) {
35620       {
35621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35622       };
35623     } catch (...) {
35624       {
35625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35626       };
35627     }
35628   }
35629 }
35630
35631
35632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35633   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35634   Dali::Radian arg2 ;
35635   Dali::Radian *argp2 ;
35636
35637   arg1 = (Dali::PanGestureDetector *)jarg1;
35638   argp2 = (Dali::Radian *)jarg2;
35639   if (!argp2) {
35640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35641     return ;
35642   }
35643   arg2 = *argp2;
35644   {
35645     try {
35646       (arg1)->AddDirection(arg2);
35647     } catch (std::out_of_range& e) {
35648       {
35649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35650       };
35651     } catch (std::exception& e) {
35652       {
35653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35654       };
35655     } catch (...) {
35656       {
35657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35658       };
35659     }
35660   }
35661 }
35662
35663
35664 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35665   unsigned long jresult ;
35666   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35667   size_t result;
35668
35669   arg1 = (Dali::PanGestureDetector *)jarg1;
35670   {
35671     try {
35672       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35673     } catch (std::out_of_range& e) {
35674       {
35675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35676       };
35677     } catch (std::exception& e) {
35678       {
35679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35680       };
35681     } catch (...) {
35682       {
35683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35684       };
35685     }
35686   }
35687   jresult = (unsigned long)result;
35688   return jresult;
35689 }
35690
35691
35692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35693   void * jresult ;
35694   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35695   size_t arg2 ;
35696   Dali::PanGestureDetector::AngleThresholdPair result;
35697
35698   arg1 = (Dali::PanGestureDetector *)jarg1;
35699   arg2 = (size_t)jarg2;
35700   {
35701     try {
35702       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35703     } catch (std::out_of_range& e) {
35704       {
35705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35706       };
35707     } catch (std::exception& e) {
35708       {
35709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35710       };
35711     } catch (...) {
35712       {
35713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35714       };
35715     }
35716   }
35717   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35718   return jresult;
35719 }
35720
35721
35722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35723   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35724
35725   arg1 = (Dali::PanGestureDetector *)jarg1;
35726   {
35727     try {
35728       (arg1)->ClearAngles();
35729     } catch (std::out_of_range& e) {
35730       {
35731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35732       };
35733     } catch (std::exception& e) {
35734       {
35735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35736       };
35737     } catch (...) {
35738       {
35739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35740       };
35741     }
35742   }
35743 }
35744
35745
35746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35747   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35748   Dali::Radian arg2 ;
35749   Dali::Radian *argp2 ;
35750
35751   arg1 = (Dali::PanGestureDetector *)jarg1;
35752   argp2 = (Dali::Radian *)jarg2;
35753   if (!argp2) {
35754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35755     return ;
35756   }
35757   arg2 = *argp2;
35758   {
35759     try {
35760       (arg1)->RemoveAngle(arg2);
35761     } catch (std::out_of_range& e) {
35762       {
35763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35764       };
35765     } catch (std::exception& e) {
35766       {
35767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35768       };
35769     } catch (...) {
35770       {
35771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35772       };
35773     }
35774   }
35775 }
35776
35777
35778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35779   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35780   Dali::Radian arg2 ;
35781   Dali::Radian *argp2 ;
35782
35783   arg1 = (Dali::PanGestureDetector *)jarg1;
35784   argp2 = (Dali::Radian *)jarg2;
35785   if (!argp2) {
35786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35787     return ;
35788   }
35789   arg2 = *argp2;
35790   {
35791     try {
35792       (arg1)->RemoveDirection(arg2);
35793     } catch (std::out_of_range& e) {
35794       {
35795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35796       };
35797     } catch (std::exception& e) {
35798       {
35799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35800       };
35801     } catch (...) {
35802       {
35803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35804       };
35805     }
35806   }
35807 }
35808
35809
35810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35811   void * jresult ;
35812   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35813   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35814
35815   arg1 = (Dali::PanGestureDetector *)jarg1;
35816   {
35817     try {
35818       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35819     } catch (std::out_of_range& e) {
35820       {
35821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35822       };
35823     } catch (std::exception& e) {
35824       {
35825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35826       };
35827     } catch (...) {
35828       {
35829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35830       };
35831     }
35832   }
35833   jresult = (void *)result;
35834   return jresult;
35835 }
35836
35837
35838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35839   Dali::PanGesture *arg1 = 0 ;
35840
35841   arg1 = (Dali::PanGesture *)jarg1;
35842   if (!arg1) {
35843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35844     return ;
35845   }
35846   {
35847     try {
35848       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35849     } catch (std::out_of_range& e) {
35850       {
35851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35852       };
35853     } catch (std::exception& e) {
35854       {
35855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35856       };
35857     } catch (...) {
35858       {
35859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35860       };
35861     }
35862   }
35863 }
35864
35865
35866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35867   void * jresult ;
35868   Dali::PanGesture *result = 0 ;
35869
35870   {
35871     try {
35872       result = (Dali::PanGesture *)new Dali::PanGesture();
35873     } catch (std::out_of_range& e) {
35874       {
35875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35876       };
35877     } catch (std::exception& e) {
35878       {
35879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35880       };
35881     } catch (...) {
35882       {
35883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35884       };
35885     }
35886   }
35887   jresult = (void *)result;
35888   return jresult;
35889 }
35890
35891
35892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35893   void * jresult ;
35894   Dali::Gesture::State arg1 ;
35895   Dali::PanGesture *result = 0 ;
35896
35897   arg1 = (Dali::Gesture::State)jarg1;
35898   {
35899     try {
35900       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35901     } catch (std::out_of_range& e) {
35902       {
35903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35904       };
35905     } catch (std::exception& e) {
35906       {
35907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35908       };
35909     } catch (...) {
35910       {
35911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35912       };
35913     }
35914   }
35915   jresult = (void *)result;
35916   return jresult;
35917 }
35918
35919
35920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
35921   void * jresult ;
35922   Dali::PanGesture *arg1 = 0 ;
35923   Dali::PanGesture *result = 0 ;
35924
35925   arg1 = (Dali::PanGesture *)jarg1;
35926   if (!arg1) {
35927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35928     return 0;
35929   }
35930   {
35931     try {
35932       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
35933     } catch (std::out_of_range& e) {
35934       {
35935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35936       };
35937     } catch (std::exception& e) {
35938       {
35939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35940       };
35941     } catch (...) {
35942       {
35943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35944       };
35945     }
35946   }
35947   jresult = (void *)result;
35948   return jresult;
35949 }
35950
35951
35952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
35953   void * jresult ;
35954   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35955   Dali::PanGesture *arg2 = 0 ;
35956   Dali::PanGesture *result = 0 ;
35957
35958   arg1 = (Dali::PanGesture *)jarg1;
35959   arg2 = (Dali::PanGesture *)jarg2;
35960   if (!arg2) {
35961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35962     return 0;
35963   }
35964   {
35965     try {
35966       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
35967     } catch (std::out_of_range& e) {
35968       {
35969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35970       };
35971     } catch (std::exception& e) {
35972       {
35973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35974       };
35975     } catch (...) {
35976       {
35977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35978       };
35979     }
35980   }
35981   jresult = (void *)result;
35982   return jresult;
35983 }
35984
35985
35986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
35987   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35988
35989   arg1 = (Dali::PanGesture *)jarg1;
35990   {
35991     try {
35992       delete arg1;
35993     } catch (std::out_of_range& e) {
35994       {
35995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35996       };
35997     } catch (std::exception& e) {
35998       {
35999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36000       };
36001     } catch (...) {
36002       {
36003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36004       };
36005     }
36006   }
36007 }
36008
36009
36010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36011   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36012   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36013
36014   arg1 = (Dali::PanGesture *)jarg1;
36015   arg2 = (Dali::Vector2 *)jarg2;
36016   if (arg1) (arg1)->velocity = *arg2;
36017 }
36018
36019
36020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36021   void * jresult ;
36022   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36023   Dali::Vector2 *result = 0 ;
36024
36025   arg1 = (Dali::PanGesture *)jarg1;
36026   result = (Dali::Vector2 *)& ((arg1)->velocity);
36027   jresult = (void *)result;
36028   return jresult;
36029 }
36030
36031
36032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36033   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36034   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36035
36036   arg1 = (Dali::PanGesture *)jarg1;
36037   arg2 = (Dali::Vector2 *)jarg2;
36038   if (arg1) (arg1)->displacement = *arg2;
36039 }
36040
36041
36042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36043   void * jresult ;
36044   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36045   Dali::Vector2 *result = 0 ;
36046
36047   arg1 = (Dali::PanGesture *)jarg1;
36048   result = (Dali::Vector2 *)& ((arg1)->displacement);
36049   jresult = (void *)result;
36050   return jresult;
36051 }
36052
36053
36054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36055   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36056   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36057
36058   arg1 = (Dali::PanGesture *)jarg1;
36059   arg2 = (Dali::Vector2 *)jarg2;
36060   if (arg1) (arg1)->position = *arg2;
36061 }
36062
36063
36064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36065   void * jresult ;
36066   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36067   Dali::Vector2 *result = 0 ;
36068
36069   arg1 = (Dali::PanGesture *)jarg1;
36070   result = (Dali::Vector2 *)& ((arg1)->position);
36071   jresult = (void *)result;
36072   return jresult;
36073 }
36074
36075
36076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36077   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36078   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36079
36080   arg1 = (Dali::PanGesture *)jarg1;
36081   arg2 = (Dali::Vector2 *)jarg2;
36082   if (arg1) (arg1)->screenVelocity = *arg2;
36083 }
36084
36085
36086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36087   void * jresult ;
36088   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36089   Dali::Vector2 *result = 0 ;
36090
36091   arg1 = (Dali::PanGesture *)jarg1;
36092   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36093   jresult = (void *)result;
36094   return jresult;
36095 }
36096
36097
36098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36099   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36100   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36101
36102   arg1 = (Dali::PanGesture *)jarg1;
36103   arg2 = (Dali::Vector2 *)jarg2;
36104   if (arg1) (arg1)->screenDisplacement = *arg2;
36105 }
36106
36107
36108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36109   void * jresult ;
36110   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36111   Dali::Vector2 *result = 0 ;
36112
36113   arg1 = (Dali::PanGesture *)jarg1;
36114   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36115   jresult = (void *)result;
36116   return jresult;
36117 }
36118
36119
36120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36121   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36122   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36123
36124   arg1 = (Dali::PanGesture *)jarg1;
36125   arg2 = (Dali::Vector2 *)jarg2;
36126   if (arg1) (arg1)->screenPosition = *arg2;
36127 }
36128
36129
36130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36131   void * jresult ;
36132   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36133   Dali::Vector2 *result = 0 ;
36134
36135   arg1 = (Dali::PanGesture *)jarg1;
36136   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36137   jresult = (void *)result;
36138   return jresult;
36139 }
36140
36141
36142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36143   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36144   unsigned int arg2 ;
36145
36146   arg1 = (Dali::PanGesture *)jarg1;
36147   arg2 = (unsigned int)jarg2;
36148   if (arg1) (arg1)->numberOfTouches = arg2;
36149 }
36150
36151
36152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36153   unsigned int jresult ;
36154   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36155   unsigned int result;
36156
36157   arg1 = (Dali::PanGesture *)jarg1;
36158   result = (unsigned int) ((arg1)->numberOfTouches);
36159   jresult = result;
36160   return jresult;
36161 }
36162
36163
36164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36165   float jresult ;
36166   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36167   float result;
36168
36169   arg1 = (Dali::PanGesture *)jarg1;
36170   {
36171     try {
36172       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36173     } catch (std::out_of_range& e) {
36174       {
36175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36176       };
36177     } catch (std::exception& e) {
36178       {
36179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36180       };
36181     } catch (...) {
36182       {
36183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36184       };
36185     }
36186   }
36187   jresult = result;
36188   return jresult;
36189 }
36190
36191
36192 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36193   float jresult ;
36194   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36195   float result;
36196
36197   arg1 = (Dali::PanGesture *)jarg1;
36198   {
36199     try {
36200       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36201     } catch (std::out_of_range& e) {
36202       {
36203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36204       };
36205     } catch (std::exception& e) {
36206       {
36207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36208       };
36209     } catch (...) {
36210       {
36211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36212       };
36213     }
36214   }
36215   jresult = result;
36216   return jresult;
36217 }
36218
36219
36220 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36221   float jresult ;
36222   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36223   float result;
36224
36225   arg1 = (Dali::PanGesture *)jarg1;
36226   {
36227     try {
36228       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36229     } catch (std::out_of_range& e) {
36230       {
36231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36232       };
36233     } catch (std::exception& e) {
36234       {
36235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36236       };
36237     } catch (...) {
36238       {
36239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36240       };
36241     }
36242   }
36243   jresult = result;
36244   return jresult;
36245 }
36246
36247
36248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36249   float jresult ;
36250   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36251   float result;
36252
36253   arg1 = (Dali::PanGesture *)jarg1;
36254   {
36255     try {
36256       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
36257     } catch (std::out_of_range& e) {
36258       {
36259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36260       };
36261     } catch (std::exception& e) {
36262       {
36263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36264       };
36265     } catch (...) {
36266       {
36267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36268       };
36269     }
36270   }
36271   jresult = result;
36272   return jresult;
36273 }
36274
36275
36276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36277   void * jresult ;
36278   Dali::PinchGestureDetector *result = 0 ;
36279
36280   {
36281     try {
36282       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36283     } catch (std::out_of_range& e) {
36284       {
36285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36286       };
36287     } catch (std::exception& e) {
36288       {
36289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36290       };
36291     } catch (...) {
36292       {
36293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36294       };
36295     }
36296   }
36297   jresult = (void *)result;
36298   return jresult;
36299 }
36300
36301
36302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36303   void * jresult ;
36304   Dali::PinchGestureDetector result;
36305
36306   {
36307     try {
36308       result = Dali::PinchGestureDetector::New();
36309     } catch (std::out_of_range& e) {
36310       {
36311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36312       };
36313     } catch (std::exception& e) {
36314       {
36315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36316       };
36317     } catch (...) {
36318       {
36319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36320       };
36321     }
36322   }
36323   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36324   return jresult;
36325 }
36326
36327
36328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36329   void * jresult ;
36330   Dali::BaseHandle arg1 ;
36331   Dali::BaseHandle *argp1 ;
36332   Dali::PinchGestureDetector result;
36333
36334   argp1 = (Dali::BaseHandle *)jarg1;
36335   if (!argp1) {
36336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36337     return 0;
36338   }
36339   arg1 = *argp1;
36340   {
36341     try {
36342       result = Dali::PinchGestureDetector::DownCast(arg1);
36343     } catch (std::out_of_range& e) {
36344       {
36345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36346       };
36347     } catch (std::exception& e) {
36348       {
36349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36350       };
36351     } catch (...) {
36352       {
36353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36354       };
36355     }
36356   }
36357   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36358   return jresult;
36359 }
36360
36361
36362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36363   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36364
36365   arg1 = (Dali::PinchGestureDetector *)jarg1;
36366   {
36367     try {
36368       delete arg1;
36369     } catch (std::out_of_range& e) {
36370       {
36371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36372       };
36373     } catch (std::exception& e) {
36374       {
36375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36376       };
36377     } catch (...) {
36378       {
36379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36380       };
36381     }
36382   }
36383 }
36384
36385
36386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36387   void * jresult ;
36388   Dali::PinchGestureDetector *arg1 = 0 ;
36389   Dali::PinchGestureDetector *result = 0 ;
36390
36391   arg1 = (Dali::PinchGestureDetector *)jarg1;
36392   if (!arg1) {
36393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36394     return 0;
36395   }
36396   {
36397     try {
36398       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36399     } catch (std::out_of_range& e) {
36400       {
36401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36402       };
36403     } catch (std::exception& e) {
36404       {
36405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36406       };
36407     } catch (...) {
36408       {
36409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36410       };
36411     }
36412   }
36413   jresult = (void *)result;
36414   return jresult;
36415 }
36416
36417
36418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36419   void * jresult ;
36420   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36421   Dali::PinchGestureDetector *arg2 = 0 ;
36422   Dali::PinchGestureDetector *result = 0 ;
36423
36424   arg1 = (Dali::PinchGestureDetector *)jarg1;
36425   arg2 = (Dali::PinchGestureDetector *)jarg2;
36426   if (!arg2) {
36427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36428     return 0;
36429   }
36430   {
36431     try {
36432       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36433     } catch (std::out_of_range& e) {
36434       {
36435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36436       };
36437     } catch (std::exception& e) {
36438       {
36439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36440       };
36441     } catch (...) {
36442       {
36443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36444       };
36445     }
36446   }
36447   jresult = (void *)result;
36448   return jresult;
36449 }
36450
36451
36452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36453   void * jresult ;
36454   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36455   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36456
36457   arg1 = (Dali::PinchGestureDetector *)jarg1;
36458   {
36459     try {
36460       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36461     } catch (std::out_of_range& e) {
36462       {
36463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36464       };
36465     } catch (std::exception& e) {
36466       {
36467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36468       };
36469     } catch (...) {
36470       {
36471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36472       };
36473     }
36474   }
36475   jresult = (void *)result;
36476   return jresult;
36477 }
36478
36479
36480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36481   void * jresult ;
36482   Dali::Gesture::State arg1 ;
36483   Dali::PinchGesture *result = 0 ;
36484
36485   arg1 = (Dali::Gesture::State)jarg1;
36486   {
36487     try {
36488       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36489     } catch (std::out_of_range& e) {
36490       {
36491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36492       };
36493     } catch (std::exception& e) {
36494       {
36495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36496       };
36497     } catch (...) {
36498       {
36499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36500       };
36501     }
36502   }
36503   jresult = (void *)result;
36504   return jresult;
36505 }
36506
36507
36508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36509   void * jresult ;
36510   Dali::PinchGesture *arg1 = 0 ;
36511   Dali::PinchGesture *result = 0 ;
36512
36513   arg1 = (Dali::PinchGesture *)jarg1;
36514   if (!arg1) {
36515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36516     return 0;
36517   }
36518   {
36519     try {
36520       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36521     } catch (std::out_of_range& e) {
36522       {
36523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36524       };
36525     } catch (std::exception& e) {
36526       {
36527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36528       };
36529     } catch (...) {
36530       {
36531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36532       };
36533     }
36534   }
36535   jresult = (void *)result;
36536   return jresult;
36537 }
36538
36539
36540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36541   void * jresult ;
36542   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36543   Dali::PinchGesture *arg2 = 0 ;
36544   Dali::PinchGesture *result = 0 ;
36545
36546   arg1 = (Dali::PinchGesture *)jarg1;
36547   arg2 = (Dali::PinchGesture *)jarg2;
36548   if (!arg2) {
36549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36550     return 0;
36551   }
36552   {
36553     try {
36554       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36555     } catch (std::out_of_range& e) {
36556       {
36557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36558       };
36559     } catch (std::exception& e) {
36560       {
36561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36562       };
36563     } catch (...) {
36564       {
36565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36566       };
36567     }
36568   }
36569   jresult = (void *)result;
36570   return jresult;
36571 }
36572
36573
36574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36575   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36576
36577   arg1 = (Dali::PinchGesture *)jarg1;
36578   {
36579     try {
36580       delete arg1;
36581     } catch (std::out_of_range& e) {
36582       {
36583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36584       };
36585     } catch (std::exception& e) {
36586       {
36587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36588       };
36589     } catch (...) {
36590       {
36591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36592       };
36593     }
36594   }
36595 }
36596
36597
36598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36599   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36600   float arg2 ;
36601
36602   arg1 = (Dali::PinchGesture *)jarg1;
36603   arg2 = (float)jarg2;
36604   if (arg1) (arg1)->scale = arg2;
36605 }
36606
36607
36608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36609   float jresult ;
36610   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36611   float result;
36612
36613   arg1 = (Dali::PinchGesture *)jarg1;
36614   result = (float) ((arg1)->scale);
36615   jresult = result;
36616   return jresult;
36617 }
36618
36619
36620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36621   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36622   float arg2 ;
36623
36624   arg1 = (Dali::PinchGesture *)jarg1;
36625   arg2 = (float)jarg2;
36626   if (arg1) (arg1)->speed = arg2;
36627 }
36628
36629
36630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36631   float jresult ;
36632   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36633   float result;
36634
36635   arg1 = (Dali::PinchGesture *)jarg1;
36636   result = (float) ((arg1)->speed);
36637   jresult = result;
36638   return jresult;
36639 }
36640
36641
36642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36643   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36644   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36645
36646   arg1 = (Dali::PinchGesture *)jarg1;
36647   arg2 = (Dali::Vector2 *)jarg2;
36648   if (arg1) (arg1)->screenCenterPoint = *arg2;
36649 }
36650
36651
36652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36653   void * jresult ;
36654   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36655   Dali::Vector2 *result = 0 ;
36656
36657   arg1 = (Dali::PinchGesture *)jarg1;
36658   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36659   jresult = (void *)result;
36660   return jresult;
36661 }
36662
36663
36664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36665   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36666   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36667
36668   arg1 = (Dali::PinchGesture *)jarg1;
36669   arg2 = (Dali::Vector2 *)jarg2;
36670   if (arg1) (arg1)->localCenterPoint = *arg2;
36671 }
36672
36673
36674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36675   void * jresult ;
36676   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36677   Dali::Vector2 *result = 0 ;
36678
36679   arg1 = (Dali::PinchGesture *)jarg1;
36680   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36681   jresult = (void *)result;
36682   return jresult;
36683 }
36684
36685
36686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36687   void * jresult ;
36688   Dali::TapGestureDetector *result = 0 ;
36689
36690   {
36691     try {
36692       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36693     } catch (std::out_of_range& e) {
36694       {
36695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36696       };
36697     } catch (std::exception& e) {
36698       {
36699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36700       };
36701     } catch (...) {
36702       {
36703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36704       };
36705     }
36706   }
36707   jresult = (void *)result;
36708   return jresult;
36709 }
36710
36711
36712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36713   void * jresult ;
36714   Dali::TapGestureDetector result;
36715
36716   {
36717     try {
36718       result = Dali::TapGestureDetector::New();
36719     } catch (std::out_of_range& e) {
36720       {
36721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36722       };
36723     } catch (std::exception& e) {
36724       {
36725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36726       };
36727     } catch (...) {
36728       {
36729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36730       };
36731     }
36732   }
36733   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36734   return jresult;
36735 }
36736
36737
36738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36739   void * jresult ;
36740   unsigned int arg1 ;
36741   Dali::TapGestureDetector result;
36742
36743   arg1 = (unsigned int)jarg1;
36744   {
36745     try {
36746       result = Dali::TapGestureDetector::New(arg1);
36747     } catch (std::out_of_range& e) {
36748       {
36749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36750       };
36751     } catch (std::exception& e) {
36752       {
36753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36754       };
36755     } catch (...) {
36756       {
36757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36758       };
36759     }
36760   }
36761   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36762   return jresult;
36763 }
36764
36765
36766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36767   void * jresult ;
36768   Dali::BaseHandle arg1 ;
36769   Dali::BaseHandle *argp1 ;
36770   Dali::TapGestureDetector result;
36771
36772   argp1 = (Dali::BaseHandle *)jarg1;
36773   if (!argp1) {
36774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36775     return 0;
36776   }
36777   arg1 = *argp1;
36778   {
36779     try {
36780       result = Dali::TapGestureDetector::DownCast(arg1);
36781     } catch (std::out_of_range& e) {
36782       {
36783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36784       };
36785     } catch (std::exception& e) {
36786       {
36787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36788       };
36789     } catch (...) {
36790       {
36791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36792       };
36793     }
36794   }
36795   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36796   return jresult;
36797 }
36798
36799
36800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36801   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36802
36803   arg1 = (Dali::TapGestureDetector *)jarg1;
36804   {
36805     try {
36806       delete arg1;
36807     } catch (std::out_of_range& e) {
36808       {
36809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36810       };
36811     } catch (std::exception& e) {
36812       {
36813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36814       };
36815     } catch (...) {
36816       {
36817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36818       };
36819     }
36820   }
36821 }
36822
36823
36824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36825   void * jresult ;
36826   Dali::TapGestureDetector *arg1 = 0 ;
36827   Dali::TapGestureDetector *result = 0 ;
36828
36829   arg1 = (Dali::TapGestureDetector *)jarg1;
36830   if (!arg1) {
36831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36832     return 0;
36833   }
36834   {
36835     try {
36836       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36837     } catch (std::out_of_range& e) {
36838       {
36839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36840       };
36841     } catch (std::exception& e) {
36842       {
36843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36844       };
36845     } catch (...) {
36846       {
36847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36848       };
36849     }
36850   }
36851   jresult = (void *)result;
36852   return jresult;
36853 }
36854
36855
36856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36857   void * jresult ;
36858   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36859   Dali::TapGestureDetector *arg2 = 0 ;
36860   Dali::TapGestureDetector *result = 0 ;
36861
36862   arg1 = (Dali::TapGestureDetector *)jarg1;
36863   arg2 = (Dali::TapGestureDetector *)jarg2;
36864   if (!arg2) {
36865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36866     return 0;
36867   }
36868   {
36869     try {
36870       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
36871     } catch (std::out_of_range& e) {
36872       {
36873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36874       };
36875     } catch (std::exception& e) {
36876       {
36877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36878       };
36879     } catch (...) {
36880       {
36881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36882       };
36883     }
36884   }
36885   jresult = (void *)result;
36886   return jresult;
36887 }
36888
36889
36890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36891   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36892   unsigned int arg2 ;
36893
36894   arg1 = (Dali::TapGestureDetector *)jarg1;
36895   arg2 = (unsigned int)jarg2;
36896   {
36897     try {
36898       (arg1)->SetMinimumTapsRequired(arg2);
36899     } catch (std::out_of_range& e) {
36900       {
36901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36902       };
36903     } catch (std::exception& e) {
36904       {
36905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36906       };
36907     } catch (...) {
36908       {
36909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36910       };
36911     }
36912   }
36913 }
36914
36915
36916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
36917   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36918   unsigned int arg2 ;
36919
36920   arg1 = (Dali::TapGestureDetector *)jarg1;
36921   arg2 = (unsigned int)jarg2;
36922   {
36923     try {
36924       (arg1)->SetMaximumTapsRequired(arg2);
36925     } catch (std::out_of_range& e) {
36926       {
36927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36928       };
36929     } catch (std::exception& e) {
36930       {
36931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36932       };
36933     } catch (...) {
36934       {
36935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36936       };
36937     }
36938   }
36939 }
36940
36941
36942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
36943   unsigned int jresult ;
36944   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36945   unsigned int result;
36946
36947   arg1 = (Dali::TapGestureDetector *)jarg1;
36948   {
36949     try {
36950       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
36951     } catch (std::out_of_range& e) {
36952       {
36953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36954       };
36955     } catch (std::exception& e) {
36956       {
36957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36958       };
36959     } catch (...) {
36960       {
36961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36962       };
36963     }
36964   }
36965   jresult = result;
36966   return jresult;
36967 }
36968
36969
36970 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
36971   unsigned int jresult ;
36972   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36973   unsigned int result;
36974
36975   arg1 = (Dali::TapGestureDetector *)jarg1;
36976   {
36977     try {
36978       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
36979     } catch (std::out_of_range& e) {
36980       {
36981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36982       };
36983     } catch (std::exception& e) {
36984       {
36985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36986       };
36987     } catch (...) {
36988       {
36989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36990       };
36991     }
36992   }
36993   jresult = result;
36994   return jresult;
36995 }
36996
36997
36998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
36999   void * jresult ;
37000   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37001   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37002
37003   arg1 = (Dali::TapGestureDetector *)jarg1;
37004   {
37005     try {
37006       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37007     } catch (std::out_of_range& e) {
37008       {
37009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37010       };
37011     } catch (std::exception& e) {
37012       {
37013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37014       };
37015     } catch (...) {
37016       {
37017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37018       };
37019     }
37020   }
37021   jresult = (void *)result;
37022   return jresult;
37023 }
37024
37025
37026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37027   void * jresult ;
37028   Dali::TapGesture *result = 0 ;
37029
37030   {
37031     try {
37032       result = (Dali::TapGesture *)new Dali::TapGesture();
37033     } catch (std::out_of_range& e) {
37034       {
37035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37036       };
37037     } catch (std::exception& e) {
37038       {
37039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37040       };
37041     } catch (...) {
37042       {
37043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37044       };
37045     }
37046   }
37047   jresult = (void *)result;
37048   return jresult;
37049 }
37050
37051
37052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37053   void * jresult ;
37054   Dali::TapGesture *arg1 = 0 ;
37055   Dali::TapGesture *result = 0 ;
37056
37057   arg1 = (Dali::TapGesture *)jarg1;
37058   if (!arg1) {
37059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37060     return 0;
37061   }
37062   {
37063     try {
37064       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37065     } catch (std::out_of_range& e) {
37066       {
37067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37068       };
37069     } catch (std::exception& e) {
37070       {
37071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37072       };
37073     } catch (...) {
37074       {
37075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37076       };
37077     }
37078   }
37079   jresult = (void *)result;
37080   return jresult;
37081 }
37082
37083
37084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37085   void * jresult ;
37086   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37087   Dali::TapGesture *arg2 = 0 ;
37088   Dali::TapGesture *result = 0 ;
37089
37090   arg1 = (Dali::TapGesture *)jarg1;
37091   arg2 = (Dali::TapGesture *)jarg2;
37092   if (!arg2) {
37093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37094     return 0;
37095   }
37096   {
37097     try {
37098       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37099     } catch (std::out_of_range& e) {
37100       {
37101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37102       };
37103     } catch (std::exception& e) {
37104       {
37105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37106       };
37107     } catch (...) {
37108       {
37109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37110       };
37111     }
37112   }
37113   jresult = (void *)result;
37114   return jresult;
37115 }
37116
37117
37118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37119   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37120
37121   arg1 = (Dali::TapGesture *)jarg1;
37122   {
37123     try {
37124       delete arg1;
37125     } catch (std::out_of_range& e) {
37126       {
37127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37128       };
37129     } catch (std::exception& e) {
37130       {
37131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37132       };
37133     } catch (...) {
37134       {
37135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37136       };
37137     }
37138   }
37139 }
37140
37141
37142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37143   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37144   unsigned int arg2 ;
37145
37146   arg1 = (Dali::TapGesture *)jarg1;
37147   arg2 = (unsigned int)jarg2;
37148   if (arg1) (arg1)->numberOfTaps = arg2;
37149 }
37150
37151
37152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37153   unsigned int jresult ;
37154   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37155   unsigned int result;
37156
37157   arg1 = (Dali::TapGesture *)jarg1;
37158   result = (unsigned int) ((arg1)->numberOfTaps);
37159   jresult = result;
37160   return jresult;
37161 }
37162
37163
37164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37165   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37166   unsigned int arg2 ;
37167
37168   arg1 = (Dali::TapGesture *)jarg1;
37169   arg2 = (unsigned int)jarg2;
37170   if (arg1) (arg1)->numberOfTouches = arg2;
37171 }
37172
37173
37174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37175   unsigned int jresult ;
37176   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37177   unsigned int result;
37178
37179   arg1 = (Dali::TapGesture *)jarg1;
37180   result = (unsigned int) ((arg1)->numberOfTouches);
37181   jresult = result;
37182   return jresult;
37183 }
37184
37185
37186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37187   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37188   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37189
37190   arg1 = (Dali::TapGesture *)jarg1;
37191   arg2 = (Dali::Vector2 *)jarg2;
37192   if (arg1) (arg1)->screenPoint = *arg2;
37193 }
37194
37195
37196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37197   void * jresult ;
37198   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37199   Dali::Vector2 *result = 0 ;
37200
37201   arg1 = (Dali::TapGesture *)jarg1;
37202   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37203   jresult = (void *)result;
37204   return jresult;
37205 }
37206
37207
37208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37209   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37210   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37211
37212   arg1 = (Dali::TapGesture *)jarg1;
37213   arg2 = (Dali::Vector2 *)jarg2;
37214   if (arg1) (arg1)->localPoint = *arg2;
37215 }
37216
37217
37218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37219   void * jresult ;
37220   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37221   Dali::Vector2 *result = 0 ;
37222
37223   arg1 = (Dali::TapGesture *)jarg1;
37224   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37225   jresult = (void *)result;
37226   return jresult;
37227 }
37228
37229
37230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37231   void * jresult ;
37232   Dali::AlphaFunction *result = 0 ;
37233
37234   {
37235     try {
37236       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37237     } catch (std::out_of_range& e) {
37238       {
37239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37240       };
37241     } catch (std::exception& e) {
37242       {
37243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37244       };
37245     } catch (...) {
37246       {
37247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37248       };
37249     }
37250   }
37251   jresult = (void *)result;
37252   return jresult;
37253 }
37254
37255
37256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37257   void * jresult ;
37258   Dali::AlphaFunction::BuiltinFunction arg1 ;
37259   Dali::AlphaFunction *result = 0 ;
37260
37261   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37262   {
37263     try {
37264       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37265     } catch (std::out_of_range& e) {
37266       {
37267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37268       };
37269     } catch (std::exception& e) {
37270       {
37271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37272       };
37273     } catch (...) {
37274       {
37275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37276       };
37277     }
37278   }
37279   jresult = (void *)result;
37280   return jresult;
37281 }
37282
37283
37284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37285   void * jresult ;
37286   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37287   Dali::AlphaFunction *result = 0 ;
37288
37289   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37290   {
37291     try {
37292       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37293     } catch (std::out_of_range& e) {
37294       {
37295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37296       };
37297     } catch (std::exception& e) {
37298       {
37299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37300       };
37301     } catch (...) {
37302       {
37303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37304       };
37305     }
37306   }
37307   jresult = (void *)result;
37308   return jresult;
37309 }
37310
37311
37312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37313   void * jresult ;
37314   Dali::Vector2 *arg1 = 0 ;
37315   Dali::Vector2 *arg2 = 0 ;
37316   Dali::AlphaFunction *result = 0 ;
37317
37318   arg1 = (Dali::Vector2 *)jarg1;
37319   if (!arg1) {
37320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37321     return 0;
37322   }
37323   arg2 = (Dali::Vector2 *)jarg2;
37324   if (!arg2) {
37325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37326     return 0;
37327   }
37328   {
37329     try {
37330       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37331     } catch (std::out_of_range& e) {
37332       {
37333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37334       };
37335     } catch (std::exception& e) {
37336       {
37337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37338       };
37339     } catch (...) {
37340       {
37341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37342       };
37343     }
37344   }
37345   jresult = (void *)result;
37346   return jresult;
37347 }
37348
37349
37350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37351   void * jresult ;
37352   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37353   Dali::Vector4 result;
37354
37355   arg1 = (Dali::AlphaFunction *)jarg1;
37356   {
37357     try {
37358       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37359     } catch (std::out_of_range& e) {
37360       {
37361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37362       };
37363     } catch (std::exception& e) {
37364       {
37365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37366       };
37367     } catch (...) {
37368       {
37369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37370       };
37371     }
37372   }
37373   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37374   return jresult;
37375 }
37376
37377
37378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37379   void * jresult ;
37380   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37381   Dali::AlphaFunctionPrototype result;
37382
37383   arg1 = (Dali::AlphaFunction *)jarg1;
37384   {
37385     try {
37386       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37387     } catch (std::out_of_range& e) {
37388       {
37389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37390       };
37391     } catch (std::exception& e) {
37392       {
37393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37394       };
37395     } catch (...) {
37396       {
37397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37398       };
37399     }
37400   }
37401   jresult = (void *)result;
37402   return jresult;
37403 }
37404
37405
37406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37407   int jresult ;
37408   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37409   Dali::AlphaFunction::BuiltinFunction result;
37410
37411   arg1 = (Dali::AlphaFunction *)jarg1;
37412   {
37413     try {
37414       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37415     } catch (std::out_of_range& e) {
37416       {
37417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37418       };
37419     } catch (std::exception& e) {
37420       {
37421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37422       };
37423     } catch (...) {
37424       {
37425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37426       };
37427     }
37428   }
37429   jresult = (int)result;
37430   return jresult;
37431 }
37432
37433
37434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37435   int jresult ;
37436   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37437   Dali::AlphaFunction::Mode result;
37438
37439   arg1 = (Dali::AlphaFunction *)jarg1;
37440   {
37441     try {
37442       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37443     } catch (std::out_of_range& e) {
37444       {
37445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37446       };
37447     } catch (std::exception& e) {
37448       {
37449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37450       };
37451     } catch (...) {
37452       {
37453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37454       };
37455     }
37456   }
37457   jresult = (int)result;
37458   return jresult;
37459 }
37460
37461
37462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37463   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37464
37465   arg1 = (Dali::AlphaFunction *)jarg1;
37466   {
37467     try {
37468       delete arg1;
37469     } catch (std::out_of_range& e) {
37470       {
37471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37472       };
37473     } catch (std::exception& e) {
37474       {
37475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37476       };
37477     } catch (...) {
37478       {
37479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37480       };
37481     }
37482   }
37483 }
37484
37485
37486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37487   void * jresult ;
37488   Dali::KeyFrames result;
37489
37490   {
37491     try {
37492       result = Dali::KeyFrames::New();
37493     } catch (std::out_of_range& e) {
37494       {
37495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37496       };
37497     } catch (std::exception& e) {
37498       {
37499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37500       };
37501     } catch (...) {
37502       {
37503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37504       };
37505     }
37506   }
37507   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37508   return jresult;
37509 }
37510
37511
37512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37513   void * jresult ;
37514   Dali::BaseHandle arg1 ;
37515   Dali::BaseHandle *argp1 ;
37516   Dali::KeyFrames result;
37517
37518   argp1 = (Dali::BaseHandle *)jarg1;
37519   if (!argp1) {
37520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37521     return 0;
37522   }
37523   arg1 = *argp1;
37524   {
37525     try {
37526       result = Dali::KeyFrames::DownCast(arg1);
37527     } catch (std::out_of_range& e) {
37528       {
37529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37530       };
37531     } catch (std::exception& e) {
37532       {
37533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37534       };
37535     } catch (...) {
37536       {
37537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37538       };
37539     }
37540   }
37541   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37542   return jresult;
37543 }
37544
37545
37546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37547   void * jresult ;
37548   Dali::KeyFrames *result = 0 ;
37549
37550   {
37551     try {
37552       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37553     } catch (std::out_of_range& e) {
37554       {
37555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37556       };
37557     } catch (std::exception& e) {
37558       {
37559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37560       };
37561     } catch (...) {
37562       {
37563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37564       };
37565     }
37566   }
37567   jresult = (void *)result;
37568   return jresult;
37569 }
37570
37571
37572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37573   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37574
37575   arg1 = (Dali::KeyFrames *)jarg1;
37576   {
37577     try {
37578       delete arg1;
37579     } catch (std::out_of_range& e) {
37580       {
37581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37582       };
37583     } catch (std::exception& e) {
37584       {
37585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37586       };
37587     } catch (...) {
37588       {
37589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37590       };
37591     }
37592   }
37593 }
37594
37595
37596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37597   void * jresult ;
37598   Dali::KeyFrames *arg1 = 0 ;
37599   Dali::KeyFrames *result = 0 ;
37600
37601   arg1 = (Dali::KeyFrames *)jarg1;
37602   if (!arg1) {
37603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37604     return 0;
37605   }
37606   {
37607     try {
37608       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37609     } catch (std::out_of_range& e) {
37610       {
37611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37612       };
37613     } catch (std::exception& e) {
37614       {
37615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37616       };
37617     } catch (...) {
37618       {
37619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37620       };
37621     }
37622   }
37623   jresult = (void *)result;
37624   return jresult;
37625 }
37626
37627
37628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37629   void * jresult ;
37630   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37631   Dali::KeyFrames *arg2 = 0 ;
37632   Dali::KeyFrames *result = 0 ;
37633
37634   arg1 = (Dali::KeyFrames *)jarg1;
37635   arg2 = (Dali::KeyFrames *)jarg2;
37636   if (!arg2) {
37637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37638     return 0;
37639   }
37640   {
37641     try {
37642       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37643     } catch (std::out_of_range& e) {
37644       {
37645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37646       };
37647     } catch (std::exception& e) {
37648       {
37649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37650       };
37651     } catch (...) {
37652       {
37653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37654       };
37655     }
37656   }
37657   jresult = (void *)result;
37658   return jresult;
37659 }
37660
37661
37662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37663   int jresult ;
37664   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37665   Dali::Property::Type result;
37666
37667   arg1 = (Dali::KeyFrames *)jarg1;
37668   {
37669     try {
37670       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37671     } catch (std::out_of_range& e) {
37672       {
37673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37674       };
37675     } catch (std::exception& e) {
37676       {
37677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37678       };
37679     } catch (...) {
37680       {
37681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37682       };
37683     }
37684   }
37685   jresult = (int)result;
37686   return jresult;
37687 }
37688
37689
37690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37691   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37692   float arg2 ;
37693   Dali::Property::Value arg3 ;
37694   Dali::Property::Value *argp3 ;
37695
37696   arg1 = (Dali::KeyFrames *)jarg1;
37697   arg2 = (float)jarg2;
37698   argp3 = (Dali::Property::Value *)jarg3;
37699   if (!argp3) {
37700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37701     return ;
37702   }
37703   arg3 = *argp3;
37704   {
37705     try {
37706       (arg1)->Add(arg2,arg3);
37707     } catch (std::out_of_range& e) {
37708       {
37709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37710       };
37711     } catch (std::exception& e) {
37712       {
37713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37714       };
37715     } catch (...) {
37716       {
37717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37718       };
37719     }
37720   }
37721 }
37722
37723
37724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37725   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37726   float arg2 ;
37727   Dali::Property::Value arg3 ;
37728   Dali::AlphaFunction arg4 ;
37729   Dali::Property::Value *argp3 ;
37730   Dali::AlphaFunction *argp4 ;
37731
37732   arg1 = (Dali::KeyFrames *)jarg1;
37733   arg2 = (float)jarg2;
37734   argp3 = (Dali::Property::Value *)jarg3;
37735   if (!argp3) {
37736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37737     return ;
37738   }
37739   arg3 = *argp3;
37740   argp4 = (Dali::AlphaFunction *)jarg4;
37741   if (!argp4) {
37742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37743     return ;
37744   }
37745   arg4 = *argp4;
37746   {
37747     try {
37748       (arg1)->Add(arg2,arg3,arg4);
37749     } catch (std::out_of_range& e) {
37750       {
37751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37752       };
37753     } catch (std::exception& e) {
37754       {
37755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37756       };
37757     } catch (...) {
37758       {
37759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37760       };
37761     }
37762   }
37763 }
37764
37765
37766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37767   int jresult ;
37768   int result;
37769
37770   result = (int)Dali::Path::Property::POINTS;
37771   jresult = (int)result;
37772   return jresult;
37773 }
37774
37775
37776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37777   int jresult ;
37778   int result;
37779
37780   result = (int)Dali::Path::Property::CONTROL_POINTS;
37781   jresult = (int)result;
37782   return jresult;
37783 }
37784
37785
37786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37787   void * jresult ;
37788   Dali::Path::Property *result = 0 ;
37789
37790   {
37791     try {
37792       result = (Dali::Path::Property *)new Dali::Path::Property();
37793     } catch (std::out_of_range& e) {
37794       {
37795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37796       };
37797     } catch (std::exception& e) {
37798       {
37799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37800       };
37801     } catch (...) {
37802       {
37803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37804       };
37805     }
37806   }
37807   jresult = (void *)result;
37808   return jresult;
37809 }
37810
37811
37812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37813   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37814
37815   arg1 = (Dali::Path::Property *)jarg1;
37816   {
37817     try {
37818       delete arg1;
37819     } catch (std::out_of_range& e) {
37820       {
37821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37822       };
37823     } catch (std::exception& e) {
37824       {
37825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37826       };
37827     } catch (...) {
37828       {
37829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37830       };
37831     }
37832   }
37833 }
37834
37835
37836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37837   void * jresult ;
37838   Dali::Path result;
37839
37840   {
37841     try {
37842       result = Dali::Path::New();
37843     } catch (std::out_of_range& e) {
37844       {
37845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37846       };
37847     } catch (std::exception& e) {
37848       {
37849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37850       };
37851     } catch (...) {
37852       {
37853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37854       };
37855     }
37856   }
37857   jresult = new Dali::Path((const Dali::Path &)result);
37858   return jresult;
37859 }
37860
37861
37862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37863   void * jresult ;
37864   Dali::BaseHandle arg1 ;
37865   Dali::BaseHandle *argp1 ;
37866   Dali::Path result;
37867
37868   argp1 = (Dali::BaseHandle *)jarg1;
37869   if (!argp1) {
37870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37871     return 0;
37872   }
37873   arg1 = *argp1;
37874   {
37875     try {
37876       result = Dali::Path::DownCast(arg1);
37877     } catch (std::out_of_range& e) {
37878       {
37879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37880       };
37881     } catch (std::exception& e) {
37882       {
37883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37884       };
37885     } catch (...) {
37886       {
37887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37888       };
37889     }
37890   }
37891   jresult = new Dali::Path((const Dali::Path &)result);
37892   return jresult;
37893 }
37894
37895
37896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37897   void * jresult ;
37898   Dali::Path *result = 0 ;
37899
37900   {
37901     try {
37902       result = (Dali::Path *)new Dali::Path();
37903     } catch (std::out_of_range& e) {
37904       {
37905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37906       };
37907     } catch (std::exception& e) {
37908       {
37909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37910       };
37911     } catch (...) {
37912       {
37913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37914       };
37915     }
37916   }
37917   jresult = (void *)result;
37918   return jresult;
37919 }
37920
37921
37922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
37923   Dali::Path *arg1 = (Dali::Path *) 0 ;
37924
37925   arg1 = (Dali::Path *)jarg1;
37926   {
37927     try {
37928       delete arg1;
37929     } catch (std::out_of_range& e) {
37930       {
37931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37932       };
37933     } catch (std::exception& e) {
37934       {
37935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37936       };
37937     } catch (...) {
37938       {
37939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37940       };
37941     }
37942   }
37943 }
37944
37945
37946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
37947   void * jresult ;
37948   Dali::Path *arg1 = 0 ;
37949   Dali::Path *result = 0 ;
37950
37951   arg1 = (Dali::Path *)jarg1;
37952   if (!arg1) {
37953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37954     return 0;
37955   }
37956   {
37957     try {
37958       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
37959     } catch (std::out_of_range& e) {
37960       {
37961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37962       };
37963     } catch (std::exception& e) {
37964       {
37965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37966       };
37967     } catch (...) {
37968       {
37969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37970       };
37971     }
37972   }
37973   jresult = (void *)result;
37974   return jresult;
37975 }
37976
37977
37978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
37979   void * jresult ;
37980   Dali::Path *arg1 = (Dali::Path *) 0 ;
37981   Dali::Path *arg2 = 0 ;
37982   Dali::Path *result = 0 ;
37983
37984   arg1 = (Dali::Path *)jarg1;
37985   arg2 = (Dali::Path *)jarg2;
37986   if (!arg2) {
37987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37988     return 0;
37989   }
37990   {
37991     try {
37992       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
37993     } catch (std::out_of_range& e) {
37994       {
37995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37996       };
37997     } catch (std::exception& e) {
37998       {
37999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38000       };
38001     } catch (...) {
38002       {
38003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38004       };
38005     }
38006   }
38007   jresult = (void *)result;
38008   return jresult;
38009 }
38010
38011
38012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38013   Dali::Path *arg1 = (Dali::Path *) 0 ;
38014   Dali::Vector3 *arg2 = 0 ;
38015
38016   arg1 = (Dali::Path *)jarg1;
38017   arg2 = (Dali::Vector3 *)jarg2;
38018   if (!arg2) {
38019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38020     return ;
38021   }
38022   {
38023     try {
38024       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38025     } catch (std::out_of_range& e) {
38026       {
38027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38028       };
38029     } catch (std::exception& e) {
38030       {
38031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38032       };
38033     } catch (...) {
38034       {
38035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38036       };
38037     }
38038   }
38039 }
38040
38041
38042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38043   Dali::Path *arg1 = (Dali::Path *) 0 ;
38044   Dali::Vector3 *arg2 = 0 ;
38045
38046   arg1 = (Dali::Path *)jarg1;
38047   arg2 = (Dali::Vector3 *)jarg2;
38048   if (!arg2) {
38049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38050     return ;
38051   }
38052   {
38053     try {
38054       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38055     } catch (std::out_of_range& e) {
38056       {
38057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38058       };
38059     } catch (std::exception& e) {
38060       {
38061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38062       };
38063     } catch (...) {
38064       {
38065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38066       };
38067     }
38068   }
38069 }
38070
38071
38072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38073   Dali::Path *arg1 = (Dali::Path *) 0 ;
38074   float arg2 ;
38075
38076   arg1 = (Dali::Path *)jarg1;
38077   arg2 = (float)jarg2;
38078   {
38079     try {
38080       (arg1)->GenerateControlPoints(arg2);
38081     } catch (std::out_of_range& e) {
38082       {
38083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38084       };
38085     } catch (std::exception& e) {
38086       {
38087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38088       };
38089     } catch (...) {
38090       {
38091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38092       };
38093     }
38094   }
38095 }
38096
38097
38098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38099   Dali::Path *arg1 = (Dali::Path *) 0 ;
38100   float arg2 ;
38101   Dali::Vector3 *arg3 = 0 ;
38102   Dali::Vector3 *arg4 = 0 ;
38103
38104   arg1 = (Dali::Path *)jarg1;
38105   arg2 = (float)jarg2;
38106   arg3 = (Dali::Vector3 *)jarg3;
38107   if (!arg3) {
38108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38109     return ;
38110   }
38111   arg4 = (Dali::Vector3 *)jarg4;
38112   if (!arg4) {
38113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38114     return ;
38115   }
38116   {
38117     try {
38118       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38119     } catch (std::out_of_range& e) {
38120       {
38121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38122       };
38123     } catch (std::exception& e) {
38124       {
38125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38126       };
38127     } catch (...) {
38128       {
38129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38130       };
38131     }
38132   }
38133 }
38134
38135
38136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38137   void * jresult ;
38138   Dali::Path *arg1 = (Dali::Path *) 0 ;
38139   size_t arg2 ;
38140   Dali::Vector3 *result = 0 ;
38141
38142   arg1 = (Dali::Path *)jarg1;
38143   arg2 = (size_t)jarg2;
38144   {
38145     try {
38146       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38147     } catch (std::out_of_range& e) {
38148       {
38149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38150       };
38151     } catch (std::exception& e) {
38152       {
38153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38154       };
38155     } catch (...) {
38156       {
38157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38158       };
38159     }
38160   }
38161   jresult = (void *)result;
38162   return jresult;
38163 }
38164
38165
38166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38167   void * jresult ;
38168   Dali::Path *arg1 = (Dali::Path *) 0 ;
38169   size_t arg2 ;
38170   Dali::Vector3 *result = 0 ;
38171
38172   arg1 = (Dali::Path *)jarg1;
38173   arg2 = (size_t)jarg2;
38174   {
38175     try {
38176       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38177     } catch (std::out_of_range& e) {
38178       {
38179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38180       };
38181     } catch (std::exception& e) {
38182       {
38183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38184       };
38185     } catch (...) {
38186       {
38187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38188       };
38189     }
38190   }
38191   jresult = (void *)result;
38192   return jresult;
38193 }
38194
38195
38196 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38197   unsigned long jresult ;
38198   Dali::Path *arg1 = (Dali::Path *) 0 ;
38199   size_t result;
38200
38201   arg1 = (Dali::Path *)jarg1;
38202   {
38203     try {
38204       result = ((Dali::Path const *)arg1)->GetPointCount();
38205     } catch (std::out_of_range& e) {
38206       {
38207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38208       };
38209     } catch (std::exception& e) {
38210       {
38211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38212       };
38213     } catch (...) {
38214       {
38215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38216       };
38217     }
38218   }
38219   jresult = (unsigned long)result;
38220   return jresult;
38221 }
38222
38223
38224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38225   void * jresult ;
38226   float arg1 ;
38227   Dali::TimePeriod *result = 0 ;
38228
38229   arg1 = (float)jarg1;
38230   {
38231     try {
38232       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38233     } catch (std::out_of_range& e) {
38234       {
38235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38236       };
38237     } catch (std::exception& e) {
38238       {
38239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38240       };
38241     } catch (...) {
38242       {
38243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38244       };
38245     }
38246   }
38247   jresult = (void *)result;
38248   return jresult;
38249 }
38250
38251
38252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38253   void * jresult ;
38254   float arg1 ;
38255   float arg2 ;
38256   Dali::TimePeriod *result = 0 ;
38257
38258   arg1 = (float)jarg1;
38259   arg2 = (float)jarg2;
38260   {
38261     try {
38262       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38263     } catch (std::out_of_range& e) {
38264       {
38265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38266       };
38267     } catch (std::exception& e) {
38268       {
38269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38270       };
38271     } catch (...) {
38272       {
38273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38274       };
38275     }
38276   }
38277   jresult = (void *)result;
38278   return jresult;
38279 }
38280
38281
38282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38283   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38284
38285   arg1 = (Dali::TimePeriod *)jarg1;
38286   {
38287     try {
38288       delete arg1;
38289     } catch (std::out_of_range& e) {
38290       {
38291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38292       };
38293     } catch (std::exception& e) {
38294       {
38295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38296       };
38297     } catch (...) {
38298       {
38299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38300       };
38301     }
38302   }
38303 }
38304
38305
38306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38307   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38308   float arg2 ;
38309
38310   arg1 = (Dali::TimePeriod *)jarg1;
38311   arg2 = (float)jarg2;
38312   if (arg1) (arg1)->delaySeconds = arg2;
38313 }
38314
38315
38316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38317   float jresult ;
38318   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38319   float result;
38320
38321   arg1 = (Dali::TimePeriod *)jarg1;
38322   result = (float) ((arg1)->delaySeconds);
38323   jresult = result;
38324   return jresult;
38325 }
38326
38327
38328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38329   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38330   float arg2 ;
38331
38332   arg1 = (Dali::TimePeriod *)jarg1;
38333   arg2 = (float)jarg2;
38334   if (arg1) (arg1)->durationSeconds = arg2;
38335 }
38336
38337
38338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38339   float jresult ;
38340   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38341   float result;
38342
38343   arg1 = (Dali::TimePeriod *)jarg1;
38344   result = (float) ((arg1)->durationSeconds);
38345   jresult = result;
38346   return jresult;
38347 }
38348
38349
38350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38351   void * jresult ;
38352   Dali::Animation *result = 0 ;
38353
38354   {
38355     try {
38356       result = (Dali::Animation *)new Dali::Animation();
38357     } catch (std::out_of_range& e) {
38358       {
38359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38360       };
38361     } catch (std::exception& e) {
38362       {
38363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38364       };
38365     } catch (...) {
38366       {
38367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38368       };
38369     }
38370   }
38371   jresult = (void *)result;
38372   return jresult;
38373 }
38374
38375
38376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38377   void * jresult ;
38378   float arg1 ;
38379   Dali::Animation result;
38380
38381   arg1 = (float)jarg1;
38382   {
38383     try {
38384       result = Dali::Animation::New(arg1);
38385     } catch (std::out_of_range& e) {
38386       {
38387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38388       };
38389     } catch (std::exception& e) {
38390       {
38391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38392       };
38393     } catch (...) {
38394       {
38395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38396       };
38397     }
38398   }
38399   jresult = new Dali::Animation((const Dali::Animation &)result);
38400   return jresult;
38401 }
38402
38403
38404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38405   void * jresult ;
38406   Dali::BaseHandle arg1 ;
38407   Dali::BaseHandle *argp1 ;
38408   Dali::Animation result;
38409
38410   argp1 = (Dali::BaseHandle *)jarg1;
38411   if (!argp1) {
38412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38413     return 0;
38414   }
38415   arg1 = *argp1;
38416   {
38417     try {
38418       result = Dali::Animation::DownCast(arg1);
38419     } catch (std::out_of_range& e) {
38420       {
38421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38422       };
38423     } catch (std::exception& e) {
38424       {
38425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38426       };
38427     } catch (...) {
38428       {
38429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38430       };
38431     }
38432   }
38433   jresult = new Dali::Animation((const Dali::Animation &)result);
38434   return jresult;
38435 }
38436
38437
38438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38439   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38440
38441   arg1 = (Dali::Animation *)jarg1;
38442   {
38443     try {
38444       delete arg1;
38445     } catch (std::out_of_range& e) {
38446       {
38447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38448       };
38449     } catch (std::exception& e) {
38450       {
38451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38452       };
38453     } catch (...) {
38454       {
38455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38456       };
38457     }
38458   }
38459 }
38460
38461
38462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38463   void * jresult ;
38464   Dali::Animation *arg1 = 0 ;
38465   Dali::Animation *result = 0 ;
38466
38467   arg1 = (Dali::Animation *)jarg1;
38468   if (!arg1) {
38469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38470     return 0;
38471   }
38472   {
38473     try {
38474       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38475     } catch (std::out_of_range& e) {
38476       {
38477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38478       };
38479     } catch (std::exception& e) {
38480       {
38481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38482       };
38483     } catch (...) {
38484       {
38485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38486       };
38487     }
38488   }
38489   jresult = (void *)result;
38490   return jresult;
38491 }
38492
38493
38494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38495   void * jresult ;
38496   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38497   Dali::Animation *arg2 = 0 ;
38498   Dali::Animation *result = 0 ;
38499
38500   arg1 = (Dali::Animation *)jarg1;
38501   arg2 = (Dali::Animation *)jarg2;
38502   if (!arg2) {
38503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38504     return 0;
38505   }
38506   {
38507     try {
38508       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38509     } catch (std::out_of_range& e) {
38510       {
38511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38512       };
38513     } catch (std::exception& e) {
38514       {
38515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38516       };
38517     } catch (...) {
38518       {
38519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38520       };
38521     }
38522   }
38523   jresult = (void *)result;
38524   return jresult;
38525 }
38526
38527
38528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38529   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38530   float arg2 ;
38531
38532   arg1 = (Dali::Animation *)jarg1;
38533   arg2 = (float)jarg2;
38534   {
38535     try {
38536       (arg1)->SetDuration(arg2);
38537     } catch (std::out_of_range& e) {
38538       {
38539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38540       };
38541     } catch (std::exception& e) {
38542       {
38543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38544       };
38545     } catch (...) {
38546       {
38547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38548       };
38549     }
38550   }
38551 }
38552
38553
38554 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38555   float jresult ;
38556   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38557   float result;
38558
38559   arg1 = (Dali::Animation *)jarg1;
38560   {
38561     try {
38562       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38563     } catch (std::out_of_range& e) {
38564       {
38565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38566       };
38567     } catch (std::exception& e) {
38568       {
38569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38570       };
38571     } catch (...) {
38572       {
38573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38574       };
38575     }
38576   }
38577   jresult = result;
38578   return jresult;
38579 }
38580
38581
38582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38583   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38584   bool arg2 ;
38585
38586   arg1 = (Dali::Animation *)jarg1;
38587   arg2 = jarg2 ? true : false;
38588   {
38589     try {
38590       (arg1)->SetLooping(arg2);
38591     } catch (std::out_of_range& e) {
38592       {
38593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38594       };
38595     } catch (std::exception& e) {
38596       {
38597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38598       };
38599     } catch (...) {
38600       {
38601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38602       };
38603     }
38604   }
38605 }
38606
38607
38608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38609   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38610   int arg2 ;
38611
38612   arg1 = (Dali::Animation *)jarg1;
38613   arg2 = (int)jarg2;
38614   {
38615     try {
38616       (arg1)->SetLoopCount(arg2);
38617     } catch (std::out_of_range& e) {
38618       {
38619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38620       };
38621     } catch (std::exception& e) {
38622       {
38623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38624       };
38625     } catch (...) {
38626       {
38627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38628       };
38629     }
38630   }
38631 }
38632
38633
38634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38635   int jresult ;
38636   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38637   int result;
38638
38639   arg1 = (Dali::Animation *)jarg1;
38640   {
38641     try {
38642       result = (int)(arg1)->GetLoopCount();
38643     } catch (std::out_of_range& e) {
38644       {
38645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38646       };
38647     } catch (std::exception& e) {
38648       {
38649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38650       };
38651     } catch (...) {
38652       {
38653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38654       };
38655     }
38656   }
38657   jresult = result;
38658   return jresult;
38659 }
38660
38661
38662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38663   int jresult ;
38664   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38665   int result;
38666
38667   arg1 = (Dali::Animation *)jarg1;
38668   {
38669     try {
38670       result = (int)(arg1)->GetCurrentLoop();
38671     } catch (std::out_of_range& e) {
38672       {
38673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38674       };
38675     } catch (std::exception& e) {
38676       {
38677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38678       };
38679     } catch (...) {
38680       {
38681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38682       };
38683     }
38684   }
38685   jresult = result;
38686   return jresult;
38687 }
38688
38689
38690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38691   unsigned int jresult ;
38692   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38693   bool result;
38694
38695   arg1 = (Dali::Animation *)jarg1;
38696   {
38697     try {
38698       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38699     } catch (std::out_of_range& e) {
38700       {
38701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38702       };
38703     } catch (std::exception& e) {
38704       {
38705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38706       };
38707     } catch (...) {
38708       {
38709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38710       };
38711     }
38712   }
38713   jresult = result;
38714   return jresult;
38715 }
38716
38717
38718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38719   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38720   Dali::Animation::EndAction arg2 ;
38721
38722   arg1 = (Dali::Animation *)jarg1;
38723   arg2 = (Dali::Animation::EndAction)jarg2;
38724   {
38725     try {
38726       (arg1)->SetEndAction(arg2);
38727     } catch (std::out_of_range& e) {
38728       {
38729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38730       };
38731     } catch (std::exception& e) {
38732       {
38733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38734       };
38735     } catch (...) {
38736       {
38737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38738       };
38739     }
38740   }
38741 }
38742
38743
38744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38745   int jresult ;
38746   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38747   Dali::Animation::EndAction result;
38748
38749   arg1 = (Dali::Animation *)jarg1;
38750   {
38751     try {
38752       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38753     } catch (std::out_of_range& e) {
38754       {
38755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38756       };
38757     } catch (std::exception& e) {
38758       {
38759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38760       };
38761     } catch (...) {
38762       {
38763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38764       };
38765     }
38766   }
38767   jresult = (int)result;
38768   return jresult;
38769 }
38770
38771
38772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38773   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38774   Dali::Animation::EndAction arg2 ;
38775
38776   arg1 = (Dali::Animation *)jarg1;
38777   arg2 = (Dali::Animation::EndAction)jarg2;
38778   {
38779     try {
38780       (arg1)->SetDisconnectAction(arg2);
38781     } catch (std::out_of_range& e) {
38782       {
38783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38784       };
38785     } catch (std::exception& e) {
38786       {
38787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38788       };
38789     } catch (...) {
38790       {
38791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38792       };
38793     }
38794   }
38795 }
38796
38797
38798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38799   int jresult ;
38800   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38801   Dali::Animation::EndAction result;
38802
38803   arg1 = (Dali::Animation *)jarg1;
38804   {
38805     try {
38806       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38807     } catch (std::out_of_range& e) {
38808       {
38809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38810       };
38811     } catch (std::exception& e) {
38812       {
38813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38814       };
38815     } catch (...) {
38816       {
38817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38818       };
38819     }
38820   }
38821   jresult = (int)result;
38822   return jresult;
38823 }
38824
38825
38826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38827   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38828   Dali::AlphaFunction arg2 ;
38829   Dali::AlphaFunction *argp2 ;
38830
38831   arg1 = (Dali::Animation *)jarg1;
38832   argp2 = (Dali::AlphaFunction *)jarg2;
38833   if (!argp2) {
38834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38835     return ;
38836   }
38837   arg2 = *argp2;
38838   {
38839     try {
38840       (arg1)->SetDefaultAlphaFunction(arg2);
38841     } catch (std::out_of_range& e) {
38842       {
38843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38844       };
38845     } catch (std::exception& e) {
38846       {
38847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38848       };
38849     } catch (...) {
38850       {
38851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38852       };
38853     }
38854   }
38855 }
38856
38857
38858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
38859   void * jresult ;
38860   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38861   Dali::AlphaFunction result;
38862
38863   arg1 = (Dali::Animation *)jarg1;
38864   {
38865     try {
38866       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
38867     } catch (std::out_of_range& e) {
38868       {
38869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38870       };
38871     } catch (std::exception& e) {
38872       {
38873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38874       };
38875     } catch (...) {
38876       {
38877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38878       };
38879     }
38880   }
38881   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
38882   return jresult;
38883 }
38884
38885
38886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
38887   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38888   float arg2 ;
38889
38890   arg1 = (Dali::Animation *)jarg1;
38891   arg2 = (float)jarg2;
38892   {
38893     try {
38894       (arg1)->SetCurrentProgress(arg2);
38895     } catch (std::out_of_range& e) {
38896       {
38897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38898       };
38899     } catch (std::exception& e) {
38900       {
38901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38902       };
38903     } catch (...) {
38904       {
38905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38906       };
38907     }
38908   }
38909 }
38910
38911
38912 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
38913   float jresult ;
38914   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38915   float result;
38916
38917   arg1 = (Dali::Animation *)jarg1;
38918   {
38919     try {
38920       result = (float)(arg1)->GetCurrentProgress();
38921     } catch (std::out_of_range& e) {
38922       {
38923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38924       };
38925     } catch (std::exception& e) {
38926       {
38927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38928       };
38929     } catch (...) {
38930       {
38931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38932       };
38933     }
38934   }
38935   jresult = result;
38936   return jresult;
38937 }
38938
38939
38940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
38941   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38942   float arg2 ;
38943
38944   arg1 = (Dali::Animation *)jarg1;
38945   arg2 = (float)jarg2;
38946   {
38947     try {
38948       (arg1)->SetSpeedFactor(arg2);
38949     } catch (std::out_of_range& e) {
38950       {
38951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38952       };
38953     } catch (std::exception& e) {
38954       {
38955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38956       };
38957     } catch (...) {
38958       {
38959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38960       };
38961     }
38962   }
38963 }
38964
38965
38966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
38967   float jresult ;
38968   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38969   float result;
38970
38971   arg1 = (Dali::Animation *)jarg1;
38972   {
38973     try {
38974       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
38975     } catch (std::out_of_range& e) {
38976       {
38977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38978       };
38979     } catch (std::exception& e) {
38980       {
38981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38982       };
38983     } catch (...) {
38984       {
38985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38986       };
38987     }
38988   }
38989   jresult = result;
38990   return jresult;
38991 }
38992
38993
38994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
38995   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38996   Dali::Vector2 *arg2 = 0 ;
38997
38998   arg1 = (Dali::Animation *)jarg1;
38999   arg2 = (Dali::Vector2 *)jarg2;
39000   if (!arg2) {
39001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39002     return ;
39003   }
39004   {
39005     try {
39006       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39007     } catch (std::out_of_range& e) {
39008       {
39009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39010       };
39011     } catch (std::exception& e) {
39012       {
39013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39014       };
39015     } catch (...) {
39016       {
39017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39018       };
39019     }
39020   }
39021 }
39022
39023
39024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39025   void * jresult ;
39026   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39027   Dali::Vector2 result;
39028
39029   arg1 = (Dali::Animation *)jarg1;
39030   {
39031     try {
39032       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39033     } catch (std::out_of_range& e) {
39034       {
39035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39036       };
39037     } catch (std::exception& e) {
39038       {
39039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39040       };
39041     } catch (...) {
39042       {
39043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39044       };
39045     }
39046   }
39047   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39048   return jresult;
39049 }
39050
39051
39052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39053   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39054
39055   arg1 = (Dali::Animation *)jarg1;
39056   {
39057     try {
39058       (arg1)->Play();
39059     } catch (std::out_of_range& e) {
39060       {
39061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39062       };
39063     } catch (std::exception& e) {
39064       {
39065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39066       };
39067     } catch (...) {
39068       {
39069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39070       };
39071     }
39072   }
39073 }
39074
39075
39076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39077   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39078   float arg2 ;
39079
39080   arg1 = (Dali::Animation *)jarg1;
39081   arg2 = (float)jarg2;
39082   {
39083     try {
39084       (arg1)->PlayFrom(arg2);
39085     } catch (std::out_of_range& e) {
39086       {
39087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39088       };
39089     } catch (std::exception& e) {
39090       {
39091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39092       };
39093     } catch (...) {
39094       {
39095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39096       };
39097     }
39098   }
39099 }
39100
39101
39102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39103   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39104
39105   arg1 = (Dali::Animation *)jarg1;
39106   {
39107     try {
39108       (arg1)->Pause();
39109     } catch (std::out_of_range& e) {
39110       {
39111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39112       };
39113     } catch (std::exception& e) {
39114       {
39115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39116       };
39117     } catch (...) {
39118       {
39119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39120       };
39121     }
39122   }
39123 }
39124
39125
39126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39127   int jresult ;
39128   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39129   Dali::Animation::State result;
39130
39131   arg1 = (Dali::Animation *)jarg1;
39132   {
39133     try {
39134       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39135     } catch (std::out_of_range& e) {
39136       {
39137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39138       };
39139     } catch (std::exception& e) {
39140       {
39141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39142       };
39143     } catch (...) {
39144       {
39145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39146       };
39147     }
39148   }
39149   jresult = (int)result;
39150   return jresult;
39151 }
39152
39153
39154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39155   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39156
39157   arg1 = (Dali::Animation *)jarg1;
39158   {
39159     try {
39160       (arg1)->Stop();
39161     } catch (std::out_of_range& e) {
39162       {
39163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39164       };
39165     } catch (std::exception& e) {
39166       {
39167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39168       };
39169     } catch (...) {
39170       {
39171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39172       };
39173     }
39174   }
39175 }
39176
39177
39178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39179   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39180
39181   arg1 = (Dali::Animation *)jarg1;
39182   {
39183     try {
39184       (arg1)->Clear();
39185     } catch (std::out_of_range& e) {
39186       {
39187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39188       };
39189     } catch (std::exception& e) {
39190       {
39191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39192       };
39193     } catch (...) {
39194       {
39195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39196       };
39197     }
39198   }
39199 }
39200
39201
39202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39203   void * jresult ;
39204   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39205   Dali::Animation::AnimationSignalType *result = 0 ;
39206
39207   arg1 = (Dali::Animation *)jarg1;
39208   {
39209     try {
39210       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39211     } catch (std::out_of_range& e) {
39212       {
39213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39214       };
39215     } catch (std::exception& e) {
39216       {
39217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39218       };
39219     } catch (...) {
39220       {
39221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39222       };
39223     }
39224   }
39225   jresult = (void *)result;
39226   return jresult;
39227 }
39228
39229
39230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39231   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39232   SwigValueWrapper< Dali::Property > arg2 ;
39233   Dali::Property::Value arg3 ;
39234   Dali::Property *argp2 ;
39235   Dali::Property::Value *argp3 ;
39236
39237   arg1 = (Dali::Animation *)jarg1;
39238   argp2 = (Dali::Property *)jarg2;
39239   if (!argp2) {
39240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39241     return ;
39242   }
39243   arg2 = *argp2;
39244   argp3 = (Dali::Property::Value *)jarg3;
39245   if (!argp3) {
39246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39247     return ;
39248   }
39249   arg3 = *argp3;
39250   {
39251     try {
39252       (arg1)->AnimateBy(arg2,arg3);
39253     } catch (std::out_of_range& e) {
39254       {
39255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39256       };
39257     } catch (std::exception& e) {
39258       {
39259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39260       };
39261     } catch (...) {
39262       {
39263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39264       };
39265     }
39266   }
39267 }
39268
39269
39270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39271   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39272   SwigValueWrapper< Dali::Property > arg2 ;
39273   Dali::Property::Value arg3 ;
39274   Dali::AlphaFunction arg4 ;
39275   Dali::Property *argp2 ;
39276   Dali::Property::Value *argp3 ;
39277   Dali::AlphaFunction *argp4 ;
39278
39279   arg1 = (Dali::Animation *)jarg1;
39280   argp2 = (Dali::Property *)jarg2;
39281   if (!argp2) {
39282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39283     return ;
39284   }
39285   arg2 = *argp2;
39286   argp3 = (Dali::Property::Value *)jarg3;
39287   if (!argp3) {
39288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39289     return ;
39290   }
39291   arg3 = *argp3;
39292   argp4 = (Dali::AlphaFunction *)jarg4;
39293   if (!argp4) {
39294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39295     return ;
39296   }
39297   arg4 = *argp4;
39298   {
39299     try {
39300       (arg1)->AnimateBy(arg2,arg3,arg4);
39301     } catch (std::out_of_range& e) {
39302       {
39303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39304       };
39305     } catch (std::exception& e) {
39306       {
39307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39308       };
39309     } catch (...) {
39310       {
39311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39312       };
39313     }
39314   }
39315 }
39316
39317
39318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39319   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39320   SwigValueWrapper< Dali::Property > arg2 ;
39321   Dali::Property::Value arg3 ;
39322   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39323   Dali::Property *argp2 ;
39324   Dali::Property::Value *argp3 ;
39325   Dali::TimePeriod *argp4 ;
39326
39327   arg1 = (Dali::Animation *)jarg1;
39328   argp2 = (Dali::Property *)jarg2;
39329   if (!argp2) {
39330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39331     return ;
39332   }
39333   arg2 = *argp2;
39334   argp3 = (Dali::Property::Value *)jarg3;
39335   if (!argp3) {
39336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39337     return ;
39338   }
39339   arg3 = *argp3;
39340   argp4 = (Dali::TimePeriod *)jarg4;
39341   if (!argp4) {
39342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39343     return ;
39344   }
39345   arg4 = *argp4;
39346   {
39347     try {
39348       (arg1)->AnimateBy(arg2,arg3,arg4);
39349     } catch (std::out_of_range& e) {
39350       {
39351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39352       };
39353     } catch (std::exception& e) {
39354       {
39355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39356       };
39357     } catch (...) {
39358       {
39359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39360       };
39361     }
39362   }
39363 }
39364
39365
39366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39367   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39368   SwigValueWrapper< Dali::Property > arg2 ;
39369   Dali::Property::Value arg3 ;
39370   Dali::AlphaFunction arg4 ;
39371   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39372   Dali::Property *argp2 ;
39373   Dali::Property::Value *argp3 ;
39374   Dali::AlphaFunction *argp4 ;
39375   Dali::TimePeriod *argp5 ;
39376
39377   arg1 = (Dali::Animation *)jarg1;
39378   argp2 = (Dali::Property *)jarg2;
39379   if (!argp2) {
39380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39381     return ;
39382   }
39383   arg2 = *argp2;
39384   argp3 = (Dali::Property::Value *)jarg3;
39385   if (!argp3) {
39386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39387     return ;
39388   }
39389   arg3 = *argp3;
39390   argp4 = (Dali::AlphaFunction *)jarg4;
39391   if (!argp4) {
39392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39393     return ;
39394   }
39395   arg4 = *argp4;
39396   argp5 = (Dali::TimePeriod *)jarg5;
39397   if (!argp5) {
39398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39399     return ;
39400   }
39401   arg5 = *argp5;
39402   {
39403     try {
39404       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39405     } catch (std::out_of_range& e) {
39406       {
39407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39408       };
39409     } catch (std::exception& e) {
39410       {
39411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39412       };
39413     } catch (...) {
39414       {
39415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39416       };
39417     }
39418   }
39419 }
39420
39421
39422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39423   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39424   SwigValueWrapper< Dali::Property > arg2 ;
39425   Dali::Property::Value arg3 ;
39426   Dali::Property *argp2 ;
39427   Dali::Property::Value *argp3 ;
39428
39429   arg1 = (Dali::Animation *)jarg1;
39430   argp2 = (Dali::Property *)jarg2;
39431   if (!argp2) {
39432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39433     return ;
39434   }
39435   arg2 = *argp2;
39436   argp3 = (Dali::Property::Value *)jarg3;
39437   if (!argp3) {
39438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39439     return ;
39440   }
39441   arg3 = *argp3;
39442   {
39443     try {
39444       (arg1)->AnimateTo(arg2,arg3);
39445     } catch (std::out_of_range& e) {
39446       {
39447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39448       };
39449     } catch (std::exception& e) {
39450       {
39451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39452       };
39453     } catch (...) {
39454       {
39455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39456       };
39457     }
39458   }
39459 }
39460
39461
39462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39463   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39464   SwigValueWrapper< Dali::Property > arg2 ;
39465   Dali::Property::Value arg3 ;
39466   Dali::AlphaFunction arg4 ;
39467   Dali::Property *argp2 ;
39468   Dali::Property::Value *argp3 ;
39469   Dali::AlphaFunction *argp4 ;
39470
39471   arg1 = (Dali::Animation *)jarg1;
39472   argp2 = (Dali::Property *)jarg2;
39473   if (!argp2) {
39474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39475     return ;
39476   }
39477   arg2 = *argp2;
39478   argp3 = (Dali::Property::Value *)jarg3;
39479   if (!argp3) {
39480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39481     return ;
39482   }
39483   arg3 = *argp3;
39484   argp4 = (Dali::AlphaFunction *)jarg4;
39485   if (!argp4) {
39486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39487     return ;
39488   }
39489   arg4 = *argp4;
39490   {
39491     try {
39492       (arg1)->AnimateTo(arg2,arg3,arg4);
39493     } catch (std::out_of_range& e) {
39494       {
39495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39496       };
39497     } catch (std::exception& e) {
39498       {
39499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39500       };
39501     } catch (...) {
39502       {
39503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39504       };
39505     }
39506   }
39507 }
39508
39509
39510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39511   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39512   SwigValueWrapper< Dali::Property > arg2 ;
39513   Dali::Property::Value arg3 ;
39514   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39515   Dali::Property *argp2 ;
39516   Dali::Property::Value *argp3 ;
39517   Dali::TimePeriod *argp4 ;
39518
39519   arg1 = (Dali::Animation *)jarg1;
39520   argp2 = (Dali::Property *)jarg2;
39521   if (!argp2) {
39522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39523     return ;
39524   }
39525   arg2 = *argp2;
39526   argp3 = (Dali::Property::Value *)jarg3;
39527   if (!argp3) {
39528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39529     return ;
39530   }
39531   arg3 = *argp3;
39532   argp4 = (Dali::TimePeriod *)jarg4;
39533   if (!argp4) {
39534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39535     return ;
39536   }
39537   arg4 = *argp4;
39538   {
39539     try {
39540       (arg1)->AnimateTo(arg2,arg3,arg4);
39541     } catch (std::out_of_range& e) {
39542       {
39543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39544       };
39545     } catch (std::exception& e) {
39546       {
39547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39548       };
39549     } catch (...) {
39550       {
39551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39552       };
39553     }
39554   }
39555 }
39556
39557
39558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39559   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39560   SwigValueWrapper< Dali::Property > arg2 ;
39561   Dali::Property::Value arg3 ;
39562   Dali::AlphaFunction arg4 ;
39563   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39564   Dali::Property *argp2 ;
39565   Dali::Property::Value *argp3 ;
39566   Dali::AlphaFunction *argp4 ;
39567   Dali::TimePeriod *argp5 ;
39568
39569   arg1 = (Dali::Animation *)jarg1;
39570   argp2 = (Dali::Property *)jarg2;
39571   if (!argp2) {
39572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39573     return ;
39574   }
39575   arg2 = *argp2;
39576   argp3 = (Dali::Property::Value *)jarg3;
39577   if (!argp3) {
39578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39579     return ;
39580   }
39581   arg3 = *argp3;
39582   argp4 = (Dali::AlphaFunction *)jarg4;
39583   if (!argp4) {
39584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39585     return ;
39586   }
39587   arg4 = *argp4;
39588   argp5 = (Dali::TimePeriod *)jarg5;
39589   if (!argp5) {
39590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39591     return ;
39592   }
39593   arg5 = *argp5;
39594   {
39595     try {
39596       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39597     } catch (std::out_of_range& e) {
39598       {
39599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39600       };
39601     } catch (std::exception& e) {
39602       {
39603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39604       };
39605     } catch (...) {
39606       {
39607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39608       };
39609     }
39610   }
39611 }
39612
39613
39614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39615   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39616   SwigValueWrapper< Dali::Property > arg2 ;
39617   Dali::KeyFrames *arg3 = 0 ;
39618   Dali::Property *argp2 ;
39619
39620   arg1 = (Dali::Animation *)jarg1;
39621   argp2 = (Dali::Property *)jarg2;
39622   if (!argp2) {
39623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39624     return ;
39625   }
39626   arg2 = *argp2;
39627   arg3 = (Dali::KeyFrames *)jarg3;
39628   if (!arg3) {
39629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39630     return ;
39631   }
39632   {
39633     try {
39634       (arg1)->AnimateBetween(arg2,*arg3);
39635     } catch (std::out_of_range& e) {
39636       {
39637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39638       };
39639     } catch (std::exception& e) {
39640       {
39641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39642       };
39643     } catch (...) {
39644       {
39645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39646       };
39647     }
39648   }
39649 }
39650
39651
39652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39653   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39654   SwigValueWrapper< Dali::Property > arg2 ;
39655   Dali::KeyFrames *arg3 = 0 ;
39656   Dali::Animation::Interpolation arg4 ;
39657   Dali::Property *argp2 ;
39658
39659   arg1 = (Dali::Animation *)jarg1;
39660   argp2 = (Dali::Property *)jarg2;
39661   if (!argp2) {
39662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39663     return ;
39664   }
39665   arg2 = *argp2;
39666   arg3 = (Dali::KeyFrames *)jarg3;
39667   if (!arg3) {
39668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39669     return ;
39670   }
39671   arg4 = (Dali::Animation::Interpolation)jarg4;
39672   {
39673     try {
39674       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39675     } catch (std::out_of_range& e) {
39676       {
39677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39678       };
39679     } catch (std::exception& e) {
39680       {
39681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39682       };
39683     } catch (...) {
39684       {
39685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39686       };
39687     }
39688   }
39689 }
39690
39691
39692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39693   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39694   SwigValueWrapper< Dali::Property > arg2 ;
39695   Dali::KeyFrames *arg3 = 0 ;
39696   Dali::AlphaFunction arg4 ;
39697   Dali::Property *argp2 ;
39698   Dali::AlphaFunction *argp4 ;
39699
39700   arg1 = (Dali::Animation *)jarg1;
39701   argp2 = (Dali::Property *)jarg2;
39702   if (!argp2) {
39703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39704     return ;
39705   }
39706   arg2 = *argp2;
39707   arg3 = (Dali::KeyFrames *)jarg3;
39708   if (!arg3) {
39709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39710     return ;
39711   }
39712   argp4 = (Dali::AlphaFunction *)jarg4;
39713   if (!argp4) {
39714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39715     return ;
39716   }
39717   arg4 = *argp4;
39718   {
39719     try {
39720       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39721     } catch (std::out_of_range& e) {
39722       {
39723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39724       };
39725     } catch (std::exception& e) {
39726       {
39727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39728       };
39729     } catch (...) {
39730       {
39731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39732       };
39733     }
39734   }
39735 }
39736
39737
39738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39739   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39740   SwigValueWrapper< Dali::Property > arg2 ;
39741   Dali::KeyFrames *arg3 = 0 ;
39742   Dali::AlphaFunction arg4 ;
39743   Dali::Animation::Interpolation arg5 ;
39744   Dali::Property *argp2 ;
39745   Dali::AlphaFunction *argp4 ;
39746
39747   arg1 = (Dali::Animation *)jarg1;
39748   argp2 = (Dali::Property *)jarg2;
39749   if (!argp2) {
39750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39751     return ;
39752   }
39753   arg2 = *argp2;
39754   arg3 = (Dali::KeyFrames *)jarg3;
39755   if (!arg3) {
39756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39757     return ;
39758   }
39759   argp4 = (Dali::AlphaFunction *)jarg4;
39760   if (!argp4) {
39761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39762     return ;
39763   }
39764   arg4 = *argp4;
39765   arg5 = (Dali::Animation::Interpolation)jarg5;
39766   {
39767     try {
39768       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39769     } catch (std::out_of_range& e) {
39770       {
39771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39772       };
39773     } catch (std::exception& e) {
39774       {
39775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39776       };
39777     } catch (...) {
39778       {
39779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39780       };
39781     }
39782   }
39783 }
39784
39785
39786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39787   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39788   SwigValueWrapper< Dali::Property > arg2 ;
39789   Dali::KeyFrames *arg3 = 0 ;
39790   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39791   Dali::Property *argp2 ;
39792   Dali::TimePeriod *argp4 ;
39793
39794   arg1 = (Dali::Animation *)jarg1;
39795   argp2 = (Dali::Property *)jarg2;
39796   if (!argp2) {
39797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39798     return ;
39799   }
39800   arg2 = *argp2;
39801   arg3 = (Dali::KeyFrames *)jarg3;
39802   if (!arg3) {
39803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39804     return ;
39805   }
39806   argp4 = (Dali::TimePeriod *)jarg4;
39807   if (!argp4) {
39808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39809     return ;
39810   }
39811   arg4 = *argp4;
39812   {
39813     try {
39814       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39815     } catch (std::out_of_range& e) {
39816       {
39817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39818       };
39819     } catch (std::exception& e) {
39820       {
39821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39822       };
39823     } catch (...) {
39824       {
39825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39826       };
39827     }
39828   }
39829 }
39830
39831
39832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39833   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39834   SwigValueWrapper< Dali::Property > arg2 ;
39835   Dali::KeyFrames *arg3 = 0 ;
39836   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39837   Dali::Animation::Interpolation arg5 ;
39838   Dali::Property *argp2 ;
39839   Dali::TimePeriod *argp4 ;
39840
39841   arg1 = (Dali::Animation *)jarg1;
39842   argp2 = (Dali::Property *)jarg2;
39843   if (!argp2) {
39844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39845     return ;
39846   }
39847   arg2 = *argp2;
39848   arg3 = (Dali::KeyFrames *)jarg3;
39849   if (!arg3) {
39850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39851     return ;
39852   }
39853   argp4 = (Dali::TimePeriod *)jarg4;
39854   if (!argp4) {
39855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39856     return ;
39857   }
39858   arg4 = *argp4;
39859   arg5 = (Dali::Animation::Interpolation)jarg5;
39860   {
39861     try {
39862       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39863     } catch (std::out_of_range& e) {
39864       {
39865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39866       };
39867     } catch (std::exception& e) {
39868       {
39869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39870       };
39871     } catch (...) {
39872       {
39873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39874       };
39875     }
39876   }
39877 }
39878
39879
39880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39881   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39882   SwigValueWrapper< Dali::Property > arg2 ;
39883   Dali::KeyFrames *arg3 = 0 ;
39884   Dali::AlphaFunction arg4 ;
39885   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39886   Dali::Property *argp2 ;
39887   Dali::AlphaFunction *argp4 ;
39888   Dali::TimePeriod *argp5 ;
39889
39890   arg1 = (Dali::Animation *)jarg1;
39891   argp2 = (Dali::Property *)jarg2;
39892   if (!argp2) {
39893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39894     return ;
39895   }
39896   arg2 = *argp2;
39897   arg3 = (Dali::KeyFrames *)jarg3;
39898   if (!arg3) {
39899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39900     return ;
39901   }
39902   argp4 = (Dali::AlphaFunction *)jarg4;
39903   if (!argp4) {
39904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39905     return ;
39906   }
39907   arg4 = *argp4;
39908   argp5 = (Dali::TimePeriod *)jarg5;
39909   if (!argp5) {
39910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39911     return ;
39912   }
39913   arg5 = *argp5;
39914   {
39915     try {
39916       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39917     } catch (std::out_of_range& e) {
39918       {
39919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39920       };
39921     } catch (std::exception& e) {
39922       {
39923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39924       };
39925     } catch (...) {
39926       {
39927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39928       };
39929     }
39930   }
39931 }
39932
39933
39934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
39935   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39936   SwigValueWrapper< Dali::Property > arg2 ;
39937   Dali::KeyFrames *arg3 = 0 ;
39938   Dali::AlphaFunction arg4 ;
39939   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39940   Dali::Animation::Interpolation arg6 ;
39941   Dali::Property *argp2 ;
39942   Dali::AlphaFunction *argp4 ;
39943   Dali::TimePeriod *argp5 ;
39944
39945   arg1 = (Dali::Animation *)jarg1;
39946   argp2 = (Dali::Property *)jarg2;
39947   if (!argp2) {
39948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39949     return ;
39950   }
39951   arg2 = *argp2;
39952   arg3 = (Dali::KeyFrames *)jarg3;
39953   if (!arg3) {
39954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39955     return ;
39956   }
39957   argp4 = (Dali::AlphaFunction *)jarg4;
39958   if (!argp4) {
39959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39960     return ;
39961   }
39962   arg4 = *argp4;
39963   argp5 = (Dali::TimePeriod *)jarg5;
39964   if (!argp5) {
39965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39966     return ;
39967   }
39968   arg5 = *argp5;
39969   arg6 = (Dali::Animation::Interpolation)jarg6;
39970   {
39971     try {
39972       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
39973     } catch (std::out_of_range& e) {
39974       {
39975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39976       };
39977     } catch (std::exception& e) {
39978       {
39979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39980       };
39981     } catch (...) {
39982       {
39983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39984       };
39985     }
39986   }
39987 }
39988
39989
39990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39991   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39992   Dali::Actor arg2 ;
39993   Dali::Path arg3 ;
39994   Dali::Vector3 *arg4 = 0 ;
39995   Dali::Actor *argp2 ;
39996   Dali::Path *argp3 ;
39997
39998   arg1 = (Dali::Animation *)jarg1;
39999   argp2 = (Dali::Actor *)jarg2;
40000   if (!argp2) {
40001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40002     return ;
40003   }
40004   arg2 = *argp2;
40005   argp3 = (Dali::Path *)jarg3;
40006   if (!argp3) {
40007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40008     return ;
40009   }
40010   arg3 = *argp3;
40011   arg4 = (Dali::Vector3 *)jarg4;
40012   if (!arg4) {
40013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40014     return ;
40015   }
40016   {
40017     try {
40018       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40019     } catch (std::out_of_range& e) {
40020       {
40021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40022       };
40023     } catch (std::exception& e) {
40024       {
40025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40026       };
40027     } catch (...) {
40028       {
40029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40030       };
40031     }
40032   }
40033 }
40034
40035
40036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40037   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40038   Dali::Actor arg2 ;
40039   Dali::Path arg3 ;
40040   Dali::Vector3 *arg4 = 0 ;
40041   Dali::AlphaFunction arg5 ;
40042   Dali::Actor *argp2 ;
40043   Dali::Path *argp3 ;
40044   Dali::AlphaFunction *argp5 ;
40045
40046   arg1 = (Dali::Animation *)jarg1;
40047   argp2 = (Dali::Actor *)jarg2;
40048   if (!argp2) {
40049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40050     return ;
40051   }
40052   arg2 = *argp2;
40053   argp3 = (Dali::Path *)jarg3;
40054   if (!argp3) {
40055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40056     return ;
40057   }
40058   arg3 = *argp3;
40059   arg4 = (Dali::Vector3 *)jarg4;
40060   if (!arg4) {
40061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40062     return ;
40063   }
40064   argp5 = (Dali::AlphaFunction *)jarg5;
40065   if (!argp5) {
40066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40067     return ;
40068   }
40069   arg5 = *argp5;
40070   {
40071     try {
40072       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40073     } catch (std::out_of_range& e) {
40074       {
40075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40076       };
40077     } catch (std::exception& e) {
40078       {
40079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40080       };
40081     } catch (...) {
40082       {
40083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40084       };
40085     }
40086   }
40087 }
40088
40089
40090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40091   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40092   Dali::Actor arg2 ;
40093   Dali::Path arg3 ;
40094   Dali::Vector3 *arg4 = 0 ;
40095   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40096   Dali::Actor *argp2 ;
40097   Dali::Path *argp3 ;
40098   Dali::TimePeriod *argp5 ;
40099
40100   arg1 = (Dali::Animation *)jarg1;
40101   argp2 = (Dali::Actor *)jarg2;
40102   if (!argp2) {
40103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40104     return ;
40105   }
40106   arg2 = *argp2;
40107   argp3 = (Dali::Path *)jarg3;
40108   if (!argp3) {
40109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40110     return ;
40111   }
40112   arg3 = *argp3;
40113   arg4 = (Dali::Vector3 *)jarg4;
40114   if (!arg4) {
40115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40116     return ;
40117   }
40118   argp5 = (Dali::TimePeriod *)jarg5;
40119   if (!argp5) {
40120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40121     return ;
40122   }
40123   arg5 = *argp5;
40124   {
40125     try {
40126       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40127     } catch (std::out_of_range& e) {
40128       {
40129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40130       };
40131     } catch (std::exception& e) {
40132       {
40133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40134       };
40135     } catch (...) {
40136       {
40137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40138       };
40139     }
40140   }
40141 }
40142
40143
40144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40145   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40146   Dali::Actor arg2 ;
40147   Dali::Path arg3 ;
40148   Dali::Vector3 *arg4 = 0 ;
40149   Dali::AlphaFunction arg5 ;
40150   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40151   Dali::Actor *argp2 ;
40152   Dali::Path *argp3 ;
40153   Dali::AlphaFunction *argp5 ;
40154   Dali::TimePeriod *argp6 ;
40155
40156   arg1 = (Dali::Animation *)jarg1;
40157   argp2 = (Dali::Actor *)jarg2;
40158   if (!argp2) {
40159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40160     return ;
40161   }
40162   arg2 = *argp2;
40163   argp3 = (Dali::Path *)jarg3;
40164   if (!argp3) {
40165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40166     return ;
40167   }
40168   arg3 = *argp3;
40169   arg4 = (Dali::Vector3 *)jarg4;
40170   if (!arg4) {
40171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40172     return ;
40173   }
40174   argp5 = (Dali::AlphaFunction *)jarg5;
40175   if (!argp5) {
40176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40177     return ;
40178   }
40179   arg5 = *argp5;
40180   argp6 = (Dali::TimePeriod *)jarg6;
40181   if (!argp6) {
40182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40183     return ;
40184   }
40185   arg6 = *argp6;
40186   {
40187     try {
40188       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40189     } catch (std::out_of_range& e) {
40190       {
40191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40192       };
40193     } catch (std::exception& e) {
40194       {
40195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40196       };
40197     } catch (...) {
40198       {
40199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40200       };
40201     }
40202   }
40203 }
40204
40205
40206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40207   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40208   Dali::Actor arg2 ;
40209   float arg3 ;
40210   Dali::Actor *argp2 ;
40211
40212   arg1 = (Dali::Animation *)jarg1;
40213   argp2 = (Dali::Actor *)jarg2;
40214   if (!argp2) {
40215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40216     return ;
40217   }
40218   arg2 = *argp2;
40219   arg3 = (float)jarg3;
40220   {
40221     try {
40222       (arg1)->Show(arg2,arg3);
40223     } catch (std::out_of_range& e) {
40224       {
40225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40226       };
40227     } catch (std::exception& e) {
40228       {
40229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40230       };
40231     } catch (...) {
40232       {
40233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40234       };
40235     }
40236   }
40237 }
40238
40239
40240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40241   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40242   Dali::Actor arg2 ;
40243   float arg3 ;
40244   Dali::Actor *argp2 ;
40245
40246   arg1 = (Dali::Animation *)jarg1;
40247   argp2 = (Dali::Actor *)jarg2;
40248   if (!argp2) {
40249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40250     return ;
40251   }
40252   arg2 = *argp2;
40253   arg3 = (float)jarg3;
40254   {
40255     try {
40256       (arg1)->Hide(arg2,arg3);
40257     } catch (std::out_of_range& e) {
40258       {
40259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40260       };
40261     } catch (std::exception& e) {
40262       {
40263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40264       };
40265     } catch (...) {
40266       {
40267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40268       };
40269     }
40270   }
40271 }
40272
40273
40274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40275   int jresult ;
40276   int result;
40277
40278   result = (int)Dali::LinearConstrainer::Property::VALUE;
40279   jresult = (int)result;
40280   return jresult;
40281 }
40282
40283
40284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40285   int jresult ;
40286   int result;
40287
40288   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40289   jresult = (int)result;
40290   return jresult;
40291 }
40292
40293
40294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40295   void * jresult ;
40296   Dali::LinearConstrainer::Property *result = 0 ;
40297
40298   {
40299     try {
40300       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40301     } catch (std::out_of_range& e) {
40302       {
40303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40304       };
40305     } catch (std::exception& e) {
40306       {
40307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40308       };
40309     } catch (...) {
40310       {
40311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40312       };
40313     }
40314   }
40315   jresult = (void *)result;
40316   return jresult;
40317 }
40318
40319
40320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40321   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40322
40323   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40324   {
40325     try {
40326       delete arg1;
40327     } catch (std::out_of_range& e) {
40328       {
40329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40330       };
40331     } catch (std::exception& e) {
40332       {
40333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40334       };
40335     } catch (...) {
40336       {
40337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40338       };
40339     }
40340   }
40341 }
40342
40343
40344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40345   void * jresult ;
40346   Dali::LinearConstrainer result;
40347
40348   {
40349     try {
40350       result = Dali::LinearConstrainer::New();
40351     } catch (std::out_of_range& e) {
40352       {
40353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40354       };
40355     } catch (std::exception& e) {
40356       {
40357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40358       };
40359     } catch (...) {
40360       {
40361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40362       };
40363     }
40364   }
40365   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40366   return jresult;
40367 }
40368
40369
40370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40371   void * jresult ;
40372   Dali::BaseHandle arg1 ;
40373   Dali::BaseHandle *argp1 ;
40374   Dali::LinearConstrainer result;
40375
40376   argp1 = (Dali::BaseHandle *)jarg1;
40377   if (!argp1) {
40378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40379     return 0;
40380   }
40381   arg1 = *argp1;
40382   {
40383     try {
40384       result = Dali::LinearConstrainer::DownCast(arg1);
40385     } catch (std::out_of_range& e) {
40386       {
40387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40388       };
40389     } catch (std::exception& e) {
40390       {
40391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40392       };
40393     } catch (...) {
40394       {
40395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40396       };
40397     }
40398   }
40399   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40400   return jresult;
40401 }
40402
40403
40404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40405   void * jresult ;
40406   Dali::LinearConstrainer *result = 0 ;
40407
40408   {
40409     try {
40410       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40411     } catch (std::out_of_range& e) {
40412       {
40413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40414       };
40415     } catch (std::exception& e) {
40416       {
40417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40418       };
40419     } catch (...) {
40420       {
40421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40422       };
40423     }
40424   }
40425   jresult = (void *)result;
40426   return jresult;
40427 }
40428
40429
40430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40431   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40432
40433   arg1 = (Dali::LinearConstrainer *)jarg1;
40434   {
40435     try {
40436       delete arg1;
40437     } catch (std::out_of_range& e) {
40438       {
40439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40440       };
40441     } catch (std::exception& e) {
40442       {
40443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40444       };
40445     } catch (...) {
40446       {
40447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40448       };
40449     }
40450   }
40451 }
40452
40453
40454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40455   void * jresult ;
40456   Dali::LinearConstrainer *arg1 = 0 ;
40457   Dali::LinearConstrainer *result = 0 ;
40458
40459   arg1 = (Dali::LinearConstrainer *)jarg1;
40460   if (!arg1) {
40461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40462     return 0;
40463   }
40464   {
40465     try {
40466       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40467     } catch (std::out_of_range& e) {
40468       {
40469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40470       };
40471     } catch (std::exception& e) {
40472       {
40473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40474       };
40475     } catch (...) {
40476       {
40477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40478       };
40479     }
40480   }
40481   jresult = (void *)result;
40482   return jresult;
40483 }
40484
40485
40486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40487   void * jresult ;
40488   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40489   Dali::LinearConstrainer *arg2 = 0 ;
40490   Dali::LinearConstrainer *result = 0 ;
40491
40492   arg1 = (Dali::LinearConstrainer *)jarg1;
40493   arg2 = (Dali::LinearConstrainer *)jarg2;
40494   if (!arg2) {
40495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40496     return 0;
40497   }
40498   {
40499     try {
40500       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40501     } catch (std::out_of_range& e) {
40502       {
40503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40504       };
40505     } catch (std::exception& e) {
40506       {
40507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40508       };
40509     } catch (...) {
40510       {
40511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40512       };
40513     }
40514   }
40515   jresult = (void *)result;
40516   return jresult;
40517 }
40518
40519
40520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40521   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40522   SwigValueWrapper< Dali::Property > arg2 ;
40523   SwigValueWrapper< Dali::Property > arg3 ;
40524   Dali::Vector2 *arg4 = 0 ;
40525   Dali::Vector2 *arg5 = 0 ;
40526   Dali::Property *argp2 ;
40527   Dali::Property *argp3 ;
40528
40529   arg1 = (Dali::LinearConstrainer *)jarg1;
40530   argp2 = (Dali::Property *)jarg2;
40531   if (!argp2) {
40532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40533     return ;
40534   }
40535   arg2 = *argp2;
40536   argp3 = (Dali::Property *)jarg3;
40537   if (!argp3) {
40538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40539     return ;
40540   }
40541   arg3 = *argp3;
40542   arg4 = (Dali::Vector2 *)jarg4;
40543   if (!arg4) {
40544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40545     return ;
40546   }
40547   arg5 = (Dali::Vector2 *)jarg5;
40548   if (!arg5) {
40549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40550     return ;
40551   }
40552   {
40553     try {
40554       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40555     } catch (std::out_of_range& e) {
40556       {
40557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40558       };
40559     } catch (std::exception& e) {
40560       {
40561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40562       };
40563     } catch (...) {
40564       {
40565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40566       };
40567     }
40568   }
40569 }
40570
40571
40572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40573   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40574   SwigValueWrapper< Dali::Property > arg2 ;
40575   SwigValueWrapper< Dali::Property > arg3 ;
40576   Dali::Vector2 *arg4 = 0 ;
40577   Dali::Property *argp2 ;
40578   Dali::Property *argp3 ;
40579
40580   arg1 = (Dali::LinearConstrainer *)jarg1;
40581   argp2 = (Dali::Property *)jarg2;
40582   if (!argp2) {
40583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40584     return ;
40585   }
40586   arg2 = *argp2;
40587   argp3 = (Dali::Property *)jarg3;
40588   if (!argp3) {
40589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40590     return ;
40591   }
40592   arg3 = *argp3;
40593   arg4 = (Dali::Vector2 *)jarg4;
40594   if (!arg4) {
40595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40596     return ;
40597   }
40598   {
40599     try {
40600       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40601     } catch (std::out_of_range& e) {
40602       {
40603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40604       };
40605     } catch (std::exception& e) {
40606       {
40607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40608       };
40609     } catch (...) {
40610       {
40611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40612       };
40613     }
40614   }
40615 }
40616
40617
40618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40619   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40620   Dali::Handle *arg2 = 0 ;
40621
40622   arg1 = (Dali::LinearConstrainer *)jarg1;
40623   arg2 = (Dali::Handle *)jarg2;
40624   if (!arg2) {
40625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40626     return ;
40627   }
40628   {
40629     try {
40630       (arg1)->Remove(*arg2);
40631     } catch (std::out_of_range& e) {
40632       {
40633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40634       };
40635     } catch (std::exception& e) {
40636       {
40637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40638       };
40639     } catch (...) {
40640       {
40641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40642       };
40643     }
40644   }
40645 }
40646
40647
40648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40649   int jresult ;
40650   int result;
40651
40652   result = (int)Dali::PathConstrainer::Property::FORWARD;
40653   jresult = (int)result;
40654   return jresult;
40655 }
40656
40657
40658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40659   int jresult ;
40660   int result;
40661
40662   result = (int)Dali::PathConstrainer::Property::POINTS;
40663   jresult = (int)result;
40664   return jresult;
40665 }
40666
40667
40668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40669   int jresult ;
40670   int result;
40671
40672   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40673   jresult = (int)result;
40674   return jresult;
40675 }
40676
40677
40678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40679   void * jresult ;
40680   Dali::PathConstrainer::Property *result = 0 ;
40681
40682   {
40683     try {
40684       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40685     } catch (std::out_of_range& e) {
40686       {
40687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40688       };
40689     } catch (std::exception& e) {
40690       {
40691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40692       };
40693     } catch (...) {
40694       {
40695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40696       };
40697     }
40698   }
40699   jresult = (void *)result;
40700   return jresult;
40701 }
40702
40703
40704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40705   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40706
40707   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40708   {
40709     try {
40710       delete arg1;
40711     } catch (std::out_of_range& e) {
40712       {
40713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40714       };
40715     } catch (std::exception& e) {
40716       {
40717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40718       };
40719     } catch (...) {
40720       {
40721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40722       };
40723     }
40724   }
40725 }
40726
40727
40728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40729   void * jresult ;
40730   Dali::PathConstrainer result;
40731
40732   {
40733     try {
40734       result = Dali::PathConstrainer::New();
40735     } catch (std::out_of_range& e) {
40736       {
40737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40738       };
40739     } catch (std::exception& e) {
40740       {
40741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40742       };
40743     } catch (...) {
40744       {
40745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40746       };
40747     }
40748   }
40749   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40750   return jresult;
40751 }
40752
40753
40754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40755   void * jresult ;
40756   Dali::BaseHandle arg1 ;
40757   Dali::BaseHandle *argp1 ;
40758   Dali::PathConstrainer result;
40759
40760   argp1 = (Dali::BaseHandle *)jarg1;
40761   if (!argp1) {
40762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40763     return 0;
40764   }
40765   arg1 = *argp1;
40766   {
40767     try {
40768       result = Dali::PathConstrainer::DownCast(arg1);
40769     } catch (std::out_of_range& e) {
40770       {
40771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40772       };
40773     } catch (std::exception& e) {
40774       {
40775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40776       };
40777     } catch (...) {
40778       {
40779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40780       };
40781     }
40782   }
40783   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40784   return jresult;
40785 }
40786
40787
40788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40789   void * jresult ;
40790   Dali::PathConstrainer *result = 0 ;
40791
40792   {
40793     try {
40794       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40795     } catch (std::out_of_range& e) {
40796       {
40797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40798       };
40799     } catch (std::exception& e) {
40800       {
40801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40802       };
40803     } catch (...) {
40804       {
40805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40806       };
40807     }
40808   }
40809   jresult = (void *)result;
40810   return jresult;
40811 }
40812
40813
40814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40815   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40816
40817   arg1 = (Dali::PathConstrainer *)jarg1;
40818   {
40819     try {
40820       delete arg1;
40821     } catch (std::out_of_range& e) {
40822       {
40823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40824       };
40825     } catch (std::exception& e) {
40826       {
40827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40828       };
40829     } catch (...) {
40830       {
40831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40832       };
40833     }
40834   }
40835 }
40836
40837
40838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
40839   void * jresult ;
40840   Dali::PathConstrainer *arg1 = 0 ;
40841   Dali::PathConstrainer *result = 0 ;
40842
40843   arg1 = (Dali::PathConstrainer *)jarg1;
40844   if (!arg1) {
40845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40846     return 0;
40847   }
40848   {
40849     try {
40850       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
40851     } catch (std::out_of_range& e) {
40852       {
40853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40854       };
40855     } catch (std::exception& e) {
40856       {
40857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40858       };
40859     } catch (...) {
40860       {
40861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40862       };
40863     }
40864   }
40865   jresult = (void *)result;
40866   return jresult;
40867 }
40868
40869
40870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
40871   void * jresult ;
40872   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40873   Dali::PathConstrainer *arg2 = 0 ;
40874   Dali::PathConstrainer *result = 0 ;
40875
40876   arg1 = (Dali::PathConstrainer *)jarg1;
40877   arg2 = (Dali::PathConstrainer *)jarg2;
40878   if (!arg2) {
40879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40880     return 0;
40881   }
40882   {
40883     try {
40884       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
40885     } catch (std::out_of_range& e) {
40886       {
40887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40888       };
40889     } catch (std::exception& e) {
40890       {
40891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40892       };
40893     } catch (...) {
40894       {
40895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40896       };
40897     }
40898   }
40899   jresult = (void *)result;
40900   return jresult;
40901 }
40902
40903
40904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40905   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40906   SwigValueWrapper< Dali::Property > arg2 ;
40907   SwigValueWrapper< Dali::Property > arg3 ;
40908   Dali::Vector2 *arg4 = 0 ;
40909   Dali::Vector2 *arg5 = 0 ;
40910   Dali::Property *argp2 ;
40911   Dali::Property *argp3 ;
40912
40913   arg1 = (Dali::PathConstrainer *)jarg1;
40914   argp2 = (Dali::Property *)jarg2;
40915   if (!argp2) {
40916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40917     return ;
40918   }
40919   arg2 = *argp2;
40920   argp3 = (Dali::Property *)jarg3;
40921   if (!argp3) {
40922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40923     return ;
40924   }
40925   arg3 = *argp3;
40926   arg4 = (Dali::Vector2 *)jarg4;
40927   if (!arg4) {
40928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40929     return ;
40930   }
40931   arg5 = (Dali::Vector2 *)jarg5;
40932   if (!arg5) {
40933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40934     return ;
40935   }
40936   {
40937     try {
40938       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40939     } catch (std::out_of_range& e) {
40940       {
40941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40942       };
40943     } catch (std::exception& e) {
40944       {
40945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40946       };
40947     } catch (...) {
40948       {
40949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40950       };
40951     }
40952   }
40953 }
40954
40955
40956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40957   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40958   SwigValueWrapper< Dali::Property > arg2 ;
40959   SwigValueWrapper< Dali::Property > arg3 ;
40960   Dali::Vector2 *arg4 = 0 ;
40961   Dali::Property *argp2 ;
40962   Dali::Property *argp3 ;
40963
40964   arg1 = (Dali::PathConstrainer *)jarg1;
40965   argp2 = (Dali::Property *)jarg2;
40966   if (!argp2) {
40967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40968     return ;
40969   }
40970   arg2 = *argp2;
40971   argp3 = (Dali::Property *)jarg3;
40972   if (!argp3) {
40973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40974     return ;
40975   }
40976   arg3 = *argp3;
40977   arg4 = (Dali::Vector2 *)jarg4;
40978   if (!arg4) {
40979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40980     return ;
40981   }
40982   {
40983     try {
40984       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40985     } catch (std::out_of_range& e) {
40986       {
40987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40988       };
40989     } catch (std::exception& e) {
40990       {
40991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40992       };
40993     } catch (...) {
40994       {
40995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40996       };
40997     }
40998   }
40999 }
41000
41001
41002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41003   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41004   Dali::Handle *arg2 = 0 ;
41005
41006   arg1 = (Dali::PathConstrainer *)jarg1;
41007   arg2 = (Dali::Handle *)jarg2;
41008   if (!arg2) {
41009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41010     return ;
41011   }
41012   {
41013     try {
41014       (arg1)->Remove(*arg2);
41015     } catch (std::out_of_range& e) {
41016       {
41017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41018       };
41019     } catch (std::exception& e) {
41020       {
41021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41022       };
41023     } catch (...) {
41024       {
41025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41026       };
41027     }
41028   }
41029 }
41030
41031
41032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41033   int jresult ;
41034   Dali::FittingMode::Type result;
41035
41036   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41037   jresult = (int)result;
41038   return jresult;
41039 }
41040
41041
41042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41043   int jresult ;
41044   Dali::SamplingMode::Type result;
41045
41046   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41047   jresult = (int)result;
41048   return jresult;
41049 }
41050
41051
41052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41053   void * jresult ;
41054   Dali::BufferImage *result = 0 ;
41055
41056   {
41057     try {
41058       result = (Dali::BufferImage *)new Dali::BufferImage();
41059     } catch (std::out_of_range& e) {
41060       {
41061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41062       };
41063     } catch (std::exception& e) {
41064       {
41065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41066       };
41067     } catch (...) {
41068       {
41069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41070       };
41071     }
41072   }
41073   jresult = (void *)result;
41074   return jresult;
41075 }
41076
41077
41078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41079   void * jresult ;
41080   unsigned int arg1 ;
41081   unsigned int arg2 ;
41082   Dali::Pixel::Format arg3 ;
41083   Dali::BufferImage result;
41084
41085   arg1 = (unsigned int)jarg1;
41086   arg2 = (unsigned int)jarg2;
41087   arg3 = (Dali::Pixel::Format)jarg3;
41088   {
41089     try {
41090       result = Dali::BufferImage::New(arg1,arg2,arg3);
41091     } catch (std::out_of_range& e) {
41092       {
41093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41094       };
41095     } catch (std::exception& e) {
41096       {
41097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41098       };
41099     } catch (...) {
41100       {
41101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41102       };
41103     }
41104   }
41105   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41106   return jresult;
41107 }
41108
41109
41110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41111   void * jresult ;
41112   unsigned int arg1 ;
41113   unsigned int arg2 ;
41114   Dali::BufferImage result;
41115
41116   arg1 = (unsigned int)jarg1;
41117   arg2 = (unsigned int)jarg2;
41118   {
41119     try {
41120       result = Dali::BufferImage::New(arg1,arg2);
41121     } catch (std::out_of_range& e) {
41122       {
41123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41124       };
41125     } catch (std::exception& e) {
41126       {
41127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41128       };
41129     } catch (...) {
41130       {
41131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41132       };
41133     }
41134   }
41135   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41136   return jresult;
41137 }
41138
41139
41140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41141   void * jresult ;
41142   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41143   unsigned int arg2 ;
41144   unsigned int arg3 ;
41145   Dali::Pixel::Format arg4 ;
41146   unsigned int arg5 ;
41147   Dali::BufferImage result;
41148
41149   arg1 = jarg1;
41150   arg2 = (unsigned int)jarg2;
41151   arg3 = (unsigned int)jarg3;
41152   arg4 = (Dali::Pixel::Format)jarg4;
41153   arg5 = (unsigned int)jarg5;
41154   {
41155     try {
41156       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41157     } catch (std::out_of_range& e) {
41158       {
41159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41160       };
41161     } catch (std::exception& e) {
41162       {
41163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41164       };
41165     } catch (...) {
41166       {
41167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41168       };
41169     }
41170   }
41171   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41172
41173
41174   return jresult;
41175 }
41176
41177
41178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41179   void * jresult ;
41180   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41181   unsigned int arg2 ;
41182   unsigned int arg3 ;
41183   Dali::Pixel::Format arg4 ;
41184   Dali::BufferImage result;
41185
41186   arg1 = jarg1;
41187   arg2 = (unsigned int)jarg2;
41188   arg3 = (unsigned int)jarg3;
41189   arg4 = (Dali::Pixel::Format)jarg4;
41190   {
41191     try {
41192       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41193     } catch (std::out_of_range& e) {
41194       {
41195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41196       };
41197     } catch (std::exception& e) {
41198       {
41199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41200       };
41201     } catch (...) {
41202       {
41203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41204       };
41205     }
41206   }
41207   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41208
41209
41210   return jresult;
41211 }
41212
41213
41214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41215   void * jresult ;
41216   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41217   unsigned int arg2 ;
41218   unsigned int arg3 ;
41219   Dali::BufferImage result;
41220
41221   arg1 = jarg1;
41222   arg2 = (unsigned int)jarg2;
41223   arg3 = (unsigned int)jarg3;
41224   {
41225     try {
41226       result = Dali::BufferImage::New(arg1,arg2,arg3);
41227     } catch (std::out_of_range& e) {
41228       {
41229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41230       };
41231     } catch (std::exception& e) {
41232       {
41233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41234       };
41235     } catch (...) {
41236       {
41237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41238       };
41239     }
41240   }
41241   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41242
41243
41244   return jresult;
41245 }
41246
41247
41248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41249   void * jresult ;
41250   Dali::BaseHandle arg1 ;
41251   Dali::BaseHandle *argp1 ;
41252   Dali::BufferImage result;
41253
41254   argp1 = (Dali::BaseHandle *)jarg1;
41255   if (!argp1) {
41256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41257     return 0;
41258   }
41259   arg1 = *argp1;
41260   {
41261     try {
41262       result = Dali::BufferImage::DownCast(arg1);
41263     } catch (std::out_of_range& e) {
41264       {
41265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41266       };
41267     } catch (std::exception& e) {
41268       {
41269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41270       };
41271     } catch (...) {
41272       {
41273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41274       };
41275     }
41276   }
41277   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41278   return jresult;
41279 }
41280
41281
41282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41283   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41284
41285   arg1 = (Dali::BufferImage *)jarg1;
41286   {
41287     try {
41288       delete arg1;
41289     } catch (std::out_of_range& e) {
41290       {
41291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41292       };
41293     } catch (std::exception& e) {
41294       {
41295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41296       };
41297     } catch (...) {
41298       {
41299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41300       };
41301     }
41302   }
41303 }
41304
41305
41306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41307   void * jresult ;
41308   Dali::BufferImage *arg1 = 0 ;
41309   Dali::BufferImage *result = 0 ;
41310
41311   arg1 = (Dali::BufferImage *)jarg1;
41312   if (!arg1) {
41313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41314     return 0;
41315   }
41316   {
41317     try {
41318       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41319     } catch (std::out_of_range& e) {
41320       {
41321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41322       };
41323     } catch (std::exception& e) {
41324       {
41325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41326       };
41327     } catch (...) {
41328       {
41329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41330       };
41331     }
41332   }
41333   jresult = (void *)result;
41334   return jresult;
41335 }
41336
41337
41338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41339   void * jresult ;
41340   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41341   Dali::BufferImage *arg2 = 0 ;
41342   Dali::BufferImage *result = 0 ;
41343
41344   arg1 = (Dali::BufferImage *)jarg1;
41345   arg2 = (Dali::BufferImage *)jarg2;
41346   if (!arg2) {
41347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41348     return 0;
41349   }
41350   {
41351     try {
41352       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41353     } catch (std::out_of_range& e) {
41354       {
41355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41356       };
41357     } catch (std::exception& e) {
41358       {
41359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41360       };
41361     } catch (...) {
41362       {
41363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41364       };
41365     }
41366   }
41367   jresult = (void *)result;
41368   return jresult;
41369 }
41370
41371
41372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41373   void * jresult ;
41374   Dali::BufferImage result;
41375
41376   {
41377     try {
41378       result = Dali::BufferImage::WHITE();
41379     } catch (std::out_of_range& e) {
41380       {
41381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41382       };
41383     } catch (std::exception& e) {
41384       {
41385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41386       };
41387     } catch (...) {
41388       {
41389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41390       };
41391     }
41392   }
41393   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41394   return jresult;
41395 }
41396
41397
41398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41399   void * jresult ;
41400   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41401   Dali::PixelBuffer *result = 0 ;
41402
41403   arg1 = (Dali::BufferImage *)jarg1;
41404   {
41405     try {
41406       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41407     } catch (std::out_of_range& e) {
41408       {
41409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41410       };
41411     } catch (std::exception& e) {
41412       {
41413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41414       };
41415     } catch (...) {
41416       {
41417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41418       };
41419     }
41420   }
41421   jresult = (void *)result;
41422   return jresult;
41423 }
41424
41425
41426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41427   unsigned int jresult ;
41428   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41429   unsigned int result;
41430
41431   arg1 = (Dali::BufferImage *)jarg1;
41432   {
41433     try {
41434       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41435     } catch (std::out_of_range& e) {
41436       {
41437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41438       };
41439     } catch (std::exception& e) {
41440       {
41441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41442       };
41443     } catch (...) {
41444       {
41445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41446       };
41447     }
41448   }
41449   jresult = result;
41450   return jresult;
41451 }
41452
41453
41454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41455   unsigned int jresult ;
41456   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41457   unsigned int result;
41458
41459   arg1 = (Dali::BufferImage *)jarg1;
41460   {
41461     try {
41462       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41463     } catch (std::out_of_range& e) {
41464       {
41465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41466       };
41467     } catch (std::exception& e) {
41468       {
41469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41470       };
41471     } catch (...) {
41472       {
41473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41474       };
41475     }
41476   }
41477   jresult = result;
41478   return jresult;
41479 }
41480
41481
41482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41483   int jresult ;
41484   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41485   Dali::Pixel::Format result;
41486
41487   arg1 = (Dali::BufferImage *)jarg1;
41488   {
41489     try {
41490       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41491     } catch (std::out_of_range& e) {
41492       {
41493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41494       };
41495     } catch (std::exception& e) {
41496       {
41497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41498       };
41499     } catch (...) {
41500       {
41501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41502       };
41503     }
41504   }
41505   jresult = (int)result;
41506   return jresult;
41507 }
41508
41509
41510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41511   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41512
41513   arg1 = (Dali::BufferImage *)jarg1;
41514   {
41515     try {
41516       (arg1)->Update();
41517     } catch (std::out_of_range& e) {
41518       {
41519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41520       };
41521     } catch (std::exception& e) {
41522       {
41523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41524       };
41525     } catch (...) {
41526       {
41527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41528       };
41529     }
41530   }
41531 }
41532
41533
41534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41535   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41536   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41537   Dali::RectArea *argp2 ;
41538
41539   arg1 = (Dali::BufferImage *)jarg1;
41540   argp2 = (Dali::RectArea *)jarg2;
41541   if (!argp2) {
41542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41543     return ;
41544   }
41545   arg2 = *argp2;
41546   {
41547     try {
41548       (arg1)->Update(arg2);
41549     } catch (std::out_of_range& e) {
41550       {
41551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41552       };
41553     } catch (std::exception& e) {
41554       {
41555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41556       };
41557     } catch (...) {
41558       {
41559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41560       };
41561     }
41562   }
41563 }
41564
41565
41566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41567   unsigned int jresult ;
41568   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41569   bool result;
41570
41571   arg1 = (Dali::BufferImage *)jarg1;
41572   {
41573     try {
41574       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41575     } catch (std::out_of_range& e) {
41576       {
41577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41578       };
41579     } catch (std::exception& e) {
41580       {
41581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41582       };
41583     } catch (...) {
41584       {
41585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41586       };
41587     }
41588   }
41589   jresult = result;
41590   return jresult;
41591 }
41592
41593
41594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41595   void * jresult ;
41596   Dali::EncodedBufferImage *result = 0 ;
41597
41598   {
41599     try {
41600       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41601     } catch (std::out_of_range& e) {
41602       {
41603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41604       };
41605     } catch (std::exception& e) {
41606       {
41607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41608       };
41609     } catch (...) {
41610       {
41611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41612       };
41613     }
41614   }
41615   jresult = (void *)result;
41616   return jresult;
41617 }
41618
41619
41620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41621   void * jresult ;
41622   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41623   std::size_t arg2 ;
41624   Dali::EncodedBufferImage result;
41625
41626   arg1 = (uint8_t *)jarg1;
41627   arg2 = (std::size_t)jarg2;
41628   {
41629     try {
41630       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41631     } catch (std::out_of_range& e) {
41632       {
41633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41634       };
41635     } catch (std::exception& e) {
41636       {
41637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41638       };
41639     } catch (...) {
41640       {
41641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41642       };
41643     }
41644   }
41645   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41646   return jresult;
41647 }
41648
41649
41650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41651   void * jresult ;
41652   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41653   std::size_t arg2 ;
41654   Dali::ImageDimensions arg3 ;
41655   Dali::FittingMode::Type arg4 ;
41656   Dali::SamplingMode::Type arg5 ;
41657   bool arg6 ;
41658   Dali::ImageDimensions *argp3 ;
41659   Dali::EncodedBufferImage result;
41660
41661   arg1 = (uint8_t *)jarg1;
41662   arg2 = (std::size_t)jarg2;
41663   argp3 = (Dali::ImageDimensions *)jarg3;
41664   if (!argp3) {
41665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41666     return 0;
41667   }
41668   arg3 = *argp3;
41669   arg4 = (Dali::FittingMode::Type)jarg4;
41670   arg5 = (Dali::SamplingMode::Type)jarg5;
41671   arg6 = jarg6 ? true : false;
41672   {
41673     try {
41674       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41675     } catch (std::out_of_range& e) {
41676       {
41677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41678       };
41679     } catch (std::exception& e) {
41680       {
41681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41682       };
41683     } catch (...) {
41684       {
41685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41686       };
41687     }
41688   }
41689   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41690   return jresult;
41691 }
41692
41693
41694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41695   void * jresult ;
41696   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41697   std::size_t arg2 ;
41698   Dali::ImageDimensions arg3 ;
41699   Dali::FittingMode::Type arg4 ;
41700   Dali::SamplingMode::Type arg5 ;
41701   Dali::ImageDimensions *argp3 ;
41702   Dali::EncodedBufferImage result;
41703
41704   arg1 = (uint8_t *)jarg1;
41705   arg2 = (std::size_t)jarg2;
41706   argp3 = (Dali::ImageDimensions *)jarg3;
41707   if (!argp3) {
41708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41709     return 0;
41710   }
41711   arg3 = *argp3;
41712   arg4 = (Dali::FittingMode::Type)jarg4;
41713   arg5 = (Dali::SamplingMode::Type)jarg5;
41714   {
41715     try {
41716       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41717     } catch (std::out_of_range& e) {
41718       {
41719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41720       };
41721     } catch (std::exception& e) {
41722       {
41723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41724       };
41725     } catch (...) {
41726       {
41727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41728       };
41729     }
41730   }
41731   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41732   return jresult;
41733 }
41734
41735
41736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41737   void * jresult ;
41738   Dali::BaseHandle arg1 ;
41739   Dali::BaseHandle *argp1 ;
41740   Dali::EncodedBufferImage result;
41741
41742   argp1 = (Dali::BaseHandle *)jarg1;
41743   if (!argp1) {
41744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41745     return 0;
41746   }
41747   arg1 = *argp1;
41748   {
41749     try {
41750       result = Dali::EncodedBufferImage::DownCast(arg1);
41751     } catch (std::out_of_range& e) {
41752       {
41753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41754       };
41755     } catch (std::exception& e) {
41756       {
41757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41758       };
41759     } catch (...) {
41760       {
41761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41762       };
41763     }
41764   }
41765   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41766   return jresult;
41767 }
41768
41769
41770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41771   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41772
41773   arg1 = (Dali::EncodedBufferImage *)jarg1;
41774   {
41775     try {
41776       delete arg1;
41777     } catch (std::out_of_range& e) {
41778       {
41779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41780       };
41781     } catch (std::exception& e) {
41782       {
41783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41784       };
41785     } catch (...) {
41786       {
41787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41788       };
41789     }
41790   }
41791 }
41792
41793
41794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41795   void * jresult ;
41796   Dali::EncodedBufferImage *arg1 = 0 ;
41797   Dali::EncodedBufferImage *result = 0 ;
41798
41799   arg1 = (Dali::EncodedBufferImage *)jarg1;
41800   if (!arg1) {
41801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41802     return 0;
41803   }
41804   {
41805     try {
41806       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41807     } catch (std::out_of_range& e) {
41808       {
41809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41810       };
41811     } catch (std::exception& e) {
41812       {
41813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41814       };
41815     } catch (...) {
41816       {
41817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41818       };
41819     }
41820   }
41821   jresult = (void *)result;
41822   return jresult;
41823 }
41824
41825
41826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
41827   void * jresult ;
41828   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41829   Dali::EncodedBufferImage *arg2 = 0 ;
41830   Dali::EncodedBufferImage *result = 0 ;
41831
41832   arg1 = (Dali::EncodedBufferImage *)jarg1;
41833   arg2 = (Dali::EncodedBufferImage *)jarg2;
41834   if (!arg2) {
41835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41836     return 0;
41837   }
41838   {
41839     try {
41840       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
41841     } catch (std::out_of_range& e) {
41842       {
41843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41844       };
41845     } catch (std::exception& e) {
41846       {
41847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41848       };
41849     } catch (...) {
41850       {
41851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41852       };
41853     }
41854   }
41855   jresult = (void *)result;
41856   return jresult;
41857 }
41858
41859
41860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
41861   void * jresult ;
41862   Dali::NativeImage *result = 0 ;
41863
41864   {
41865     try {
41866       result = (Dali::NativeImage *)new Dali::NativeImage();
41867     } catch (std::out_of_range& e) {
41868       {
41869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41870       };
41871     } catch (std::exception& e) {
41872       {
41873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41874       };
41875     } catch (...) {
41876       {
41877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41878       };
41879     }
41880   }
41881   jresult = (void *)result;
41882   return jresult;
41883 }
41884
41885
41886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
41887   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41888
41889   arg1 = (Dali::NativeImage *)jarg1;
41890   {
41891     try {
41892       delete arg1;
41893     } catch (std::out_of_range& e) {
41894       {
41895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41896       };
41897     } catch (std::exception& e) {
41898       {
41899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41900       };
41901     } catch (...) {
41902       {
41903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41904       };
41905     }
41906   }
41907 }
41908
41909
41910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
41911   void * jresult ;
41912   Dali::NativeImage *arg1 = 0 ;
41913   Dali::NativeImage *result = 0 ;
41914
41915   arg1 = (Dali::NativeImage *)jarg1;
41916   if (!arg1) {
41917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41918     return 0;
41919   }
41920   {
41921     try {
41922       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
41923     } catch (std::out_of_range& e) {
41924       {
41925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41926       };
41927     } catch (std::exception& e) {
41928       {
41929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41930       };
41931     } catch (...) {
41932       {
41933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41934       };
41935     }
41936   }
41937   jresult = (void *)result;
41938   return jresult;
41939 }
41940
41941
41942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
41943   void * jresult ;
41944   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41945   Dali::NativeImage *arg2 = 0 ;
41946   Dali::NativeImage *result = 0 ;
41947
41948   arg1 = (Dali::NativeImage *)jarg1;
41949   arg2 = (Dali::NativeImage *)jarg2;
41950   if (!arg2) {
41951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41952     return 0;
41953   }
41954   {
41955     try {
41956       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
41957     } catch (std::out_of_range& e) {
41958       {
41959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41960       };
41961     } catch (std::exception& e) {
41962       {
41963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41964       };
41965     } catch (...) {
41966       {
41967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41968       };
41969     }
41970   }
41971   jresult = (void *)result;
41972   return jresult;
41973 }
41974
41975
41976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
41977   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41978
41979   arg1 = (Dali::NativeImage *)jarg1;
41980   {
41981     try {
41982       (arg1)->CreateGlTexture();
41983     } catch (std::out_of_range& e) {
41984       {
41985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41986       };
41987     } catch (std::exception& e) {
41988       {
41989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41990       };
41991     } catch (...) {
41992       {
41993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41994       };
41995     }
41996   }
41997 }
41998
41999
42000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42001   void * jresult ;
42002   NativeImageInterface *arg1 = 0 ;
42003   Dali::NativeImage result;
42004
42005   arg1 = (NativeImageInterface *)jarg1;
42006   if (!arg1) {
42007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42008     return 0;
42009   }
42010   {
42011     try {
42012       result = Dali::NativeImage::New(*arg1);
42013     } catch (std::out_of_range& e) {
42014       {
42015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42016       };
42017     } catch (std::exception& e) {
42018       {
42019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42020       };
42021     } catch (...) {
42022       {
42023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42024       };
42025     }
42026   }
42027   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42028   return jresult;
42029 }
42030
42031
42032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42033   void * jresult ;
42034   Dali::BaseHandle arg1 ;
42035   Dali::BaseHandle *argp1 ;
42036   Dali::NativeImage result;
42037
42038   argp1 = (Dali::BaseHandle *)jarg1;
42039   if (!argp1) {
42040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42041     return 0;
42042   }
42043   arg1 = *argp1;
42044   {
42045     try {
42046       result = Dali::NativeImage::DownCast(arg1);
42047     } catch (std::out_of_range& e) {
42048       {
42049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42050       };
42051     } catch (std::exception& e) {
42052       {
42053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42054       };
42055     } catch (...) {
42056       {
42057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42058       };
42059     }
42060   }
42061   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42062   return jresult;
42063 }
42064
42065
42066 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42067   char * jresult ;
42068   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42069   char *result = 0 ;
42070
42071   arg1 = (Dali::NativeImage *)jarg1;
42072   {
42073     try {
42074       result = (char *)(arg1)->GetCustomFragmentPreFix();
42075     } catch (std::out_of_range& e) {
42076       {
42077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42078       };
42079     } catch (std::exception& e) {
42080       {
42081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42082       };
42083     } catch (...) {
42084       {
42085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42086       };
42087     }
42088   }
42089   jresult = SWIG_csharp_string_callback((const char *)result);
42090   return jresult;
42091 }
42092
42093
42094 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42095   char * jresult ;
42096   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42097   char *result = 0 ;
42098
42099   arg1 = (Dali::NativeImage *)jarg1;
42100   {
42101     try {
42102       result = (char *)(arg1)->GetCustomSamplerTypename();
42103     } catch (std::out_of_range& e) {
42104       {
42105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42106       };
42107     } catch (std::exception& e) {
42108       {
42109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42110       };
42111     } catch (...) {
42112       {
42113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42114       };
42115     }
42116   }
42117   jresult = SWIG_csharp_string_callback((const char *)result);
42118   return jresult;
42119 }
42120
42121
42122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42123   unsigned int jresult ;
42124   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42125   bool result;
42126
42127   arg1 = (Dali::NativeImageInterface *)jarg1;
42128   {
42129     try {
42130       result = (bool)(arg1)->GlExtensionCreate();
42131     } catch (std::out_of_range& e) {
42132       {
42133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42134       };
42135     } catch (std::exception& e) {
42136       {
42137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42138       };
42139     } catch (...) {
42140       {
42141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42142       };
42143     }
42144   }
42145   jresult = result;
42146   return jresult;
42147 }
42148
42149
42150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42151   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42152
42153   arg1 = (Dali::NativeImageInterface *)jarg1;
42154   {
42155     try {
42156       (arg1)->GlExtensionDestroy();
42157     } catch (std::out_of_range& e) {
42158       {
42159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42160       };
42161     } catch (std::exception& e) {
42162       {
42163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42164       };
42165     } catch (...) {
42166       {
42167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42168       };
42169     }
42170   }
42171 }
42172
42173
42174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42175   unsigned int jresult ;
42176   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42177   unsigned int result;
42178
42179   arg1 = (Dali::NativeImageInterface *)jarg1;
42180   {
42181     try {
42182       result = (unsigned int)(arg1)->TargetTexture();
42183     } catch (std::out_of_range& e) {
42184       {
42185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42186       };
42187     } catch (std::exception& e) {
42188       {
42189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42190       };
42191     } catch (...) {
42192       {
42193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42194       };
42195     }
42196   }
42197   jresult = result;
42198   return jresult;
42199 }
42200
42201
42202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42203   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42204
42205   arg1 = (Dali::NativeImageInterface *)jarg1;
42206   {
42207     try {
42208       (arg1)->PrepareTexture();
42209     } catch (std::out_of_range& e) {
42210       {
42211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42212       };
42213     } catch (std::exception& e) {
42214       {
42215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42216       };
42217     } catch (...) {
42218       {
42219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42220       };
42221     }
42222   }
42223 }
42224
42225
42226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42227   unsigned int jresult ;
42228   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42229   unsigned int result;
42230
42231   arg1 = (Dali::NativeImageInterface *)jarg1;
42232   {
42233     try {
42234       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42235     } catch (std::out_of_range& e) {
42236       {
42237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42238       };
42239     } catch (std::exception& e) {
42240       {
42241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42242       };
42243     } catch (...) {
42244       {
42245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42246       };
42247     }
42248   }
42249   jresult = result;
42250   return jresult;
42251 }
42252
42253
42254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42255   unsigned int jresult ;
42256   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42257   unsigned int result;
42258
42259   arg1 = (Dali::NativeImageInterface *)jarg1;
42260   {
42261     try {
42262       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42263     } catch (std::out_of_range& e) {
42264       {
42265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42266       };
42267     } catch (std::exception& e) {
42268       {
42269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42270       };
42271     } catch (...) {
42272       {
42273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42274       };
42275     }
42276   }
42277   jresult = result;
42278   return jresult;
42279 }
42280
42281
42282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42283   unsigned int jresult ;
42284   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42285   bool result;
42286
42287   arg1 = (Dali::NativeImageInterface *)jarg1;
42288   {
42289     try {
42290       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42291     } catch (std::out_of_range& e) {
42292       {
42293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42294       };
42295     } catch (std::exception& e) {
42296       {
42297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42298       };
42299     } catch (...) {
42300       {
42301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42302       };
42303     }
42304   }
42305   jresult = result;
42306   return jresult;
42307 }
42308
42309
42310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42311   void * jresult ;
42312   std::string *arg1 = 0 ;
42313   Dali::ImageDimensions result;
42314
42315   if (!jarg1) {
42316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42317     return 0;
42318   }
42319   std::string arg1_str(jarg1);
42320   arg1 = &arg1_str;
42321   {
42322     try {
42323       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42324     } catch (std::out_of_range& e) {
42325       {
42326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42327       };
42328     } catch (std::exception& e) {
42329       {
42330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42331       };
42332     } catch (...) {
42333       {
42334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42335       };
42336     }
42337   }
42338   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42339
42340   //argout typemap for const std::string&
42341
42342   return jresult;
42343 }
42344
42345
42346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42347   void * jresult ;
42348   Dali::ResourceImage *result = 0 ;
42349
42350   {
42351     try {
42352       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42353     } catch (std::out_of_range& e) {
42354       {
42355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42356       };
42357     } catch (std::exception& e) {
42358       {
42359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42360       };
42361     } catch (...) {
42362       {
42363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42364       };
42365     }
42366   }
42367   jresult = (void *)result;
42368   return jresult;
42369 }
42370
42371
42372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42373   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42374
42375   arg1 = (Dali::ResourceImage *)jarg1;
42376   {
42377     try {
42378       delete arg1;
42379     } catch (std::out_of_range& e) {
42380       {
42381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42382       };
42383     } catch (std::exception& e) {
42384       {
42385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42386       };
42387     } catch (...) {
42388       {
42389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42390       };
42391     }
42392   }
42393 }
42394
42395
42396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42397   void * jresult ;
42398   Dali::ResourceImage *arg1 = 0 ;
42399   Dali::ResourceImage *result = 0 ;
42400
42401   arg1 = (Dali::ResourceImage *)jarg1;
42402   if (!arg1) {
42403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42404     return 0;
42405   }
42406   {
42407     try {
42408       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42409     } catch (std::out_of_range& e) {
42410       {
42411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42412       };
42413     } catch (std::exception& e) {
42414       {
42415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42416       };
42417     } catch (...) {
42418       {
42419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42420       };
42421     }
42422   }
42423   jresult = (void *)result;
42424   return jresult;
42425 }
42426
42427
42428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42429   void * jresult ;
42430   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42431   Dali::ResourceImage *arg2 = 0 ;
42432   Dali::ResourceImage *result = 0 ;
42433
42434   arg1 = (Dali::ResourceImage *)jarg1;
42435   arg2 = (Dali::ResourceImage *)jarg2;
42436   if (!arg2) {
42437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42438     return 0;
42439   }
42440   {
42441     try {
42442       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42443     } catch (std::out_of_range& e) {
42444       {
42445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42446       };
42447     } catch (std::exception& e) {
42448       {
42449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42450       };
42451     } catch (...) {
42452       {
42453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42454       };
42455     }
42456   }
42457   jresult = (void *)result;
42458   return jresult;
42459 }
42460
42461
42462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42463   void * jresult ;
42464   std::string *arg1 = 0 ;
42465   bool arg2 ;
42466   Dali::ResourceImage result;
42467
42468   if (!jarg1) {
42469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42470     return 0;
42471   }
42472   std::string arg1_str(jarg1);
42473   arg1 = &arg1_str;
42474   arg2 = jarg2 ? true : false;
42475   {
42476     try {
42477       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42478     } catch (std::out_of_range& e) {
42479       {
42480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42481       };
42482     } catch (std::exception& e) {
42483       {
42484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42485       };
42486     } catch (...) {
42487       {
42488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42489       };
42490     }
42491   }
42492   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42493
42494   //argout typemap for const std::string&
42495
42496   return jresult;
42497 }
42498
42499
42500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42501   void * jresult ;
42502   std::string *arg1 = 0 ;
42503   Dali::ResourceImage result;
42504
42505   if (!jarg1) {
42506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42507     return 0;
42508   }
42509   std::string arg1_str(jarg1);
42510   arg1 = &arg1_str;
42511   {
42512     try {
42513       result = Dali::ResourceImage::New((std::string const &)*arg1);
42514     } catch (std::out_of_range& e) {
42515       {
42516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42517       };
42518     } catch (std::exception& e) {
42519       {
42520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42521       };
42522     } catch (...) {
42523       {
42524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42525       };
42526     }
42527   }
42528   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42529
42530   //argout typemap for const std::string&
42531
42532   return jresult;
42533 }
42534
42535
42536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42537   void * jresult ;
42538   std::string *arg1 = 0 ;
42539   Dali::ImageDimensions arg2 ;
42540   Dali::FittingMode::Type arg3 ;
42541   Dali::SamplingMode::Type arg4 ;
42542   bool arg5 ;
42543   Dali::ImageDimensions *argp2 ;
42544   Dali::ResourceImage result;
42545
42546   if (!jarg1) {
42547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42548     return 0;
42549   }
42550   std::string arg1_str(jarg1);
42551   arg1 = &arg1_str;
42552   argp2 = (Dali::ImageDimensions *)jarg2;
42553   if (!argp2) {
42554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42555     return 0;
42556   }
42557   arg2 = *argp2;
42558   arg3 = (Dali::FittingMode::Type)jarg3;
42559   arg4 = (Dali::SamplingMode::Type)jarg4;
42560   arg5 = jarg5 ? true : false;
42561   {
42562     try {
42563       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42564     } catch (std::out_of_range& e) {
42565       {
42566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42567       };
42568     } catch (std::exception& e) {
42569       {
42570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42571       };
42572     } catch (...) {
42573       {
42574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42575       };
42576     }
42577   }
42578   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42579
42580   //argout typemap for const std::string&
42581
42582   return jresult;
42583 }
42584
42585
42586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42587   void * jresult ;
42588   std::string *arg1 = 0 ;
42589   Dali::ImageDimensions arg2 ;
42590   Dali::FittingMode::Type arg3 ;
42591   Dali::SamplingMode::Type arg4 ;
42592   Dali::ImageDimensions *argp2 ;
42593   Dali::ResourceImage result;
42594
42595   if (!jarg1) {
42596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42597     return 0;
42598   }
42599   std::string arg1_str(jarg1);
42600   arg1 = &arg1_str;
42601   argp2 = (Dali::ImageDimensions *)jarg2;
42602   if (!argp2) {
42603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42604     return 0;
42605   }
42606   arg2 = *argp2;
42607   arg3 = (Dali::FittingMode::Type)jarg3;
42608   arg4 = (Dali::SamplingMode::Type)jarg4;
42609   {
42610     try {
42611       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42612     } catch (std::out_of_range& e) {
42613       {
42614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42615       };
42616     } catch (std::exception& e) {
42617       {
42618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42619       };
42620     } catch (...) {
42621       {
42622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42623       };
42624     }
42625   }
42626   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42627
42628   //argout typemap for const std::string&
42629
42630   return jresult;
42631 }
42632
42633
42634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42635   void * jresult ;
42636   std::string *arg1 = 0 ;
42637   Dali::ImageDimensions arg2 ;
42638   Dali::FittingMode::Type arg3 ;
42639   Dali::ImageDimensions *argp2 ;
42640   Dali::ResourceImage result;
42641
42642   if (!jarg1) {
42643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42644     return 0;
42645   }
42646   std::string arg1_str(jarg1);
42647   arg1 = &arg1_str;
42648   argp2 = (Dali::ImageDimensions *)jarg2;
42649   if (!argp2) {
42650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42651     return 0;
42652   }
42653   arg2 = *argp2;
42654   arg3 = (Dali::FittingMode::Type)jarg3;
42655   {
42656     try {
42657       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42658     } catch (std::out_of_range& e) {
42659       {
42660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42661       };
42662     } catch (std::exception& e) {
42663       {
42664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42665       };
42666     } catch (...) {
42667       {
42668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42669       };
42670     }
42671   }
42672   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42673
42674   //argout typemap for const std::string&
42675
42676   return jresult;
42677 }
42678
42679
42680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42681   void * jresult ;
42682   std::string *arg1 = 0 ;
42683   Dali::ImageDimensions arg2 ;
42684   Dali::ImageDimensions *argp2 ;
42685   Dali::ResourceImage result;
42686
42687   if (!jarg1) {
42688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42689     return 0;
42690   }
42691   std::string arg1_str(jarg1);
42692   arg1 = &arg1_str;
42693   argp2 = (Dali::ImageDimensions *)jarg2;
42694   if (!argp2) {
42695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42696     return 0;
42697   }
42698   arg2 = *argp2;
42699   {
42700     try {
42701       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42702     } catch (std::out_of_range& e) {
42703       {
42704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42705       };
42706     } catch (std::exception& e) {
42707       {
42708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42709       };
42710     } catch (...) {
42711       {
42712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42713       };
42714     }
42715   }
42716   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42717
42718   //argout typemap for const std::string&
42719
42720   return jresult;
42721 }
42722
42723
42724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42725   void * jresult ;
42726   Dali::BaseHandle arg1 ;
42727   Dali::BaseHandle *argp1 ;
42728   Dali::ResourceImage result;
42729
42730   argp1 = (Dali::BaseHandle *)jarg1;
42731   if (!argp1) {
42732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42733     return 0;
42734   }
42735   arg1 = *argp1;
42736   {
42737     try {
42738       result = Dali::ResourceImage::DownCast(arg1);
42739     } catch (std::out_of_range& e) {
42740       {
42741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42742       };
42743     } catch (std::exception& e) {
42744       {
42745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42746       };
42747     } catch (...) {
42748       {
42749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42750       };
42751     }
42752   }
42753   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42754   return jresult;
42755 }
42756
42757
42758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42759   int jresult ;
42760   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42761   Dali::LoadingState result;
42762
42763   arg1 = (Dali::ResourceImage *)jarg1;
42764   {
42765     try {
42766       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42767     } catch (std::out_of_range& e) {
42768       {
42769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42770       };
42771     } catch (std::exception& e) {
42772       {
42773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42774       };
42775     } catch (...) {
42776       {
42777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42778       };
42779     }
42780   }
42781   jresult = (int)result;
42782   return jresult;
42783 }
42784
42785
42786 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42787   char * jresult ;
42788   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42789   std::string result;
42790
42791   arg1 = (Dali::ResourceImage *)jarg1;
42792   {
42793     try {
42794       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42795     } catch (std::out_of_range& e) {
42796       {
42797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42798       };
42799     } catch (std::exception& e) {
42800       {
42801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42802       };
42803     } catch (...) {
42804       {
42805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42806       };
42807     }
42808   }
42809   jresult = SWIG_csharp_string_callback((&result)->c_str());
42810   return jresult;
42811 }
42812
42813
42814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42815   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42816
42817   arg1 = (Dali::ResourceImage *)jarg1;
42818   {
42819     try {
42820       (arg1)->Reload();
42821     } catch (std::out_of_range& e) {
42822       {
42823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42824       };
42825     } catch (std::exception& e) {
42826       {
42827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42828       };
42829     } catch (...) {
42830       {
42831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42832       };
42833     }
42834   }
42835 }
42836
42837
42838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
42839   void * jresult ;
42840   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42841   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
42842
42843   arg1 = (Dali::ResourceImage *)jarg1;
42844   {
42845     try {
42846       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
42847     } catch (std::out_of_range& e) {
42848       {
42849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42850       };
42851     } catch (std::exception& e) {
42852       {
42853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42854       };
42855     } catch (...) {
42856       {
42857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42858       };
42859     }
42860   }
42861   jresult = (void *)result;
42862   return jresult;
42863 }
42864
42865
42866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
42867   void * jresult ;
42868   Dali::FrameBufferImage *result = 0 ;
42869
42870   {
42871     try {
42872       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
42873     } catch (std::out_of_range& e) {
42874       {
42875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42876       };
42877     } catch (std::exception& e) {
42878       {
42879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42880       };
42881     } catch (...) {
42882       {
42883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42884       };
42885     }
42886   }
42887   jresult = (void *)result;
42888   return jresult;
42889 }
42890
42891
42892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
42893   void * jresult ;
42894   unsigned int arg1 ;
42895   unsigned int arg2 ;
42896   Dali::Pixel::Format arg3 ;
42897   Dali::RenderBuffer::Format arg4 ;
42898   Dali::FrameBufferImage result;
42899
42900   arg1 = (unsigned int)jarg1;
42901   arg2 = (unsigned int)jarg2;
42902   arg3 = (Dali::Pixel::Format)jarg3;
42903   arg4 = (Dali::RenderBuffer::Format)jarg4;
42904   {
42905     try {
42906       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
42907     } catch (std::out_of_range& e) {
42908       {
42909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42910       };
42911     } catch (std::exception& e) {
42912       {
42913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42914       };
42915     } catch (...) {
42916       {
42917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42918       };
42919     }
42920   }
42921   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42922   return jresult;
42923 }
42924
42925
42926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
42927   void * jresult ;
42928   unsigned int arg1 ;
42929   unsigned int arg2 ;
42930   Dali::Pixel::Format arg3 ;
42931   Dali::FrameBufferImage result;
42932
42933   arg1 = (unsigned int)jarg1;
42934   arg2 = (unsigned int)jarg2;
42935   arg3 = (Dali::Pixel::Format)jarg3;
42936   {
42937     try {
42938       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
42939     } catch (std::out_of_range& e) {
42940       {
42941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42942       };
42943     } catch (std::exception& e) {
42944       {
42945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42946       };
42947     } catch (...) {
42948       {
42949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42950       };
42951     }
42952   }
42953   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42954   return jresult;
42955 }
42956
42957
42958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
42959   void * jresult ;
42960   unsigned int arg1 ;
42961   unsigned int arg2 ;
42962   Dali::FrameBufferImage result;
42963
42964   arg1 = (unsigned int)jarg1;
42965   arg2 = (unsigned int)jarg2;
42966   {
42967     try {
42968       result = Dali::FrameBufferImage::New(arg1,arg2);
42969     } catch (std::out_of_range& e) {
42970       {
42971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42972       };
42973     } catch (std::exception& e) {
42974       {
42975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42976       };
42977     } catch (...) {
42978       {
42979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42980       };
42981     }
42982   }
42983   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42984   return jresult;
42985 }
42986
42987
42988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
42989   void * jresult ;
42990   unsigned int arg1 ;
42991   Dali::FrameBufferImage result;
42992
42993   arg1 = (unsigned int)jarg1;
42994   {
42995     try {
42996       result = Dali::FrameBufferImage::New(arg1);
42997     } catch (std::out_of_range& e) {
42998       {
42999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43000       };
43001     } catch (std::exception& e) {
43002       {
43003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43004       };
43005     } catch (...) {
43006       {
43007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43008       };
43009     }
43010   }
43011   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43012   return jresult;
43013 }
43014
43015
43016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43017   void * jresult ;
43018   Dali::FrameBufferImage result;
43019
43020   {
43021     try {
43022       result = Dali::FrameBufferImage::New();
43023     } catch (std::out_of_range& e) {
43024       {
43025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43026       };
43027     } catch (std::exception& e) {
43028       {
43029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43030       };
43031     } catch (...) {
43032       {
43033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43034       };
43035     }
43036   }
43037   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43038   return jresult;
43039 }
43040
43041
43042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43043   void * jresult ;
43044   Dali::NativeImageInterface *arg1 = 0 ;
43045   Dali::FrameBufferImage result;
43046
43047   arg1 = (Dali::NativeImageInterface *)jarg1;
43048   if (!arg1) {
43049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43050     return 0;
43051   }
43052   {
43053     try {
43054       result = Dali::FrameBufferImage::New(*arg1);
43055     } catch (std::out_of_range& e) {
43056       {
43057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43058       };
43059     } catch (std::exception& e) {
43060       {
43061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43062       };
43063     } catch (...) {
43064       {
43065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43066       };
43067     }
43068   }
43069   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43070   return jresult;
43071 }
43072
43073
43074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43075   void * jresult ;
43076   Dali::BaseHandle arg1 ;
43077   Dali::BaseHandle *argp1 ;
43078   Dali::FrameBufferImage result;
43079
43080   argp1 = (Dali::BaseHandle *)jarg1;
43081   if (!argp1) {
43082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43083     return 0;
43084   }
43085   arg1 = *argp1;
43086   {
43087     try {
43088       result = Dali::FrameBufferImage::DownCast(arg1);
43089     } catch (std::out_of_range& e) {
43090       {
43091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43092       };
43093     } catch (std::exception& e) {
43094       {
43095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43096       };
43097     } catch (...) {
43098       {
43099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43100       };
43101     }
43102   }
43103   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43104   return jresult;
43105 }
43106
43107
43108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43109   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43110
43111   arg1 = (Dali::FrameBufferImage *)jarg1;
43112   {
43113     try {
43114       delete arg1;
43115     } catch (std::out_of_range& e) {
43116       {
43117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43118       };
43119     } catch (std::exception& e) {
43120       {
43121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43122       };
43123     } catch (...) {
43124       {
43125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43126       };
43127     }
43128   }
43129 }
43130
43131
43132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43133   void * jresult ;
43134   Dali::FrameBufferImage *arg1 = 0 ;
43135   Dali::FrameBufferImage *result = 0 ;
43136
43137   arg1 = (Dali::FrameBufferImage *)jarg1;
43138   if (!arg1) {
43139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43140     return 0;
43141   }
43142   {
43143     try {
43144       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43145     } catch (std::out_of_range& e) {
43146       {
43147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43148       };
43149     } catch (std::exception& e) {
43150       {
43151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43152       };
43153     } catch (...) {
43154       {
43155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43156       };
43157     }
43158   }
43159   jresult = (void *)result;
43160   return jresult;
43161 }
43162
43163
43164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43165   void * jresult ;
43166   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43167   Dali::FrameBufferImage *arg2 = 0 ;
43168   Dali::FrameBufferImage *result = 0 ;
43169
43170   arg1 = (Dali::FrameBufferImage *)jarg1;
43171   arg2 = (Dali::FrameBufferImage *)jarg2;
43172   if (!arg2) {
43173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43174     return 0;
43175   }
43176   {
43177     try {
43178       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43179     } catch (std::out_of_range& e) {
43180       {
43181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43182       };
43183     } catch (std::exception& e) {
43184       {
43185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43186       };
43187     } catch (...) {
43188       {
43189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43190       };
43191     }
43192   }
43193   jresult = (void *)result;
43194   return jresult;
43195 }
43196
43197
43198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43199   void * jresult ;
43200   Dali::NinePatchImage *result = 0 ;
43201
43202   {
43203     try {
43204       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43205     } catch (std::out_of_range& e) {
43206       {
43207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43208       };
43209     } catch (std::exception& e) {
43210       {
43211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43212       };
43213     } catch (...) {
43214       {
43215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43216       };
43217     }
43218   }
43219   jresult = (void *)result;
43220   return jresult;
43221 }
43222
43223
43224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43225   void * jresult ;
43226   std::string *arg1 = 0 ;
43227   Dali::NinePatchImage result;
43228
43229   if (!jarg1) {
43230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43231     return 0;
43232   }
43233   std::string arg1_str(jarg1);
43234   arg1 = &arg1_str;
43235   {
43236     try {
43237       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43238     } catch (std::out_of_range& e) {
43239       {
43240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43241       };
43242     } catch (std::exception& e) {
43243       {
43244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43245       };
43246     } catch (...) {
43247       {
43248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43249       };
43250     }
43251   }
43252   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43253
43254   //argout typemap for const std::string&
43255
43256   return jresult;
43257 }
43258
43259
43260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43261   void * jresult ;
43262   Dali::BaseHandle arg1 ;
43263   Dali::BaseHandle *argp1 ;
43264   Dali::NinePatchImage result;
43265
43266   argp1 = (Dali::BaseHandle *)jarg1;
43267   if (!argp1) {
43268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43269     return 0;
43270   }
43271   arg1 = *argp1;
43272   {
43273     try {
43274       result = Dali::NinePatchImage::DownCast(arg1);
43275     } catch (std::out_of_range& e) {
43276       {
43277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43278       };
43279     } catch (std::exception& e) {
43280       {
43281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43282       };
43283     } catch (...) {
43284       {
43285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43286       };
43287     }
43288   }
43289   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43290   return jresult;
43291 }
43292
43293
43294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43295   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43296
43297   arg1 = (Dali::NinePatchImage *)jarg1;
43298   {
43299     try {
43300       delete arg1;
43301     } catch (std::out_of_range& e) {
43302       {
43303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43304       };
43305     } catch (std::exception& e) {
43306       {
43307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43308       };
43309     } catch (...) {
43310       {
43311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43312       };
43313     }
43314   }
43315 }
43316
43317
43318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43319   void * jresult ;
43320   Dali::NinePatchImage *arg1 = 0 ;
43321   Dali::NinePatchImage *result = 0 ;
43322
43323   arg1 = (Dali::NinePatchImage *)jarg1;
43324   if (!arg1) {
43325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43326     return 0;
43327   }
43328   {
43329     try {
43330       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43331     } catch (std::out_of_range& e) {
43332       {
43333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43334       };
43335     } catch (std::exception& e) {
43336       {
43337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43338       };
43339     } catch (...) {
43340       {
43341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43342       };
43343     }
43344   }
43345   jresult = (void *)result;
43346   return jresult;
43347 }
43348
43349
43350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43351   void * jresult ;
43352   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43353   Dali::NinePatchImage *arg2 = 0 ;
43354   Dali::NinePatchImage *result = 0 ;
43355
43356   arg1 = (Dali::NinePatchImage *)jarg1;
43357   arg2 = (Dali::NinePatchImage *)jarg2;
43358   if (!arg2) {
43359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43360     return 0;
43361   }
43362   {
43363     try {
43364       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43365     } catch (std::out_of_range& e) {
43366       {
43367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43368       };
43369     } catch (std::exception& e) {
43370       {
43371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43372       };
43373     } catch (...) {
43374       {
43375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43376       };
43377     }
43378   }
43379   jresult = (void *)result;
43380   return jresult;
43381 }
43382
43383
43384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43385   void * jresult ;
43386   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43387   Dali::Vector4 result;
43388
43389   arg1 = (Dali::NinePatchImage *)jarg1;
43390   {
43391     try {
43392       result = (arg1)->GetStretchBorders();
43393     } catch (std::out_of_range& e) {
43394       {
43395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43396       };
43397     } catch (std::exception& e) {
43398       {
43399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43400       };
43401     } catch (...) {
43402       {
43403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43404       };
43405     }
43406   }
43407   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43408   return jresult;
43409 }
43410
43411
43412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43413   void * jresult ;
43414   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43415   Dali::NinePatchImage::StretchRanges *result = 0 ;
43416
43417   arg1 = (Dali::NinePatchImage *)jarg1;
43418   {
43419     try {
43420       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43421     } catch (std::out_of_range& e) {
43422       {
43423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43424       };
43425     } catch (std::exception& e) {
43426       {
43427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43428       };
43429     } catch (...) {
43430       {
43431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43432       };
43433     }
43434   }
43435   jresult = (void *)result;
43436   return jresult;
43437 }
43438
43439
43440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43441   void * jresult ;
43442   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43443   Dali::NinePatchImage::StretchRanges *result = 0 ;
43444
43445   arg1 = (Dali::NinePatchImage *)jarg1;
43446   {
43447     try {
43448       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43449     } catch (std::out_of_range& e) {
43450       {
43451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43452       };
43453     } catch (std::exception& e) {
43454       {
43455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43456       };
43457     } catch (...) {
43458       {
43459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43460       };
43461     }
43462   }
43463   jresult = (void *)result;
43464   return jresult;
43465 }
43466
43467
43468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43469   void * jresult ;
43470   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43471   Dali::Rect< int > result;
43472
43473   arg1 = (Dali::NinePatchImage *)jarg1;
43474   {
43475     try {
43476       result = (arg1)->GetChildRectangle();
43477     } catch (std::out_of_range& e) {
43478       {
43479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43480       };
43481     } catch (std::exception& e) {
43482       {
43483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43484       };
43485     } catch (...) {
43486       {
43487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43488       };
43489     }
43490   }
43491   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43492   return jresult;
43493 }
43494
43495
43496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43497   void * jresult ;
43498   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43499   Dali::BufferImage result;
43500
43501   arg1 = (Dali::NinePatchImage *)jarg1;
43502   {
43503     try {
43504       result = (arg1)->CreateCroppedBufferImage();
43505     } catch (std::out_of_range& e) {
43506       {
43507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43508       };
43509     } catch (std::exception& e) {
43510       {
43511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43512       };
43513     } catch (...) {
43514       {
43515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43516       };
43517     }
43518   }
43519   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43520   return jresult;
43521 }
43522
43523
43524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43525   unsigned int jresult ;
43526   std::string *arg1 = 0 ;
43527   bool result;
43528
43529   if (!jarg1) {
43530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43531     return 0;
43532   }
43533   std::string arg1_str(jarg1);
43534   arg1 = &arg1_str;
43535   {
43536     try {
43537       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43538     } catch (std::out_of_range& e) {
43539       {
43540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43541       };
43542     } catch (std::exception& e) {
43543       {
43544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43545       };
43546     } catch (...) {
43547       {
43548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43549       };
43550     }
43551   }
43552   jresult = result;
43553
43554   //argout typemap for const std::string&
43555
43556   return jresult;
43557 }
43558
43559
43560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43561   int jresult ;
43562   int result;
43563
43564   result = (int)Dali::CameraActor::Property::TYPE;
43565   jresult = (int)result;
43566   return jresult;
43567 }
43568
43569
43570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43571   int jresult ;
43572   int result;
43573
43574   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43575   jresult = (int)result;
43576   return jresult;
43577 }
43578
43579
43580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43581   int jresult ;
43582   int result;
43583
43584   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43585   jresult = (int)result;
43586   return jresult;
43587 }
43588
43589
43590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43591   int jresult ;
43592   int result;
43593
43594   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43595   jresult = (int)result;
43596   return jresult;
43597 }
43598
43599
43600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43601   int jresult ;
43602   int result;
43603
43604   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43605   jresult = (int)result;
43606   return jresult;
43607 }
43608
43609
43610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43611   int jresult ;
43612   int result;
43613
43614   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43615   jresult = (int)result;
43616   return jresult;
43617 }
43618
43619
43620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43621   int jresult ;
43622   int result;
43623
43624   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43625   jresult = (int)result;
43626   return jresult;
43627 }
43628
43629
43630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43631   int jresult ;
43632   int result;
43633
43634   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43635   jresult = (int)result;
43636   return jresult;
43637 }
43638
43639
43640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43641   int jresult ;
43642   int result;
43643
43644   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43645   jresult = (int)result;
43646   return jresult;
43647 }
43648
43649
43650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43651   int jresult ;
43652   int result;
43653
43654   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43655   jresult = (int)result;
43656   return jresult;
43657 }
43658
43659
43660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43661   int jresult ;
43662   int result;
43663
43664   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43665   jresult = (int)result;
43666   return jresult;
43667 }
43668
43669
43670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43671   int jresult ;
43672   int result;
43673
43674   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43675   jresult = (int)result;
43676   return jresult;
43677 }
43678
43679
43680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43681   int jresult ;
43682   int result;
43683
43684   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43685   jresult = (int)result;
43686   return jresult;
43687 }
43688
43689
43690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43691   int jresult ;
43692   int result;
43693
43694   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43695   jresult = (int)result;
43696   return jresult;
43697 }
43698
43699
43700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43701   void * jresult ;
43702   Dali::CameraActor::Property *result = 0 ;
43703
43704   {
43705     try {
43706       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43707     } catch (std::out_of_range& e) {
43708       {
43709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43710       };
43711     } catch (std::exception& e) {
43712       {
43713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43714       };
43715     } catch (...) {
43716       {
43717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43718       };
43719     }
43720   }
43721   jresult = (void *)result;
43722   return jresult;
43723 }
43724
43725
43726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43727   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43728
43729   arg1 = (Dali::CameraActor::Property *)jarg1;
43730   {
43731     try {
43732       delete arg1;
43733     } catch (std::out_of_range& e) {
43734       {
43735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43736       };
43737     } catch (std::exception& e) {
43738       {
43739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43740       };
43741     } catch (...) {
43742       {
43743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43744       };
43745     }
43746   }
43747 }
43748
43749
43750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43751   void * jresult ;
43752   Dali::CameraActor *result = 0 ;
43753
43754   {
43755     try {
43756       result = (Dali::CameraActor *)new Dali::CameraActor();
43757     } catch (std::out_of_range& e) {
43758       {
43759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43760       };
43761     } catch (std::exception& e) {
43762       {
43763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43764       };
43765     } catch (...) {
43766       {
43767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43768       };
43769     }
43770   }
43771   jresult = (void *)result;
43772   return jresult;
43773 }
43774
43775
43776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43777   void * jresult ;
43778   Dali::CameraActor result;
43779
43780   {
43781     try {
43782       result = Dali::CameraActor::New();
43783     } catch (std::out_of_range& e) {
43784       {
43785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43786       };
43787     } catch (std::exception& e) {
43788       {
43789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43790       };
43791     } catch (...) {
43792       {
43793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43794       };
43795     }
43796   }
43797   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43798   return jresult;
43799 }
43800
43801
43802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43803   void * jresult ;
43804   Dali::Size *arg1 = 0 ;
43805   Dali::CameraActor result;
43806
43807   arg1 = (Dali::Size *)jarg1;
43808   if (!arg1) {
43809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43810     return 0;
43811   }
43812   {
43813     try {
43814       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43815     } catch (std::out_of_range& e) {
43816       {
43817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43818       };
43819     } catch (std::exception& e) {
43820       {
43821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43822       };
43823     } catch (...) {
43824       {
43825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43826       };
43827     }
43828   }
43829   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43830   return jresult;
43831 }
43832
43833
43834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
43835   void * jresult ;
43836   Dali::BaseHandle arg1 ;
43837   Dali::BaseHandle *argp1 ;
43838   Dali::CameraActor result;
43839
43840   argp1 = (Dali::BaseHandle *)jarg1;
43841   if (!argp1) {
43842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43843     return 0;
43844   }
43845   arg1 = *argp1;
43846   {
43847     try {
43848       result = Dali::CameraActor::DownCast(arg1);
43849     } catch (std::out_of_range& e) {
43850       {
43851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43852       };
43853     } catch (std::exception& e) {
43854       {
43855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43856       };
43857     } catch (...) {
43858       {
43859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43860       };
43861     }
43862   }
43863   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43864   return jresult;
43865 }
43866
43867
43868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
43869   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43870
43871   arg1 = (Dali::CameraActor *)jarg1;
43872   {
43873     try {
43874       delete arg1;
43875     } catch (std::out_of_range& e) {
43876       {
43877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43878       };
43879     } catch (std::exception& e) {
43880       {
43881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43882       };
43883     } catch (...) {
43884       {
43885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43886       };
43887     }
43888   }
43889 }
43890
43891
43892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
43893   void * jresult ;
43894   Dali::CameraActor *arg1 = 0 ;
43895   Dali::CameraActor *result = 0 ;
43896
43897   arg1 = (Dali::CameraActor *)jarg1;
43898   if (!arg1) {
43899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43900     return 0;
43901   }
43902   {
43903     try {
43904       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
43905     } catch (std::out_of_range& e) {
43906       {
43907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43908       };
43909     } catch (std::exception& e) {
43910       {
43911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43912       };
43913     } catch (...) {
43914       {
43915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43916       };
43917     }
43918   }
43919   jresult = (void *)result;
43920   return jresult;
43921 }
43922
43923
43924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
43925   void * jresult ;
43926   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43927   Dali::CameraActor *arg2 = 0 ;
43928   Dali::CameraActor *result = 0 ;
43929
43930   arg1 = (Dali::CameraActor *)jarg1;
43931   arg2 = (Dali::CameraActor *)jarg2;
43932   if (!arg2) {
43933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43934     return 0;
43935   }
43936   {
43937     try {
43938       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
43939     } catch (std::out_of_range& e) {
43940       {
43941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43942       };
43943     } catch (std::exception& e) {
43944       {
43945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43946       };
43947     } catch (...) {
43948       {
43949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43950       };
43951     }
43952   }
43953   jresult = (void *)result;
43954   return jresult;
43955 }
43956
43957
43958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
43959   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43960   Dali::Camera::Type arg2 ;
43961
43962   arg1 = (Dali::CameraActor *)jarg1;
43963   arg2 = (Dali::Camera::Type)jarg2;
43964   {
43965     try {
43966       (arg1)->SetType(arg2);
43967     } catch (std::out_of_range& e) {
43968       {
43969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43970       };
43971     } catch (std::exception& e) {
43972       {
43973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43974       };
43975     } catch (...) {
43976       {
43977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43978       };
43979     }
43980   }
43981 }
43982
43983
43984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
43985   int jresult ;
43986   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43987   Dali::Camera::Type result;
43988
43989   arg1 = (Dali::CameraActor *)jarg1;
43990   {
43991     try {
43992       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
43993     } catch (std::out_of_range& e) {
43994       {
43995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43996       };
43997     } catch (std::exception& e) {
43998       {
43999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44000       };
44001     } catch (...) {
44002       {
44003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44004       };
44005     }
44006   }
44007   jresult = (int)result;
44008   return jresult;
44009 }
44010
44011
44012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44013   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44014   Dali::Camera::ProjectionMode arg2 ;
44015
44016   arg1 = (Dali::CameraActor *)jarg1;
44017   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44018   {
44019     try {
44020       (arg1)->SetProjectionMode(arg2);
44021     } catch (std::out_of_range& e) {
44022       {
44023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44024       };
44025     } catch (std::exception& e) {
44026       {
44027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44028       };
44029     } catch (...) {
44030       {
44031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44032       };
44033     }
44034   }
44035 }
44036
44037
44038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44039   int jresult ;
44040   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44041   Dali::Camera::ProjectionMode result;
44042
44043   arg1 = (Dali::CameraActor *)jarg1;
44044   {
44045     try {
44046       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44047     } catch (std::out_of_range& e) {
44048       {
44049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44050       };
44051     } catch (std::exception& e) {
44052       {
44053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44054       };
44055     } catch (...) {
44056       {
44057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44058       };
44059     }
44060   }
44061   jresult = (int)result;
44062   return jresult;
44063 }
44064
44065
44066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44067   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44068   float arg2 ;
44069
44070   arg1 = (Dali::CameraActor *)jarg1;
44071   arg2 = (float)jarg2;
44072   {
44073     try {
44074       (arg1)->SetFieldOfView(arg2);
44075     } catch (std::out_of_range& e) {
44076       {
44077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44078       };
44079     } catch (std::exception& e) {
44080       {
44081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44082       };
44083     } catch (...) {
44084       {
44085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44086       };
44087     }
44088   }
44089 }
44090
44091
44092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44093   float jresult ;
44094   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44095   float result;
44096
44097   arg1 = (Dali::CameraActor *)jarg1;
44098   {
44099     try {
44100       result = (float)(arg1)->GetFieldOfView();
44101     } catch (std::out_of_range& e) {
44102       {
44103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44104       };
44105     } catch (std::exception& e) {
44106       {
44107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44108       };
44109     } catch (...) {
44110       {
44111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44112       };
44113     }
44114   }
44115   jresult = result;
44116   return jresult;
44117 }
44118
44119
44120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44121   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44122   float arg2 ;
44123
44124   arg1 = (Dali::CameraActor *)jarg1;
44125   arg2 = (float)jarg2;
44126   {
44127     try {
44128       (arg1)->SetAspectRatio(arg2);
44129     } catch (std::out_of_range& e) {
44130       {
44131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44132       };
44133     } catch (std::exception& e) {
44134       {
44135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44136       };
44137     } catch (...) {
44138       {
44139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44140       };
44141     }
44142   }
44143 }
44144
44145
44146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44147   float jresult ;
44148   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44149   float result;
44150
44151   arg1 = (Dali::CameraActor *)jarg1;
44152   {
44153     try {
44154       result = (float)(arg1)->GetAspectRatio();
44155     } catch (std::out_of_range& e) {
44156       {
44157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44158       };
44159     } catch (std::exception& e) {
44160       {
44161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44162       };
44163     } catch (...) {
44164       {
44165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44166       };
44167     }
44168   }
44169   jresult = result;
44170   return jresult;
44171 }
44172
44173
44174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44175   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44176   float arg2 ;
44177
44178   arg1 = (Dali::CameraActor *)jarg1;
44179   arg2 = (float)jarg2;
44180   {
44181     try {
44182       (arg1)->SetNearClippingPlane(arg2);
44183     } catch (std::out_of_range& e) {
44184       {
44185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44186       };
44187     } catch (std::exception& e) {
44188       {
44189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44190       };
44191     } catch (...) {
44192       {
44193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44194       };
44195     }
44196   }
44197 }
44198
44199
44200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44201   float jresult ;
44202   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44203   float result;
44204
44205   arg1 = (Dali::CameraActor *)jarg1;
44206   {
44207     try {
44208       result = (float)(arg1)->GetNearClippingPlane();
44209     } catch (std::out_of_range& e) {
44210       {
44211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44212       };
44213     } catch (std::exception& e) {
44214       {
44215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44216       };
44217     } catch (...) {
44218       {
44219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44220       };
44221     }
44222   }
44223   jresult = result;
44224   return jresult;
44225 }
44226
44227
44228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44229   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44230   float arg2 ;
44231
44232   arg1 = (Dali::CameraActor *)jarg1;
44233   arg2 = (float)jarg2;
44234   {
44235     try {
44236       (arg1)->SetFarClippingPlane(arg2);
44237     } catch (std::out_of_range& e) {
44238       {
44239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44240       };
44241     } catch (std::exception& e) {
44242       {
44243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44244       };
44245     } catch (...) {
44246       {
44247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44248       };
44249     }
44250   }
44251 }
44252
44253
44254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44255   float jresult ;
44256   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44257   float result;
44258
44259   arg1 = (Dali::CameraActor *)jarg1;
44260   {
44261     try {
44262       result = (float)(arg1)->GetFarClippingPlane();
44263     } catch (std::out_of_range& e) {
44264       {
44265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44266       };
44267     } catch (std::exception& e) {
44268       {
44269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44270       };
44271     } catch (...) {
44272       {
44273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44274       };
44275     }
44276   }
44277   jresult = result;
44278   return jresult;
44279 }
44280
44281
44282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44283   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44284   Dali::Vector3 *arg2 = 0 ;
44285
44286   arg1 = (Dali::CameraActor *)jarg1;
44287   arg2 = (Dali::Vector3 *)jarg2;
44288   if (!arg2) {
44289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44290     return ;
44291   }
44292   {
44293     try {
44294       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44295     } catch (std::out_of_range& e) {
44296       {
44297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44298       };
44299     } catch (std::exception& e) {
44300       {
44301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44302       };
44303     } catch (...) {
44304       {
44305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44306       };
44307     }
44308   }
44309 }
44310
44311
44312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44313   void * jresult ;
44314   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44315   Dali::Vector3 result;
44316
44317   arg1 = (Dali::CameraActor *)jarg1;
44318   {
44319     try {
44320       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44321     } catch (std::out_of_range& e) {
44322       {
44323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44324       };
44325     } catch (std::exception& e) {
44326       {
44327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44328       };
44329     } catch (...) {
44330       {
44331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44332       };
44333     }
44334   }
44335   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44336   return jresult;
44337 }
44338
44339
44340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44341   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44342   bool arg2 ;
44343
44344   arg1 = (Dali::CameraActor *)jarg1;
44345   arg2 = jarg2 ? true : false;
44346   {
44347     try {
44348       (arg1)->SetInvertYAxis(arg2);
44349     } catch (std::out_of_range& e) {
44350       {
44351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44352       };
44353     } catch (std::exception& e) {
44354       {
44355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44356       };
44357     } catch (...) {
44358       {
44359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44360       };
44361     }
44362   }
44363 }
44364
44365
44366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44367   unsigned int jresult ;
44368   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44369   bool result;
44370
44371   arg1 = (Dali::CameraActor *)jarg1;
44372   {
44373     try {
44374       result = (bool)(arg1)->GetInvertYAxis();
44375     } catch (std::out_of_range& e) {
44376       {
44377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44378       };
44379     } catch (std::exception& e) {
44380       {
44381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44382       };
44383     } catch (...) {
44384       {
44385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44386       };
44387     }
44388   }
44389   jresult = result;
44390   return jresult;
44391 }
44392
44393
44394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44395   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44396   Dali::Size *arg2 = 0 ;
44397
44398   arg1 = (Dali::CameraActor *)jarg1;
44399   arg2 = (Dali::Size *)jarg2;
44400   if (!arg2) {
44401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44402     return ;
44403   }
44404   {
44405     try {
44406       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44407     } catch (std::out_of_range& e) {
44408       {
44409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44410       };
44411     } catch (std::exception& e) {
44412       {
44413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44414       };
44415     } catch (...) {
44416       {
44417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44418       };
44419     }
44420   }
44421 }
44422
44423
44424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44425   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44426   Dali::Size *arg2 = 0 ;
44427
44428   arg1 = (Dali::CameraActor *)jarg1;
44429   arg2 = (Dali::Size *)jarg2;
44430   if (!arg2) {
44431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44432     return ;
44433   }
44434   {
44435     try {
44436       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44437     } catch (std::out_of_range& e) {
44438       {
44439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44440       };
44441     } catch (std::exception& e) {
44442       {
44443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44444       };
44445     } catch (...) {
44446       {
44447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44448       };
44449     }
44450   }
44451 }
44452
44453
44454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44455   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44456   float arg2 ;
44457   float arg3 ;
44458   float arg4 ;
44459   float arg5 ;
44460   float arg6 ;
44461   float arg7 ;
44462
44463   arg1 = (Dali::CameraActor *)jarg1;
44464   arg2 = (float)jarg2;
44465   arg3 = (float)jarg3;
44466   arg4 = (float)jarg4;
44467   arg5 = (float)jarg5;
44468   arg6 = (float)jarg6;
44469   arg7 = (float)jarg7;
44470   {
44471     try {
44472       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44473     } catch (std::out_of_range& e) {
44474       {
44475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44476       };
44477     } catch (std::exception& e) {
44478       {
44479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44480       };
44481     } catch (...) {
44482       {
44483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44484       };
44485     }
44486   }
44487 }
44488
44489
44490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44491   void * jresult ;
44492   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44493
44494   {
44495     try {
44496       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44497     } catch (std::out_of_range& e) {
44498       {
44499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44500       };
44501     } catch (std::exception& e) {
44502       {
44503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44504       };
44505     } catch (...) {
44506       {
44507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44508       };
44509     }
44510   }
44511   jresult = (void *)result;
44512   return jresult;
44513 }
44514
44515
44516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44517   void * jresult ;
44518   std::string arg1 ;
44519   Dali::Property::Value arg2 ;
44520   Dali::Property::Value *argp2 ;
44521   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44522
44523   if (!jarg1) {
44524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44525     return 0;
44526   }
44527   (&arg1)->assign(jarg1);
44528   argp2 = (Dali::Property::Value *)jarg2;
44529   if (!argp2) {
44530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44531     return 0;
44532   }
44533   arg2 = *argp2;
44534   {
44535     try {
44536       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44537     } catch (std::out_of_range& e) {
44538       {
44539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44540       };
44541     } catch (std::exception& e) {
44542       {
44543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44544       };
44545     } catch (...) {
44546       {
44547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44548       };
44549     }
44550   }
44551   jresult = (void *)result;
44552   return jresult;
44553 }
44554
44555
44556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44557   void * jresult ;
44558   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44559   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44560
44561   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44562   if (!arg1) {
44563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44564     return 0;
44565   }
44566   {
44567     try {
44568       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);
44569     } catch (std::out_of_range& e) {
44570       {
44571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44572       };
44573     } catch (std::exception& e) {
44574       {
44575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44576       };
44577     } catch (...) {
44578       {
44579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44580       };
44581     }
44582   }
44583   jresult = (void *)result;
44584   return jresult;
44585 }
44586
44587
44588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44589   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44590   std::string *arg2 = 0 ;
44591
44592   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44593   if (!jarg2) {
44594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44595     return ;
44596   }
44597   std::string arg2_str(jarg2);
44598   arg2 = &arg2_str;
44599   if (arg1) (arg1)->first = *arg2;
44600
44601   //argout typemap for const std::string&
44602
44603 }
44604
44605
44606 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44607   char * jresult ;
44608   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44609   std::string *result = 0 ;
44610
44611   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44612   result = (std::string *) & ((arg1)->first);
44613   jresult = SWIG_csharp_string_callback(result->c_str());
44614   return jresult;
44615 }
44616
44617
44618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44619   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44620   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44621
44622   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44623   arg2 = (Dali::Property::Value *)jarg2;
44624   if (arg1) (arg1)->second = *arg2;
44625 }
44626
44627
44628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44629   void * jresult ;
44630   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44631   Dali::Property::Value *result = 0 ;
44632
44633   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44634   result = (Dali::Property::Value *)& ((arg1)->second);
44635   jresult = (void *)result;
44636   return jresult;
44637 }
44638
44639
44640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44641   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44642
44643   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44644   {
44645     try {
44646       delete arg1;
44647     } catch (std::out_of_range& e) {
44648       {
44649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44650       };
44651     } catch (std::exception& e) {
44652       {
44653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44654       };
44655     } catch (...) {
44656       {
44657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44658       };
44659     }
44660   }
44661 }
44662
44663
44664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44665   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44666
44667   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44668   {
44669     try {
44670       (arg1)->clear();
44671     } catch (std::out_of_range& e) {
44672       {
44673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44674       };
44675     } catch (std::exception& e) {
44676       {
44677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44678       };
44679     } catch (...) {
44680       {
44681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44682       };
44683     }
44684   }
44685 }
44686
44687
44688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44689   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44690   Dali::TouchPoint *arg2 = 0 ;
44691
44692   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44693   arg2 = (Dali::TouchPoint *)jarg2;
44694   if (!arg2) {
44695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44696     return ;
44697   }
44698   {
44699     try {
44700       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44701     } catch (std::out_of_range& e) {
44702       {
44703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44704       };
44705     } catch (std::exception& e) {
44706       {
44707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44708       };
44709     } catch (...) {
44710       {
44711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44712       };
44713     }
44714   }
44715 }
44716
44717
44718 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44719   unsigned long jresult ;
44720   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44721   std::vector< Dali::TouchPoint >::size_type result;
44722
44723   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44724   {
44725     try {
44726       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44727     } catch (std::out_of_range& e) {
44728       {
44729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44730       };
44731     } catch (std::exception& e) {
44732       {
44733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44734       };
44735     } catch (...) {
44736       {
44737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44738       };
44739     }
44740   }
44741   jresult = (unsigned long)result;
44742   return jresult;
44743 }
44744
44745
44746 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44747   unsigned long jresult ;
44748   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44749   std::vector< Dali::TouchPoint >::size_type result;
44750
44751   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44752   {
44753     try {
44754       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44755     } catch (std::out_of_range& e) {
44756       {
44757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44758       };
44759     } catch (std::exception& e) {
44760       {
44761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44762       };
44763     } catch (...) {
44764       {
44765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44766       };
44767     }
44768   }
44769   jresult = (unsigned long)result;
44770   return jresult;
44771 }
44772
44773
44774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44775   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44776   std::vector< Dali::TouchPoint >::size_type arg2 ;
44777
44778   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44779   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44780   {
44781     try {
44782       (arg1)->reserve(arg2);
44783     } catch (std::out_of_range& e) {
44784       {
44785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44786       };
44787     } catch (std::exception& e) {
44788       {
44789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44790       };
44791     } catch (...) {
44792       {
44793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44794       };
44795     }
44796   }
44797 }
44798
44799
44800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44801   void * jresult ;
44802   std::vector< Dali::TouchPoint > *result = 0 ;
44803
44804   {
44805     try {
44806       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44807     } catch (std::out_of_range& e) {
44808       {
44809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44810       };
44811     } catch (std::exception& e) {
44812       {
44813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44814       };
44815     } catch (...) {
44816       {
44817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44818       };
44819     }
44820   }
44821   jresult = (void *)result;
44822   return jresult;
44823 }
44824
44825
44826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
44827   void * jresult ;
44828   std::vector< Dali::TouchPoint > *arg1 = 0 ;
44829   std::vector< Dali::TouchPoint > *result = 0 ;
44830
44831   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44832   if (!arg1) {
44833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44834     return 0;
44835   }
44836   {
44837     try {
44838       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
44839     } catch (std::out_of_range& e) {
44840       {
44841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44842       };
44843     } catch (std::exception& e) {
44844       {
44845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44846       };
44847     } catch (...) {
44848       {
44849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44850       };
44851     }
44852   }
44853   jresult = (void *)result;
44854   return jresult;
44855 }
44856
44857
44858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
44859   void * jresult ;
44860   int arg1 ;
44861   std::vector< Dali::TouchPoint > *result = 0 ;
44862
44863   arg1 = (int)jarg1;
44864   {
44865     try {
44866       try {
44867         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
44868       }
44869       catch(std::out_of_range &_e) {
44870         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44871         return 0;
44872       }
44873
44874     } catch (std::out_of_range& e) {
44875       {
44876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44877       };
44878     } catch (std::exception& e) {
44879       {
44880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44881       };
44882     } catch (...) {
44883       {
44884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44885       };
44886     }
44887   }
44888   jresult = (void *)result;
44889   return jresult;
44890 }
44891
44892
44893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
44894   void * jresult ;
44895   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44896   int arg2 ;
44897   SwigValueWrapper< Dali::TouchPoint > result;
44898
44899   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44900   arg2 = (int)jarg2;
44901   {
44902     try {
44903       try {
44904         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
44905       }
44906       catch(std::out_of_range &_e) {
44907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44908         return 0;
44909       }
44910
44911     } catch (std::out_of_range& e) {
44912       {
44913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44914       };
44915     } catch (std::exception& e) {
44916       {
44917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44918       };
44919     } catch (...) {
44920       {
44921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44922       };
44923     }
44924   }
44925   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
44926   return jresult;
44927 }
44928
44929
44930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
44931   void * jresult ;
44932   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44933   int arg2 ;
44934   Dali::TouchPoint *result = 0 ;
44935
44936   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44937   arg2 = (int)jarg2;
44938   {
44939     try {
44940       try {
44941         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
44942       }
44943       catch(std::out_of_range &_e) {
44944         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44945         return 0;
44946       }
44947
44948     } catch (std::out_of_range& e) {
44949       {
44950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44951       };
44952     } catch (std::exception& e) {
44953       {
44954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44955       };
44956     } catch (...) {
44957       {
44958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44959       };
44960     }
44961   }
44962   jresult = (void *)result;
44963   return jresult;
44964 }
44965
44966
44967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
44968   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44969   int arg2 ;
44970   Dali::TouchPoint *arg3 = 0 ;
44971
44972   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44973   arg2 = (int)jarg2;
44974   arg3 = (Dali::TouchPoint *)jarg3;
44975   if (!arg3) {
44976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44977     return ;
44978   }
44979   {
44980     try {
44981       try {
44982         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
44983       }
44984       catch(std::out_of_range &_e) {
44985         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44986         return ;
44987       }
44988
44989     } catch (std::out_of_range& e) {
44990       {
44991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44992       };
44993     } catch (std::exception& e) {
44994       {
44995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44996       };
44997     } catch (...) {
44998       {
44999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45000       };
45001     }
45002   }
45003 }
45004
45005
45006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45007   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45008   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45009
45010   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45011   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45012   if (!arg2) {
45013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45014     return ;
45015   }
45016   {
45017     try {
45018       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45019     } catch (std::out_of_range& e) {
45020       {
45021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45022       };
45023     } catch (std::exception& e) {
45024       {
45025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45026       };
45027     } catch (...) {
45028       {
45029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45030       };
45031     }
45032   }
45033 }
45034
45035
45036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45037   void * jresult ;
45038   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45039   int arg2 ;
45040   int arg3 ;
45041   std::vector< Dali::TouchPoint > *result = 0 ;
45042
45043   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45044   arg2 = (int)jarg2;
45045   arg3 = (int)jarg3;
45046   {
45047     try {
45048       try {
45049         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45050       }
45051       catch(std::out_of_range &_e) {
45052         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45053         return 0;
45054       }
45055       catch(std::invalid_argument &_e) {
45056         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45057         return 0;
45058       }
45059
45060     } catch (std::out_of_range& e) {
45061       {
45062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45063       };
45064     } catch (std::exception& e) {
45065       {
45066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45067       };
45068     } catch (...) {
45069       {
45070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45071       };
45072     }
45073   }
45074   jresult = (void *)result;
45075   return jresult;
45076 }
45077
45078
45079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45080   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45081   int arg2 ;
45082   Dali::TouchPoint *arg3 = 0 ;
45083
45084   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45085   arg2 = (int)jarg2;
45086   arg3 = (Dali::TouchPoint *)jarg3;
45087   if (!arg3) {
45088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45089     return ;
45090   }
45091   {
45092     try {
45093       try {
45094         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45095       }
45096       catch(std::out_of_range &_e) {
45097         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45098         return ;
45099       }
45100
45101     } catch (std::out_of_range& e) {
45102       {
45103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45104       };
45105     } catch (std::exception& e) {
45106       {
45107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45108       };
45109     } catch (...) {
45110       {
45111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45112       };
45113     }
45114   }
45115 }
45116
45117
45118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45119   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45120   int arg2 ;
45121   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45122
45123   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45124   arg2 = (int)jarg2;
45125   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45126   if (!arg3) {
45127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45128     return ;
45129   }
45130   {
45131     try {
45132       try {
45133         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45134       }
45135       catch(std::out_of_range &_e) {
45136         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45137         return ;
45138       }
45139
45140     } catch (std::out_of_range& e) {
45141       {
45142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45143       };
45144     } catch (std::exception& e) {
45145       {
45146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45147       };
45148     } catch (...) {
45149       {
45150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45151       };
45152     }
45153   }
45154 }
45155
45156
45157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45158   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45159   int arg2 ;
45160
45161   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45162   arg2 = (int)jarg2;
45163   {
45164     try {
45165       try {
45166         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45167       }
45168       catch(std::out_of_range &_e) {
45169         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45170         return ;
45171       }
45172
45173     } catch (std::out_of_range& e) {
45174       {
45175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45176       };
45177     } catch (std::exception& e) {
45178       {
45179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45180       };
45181     } catch (...) {
45182       {
45183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45184       };
45185     }
45186   }
45187 }
45188
45189
45190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45191   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45192   int arg2 ;
45193   int arg3 ;
45194
45195   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45196   arg2 = (int)jarg2;
45197   arg3 = (int)jarg3;
45198   {
45199     try {
45200       try {
45201         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45202       }
45203       catch(std::out_of_range &_e) {
45204         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45205         return ;
45206       }
45207       catch(std::invalid_argument &_e) {
45208         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45209         return ;
45210       }
45211
45212     } catch (std::out_of_range& e) {
45213       {
45214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45215       };
45216     } catch (std::exception& e) {
45217       {
45218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45219       };
45220     } catch (...) {
45221       {
45222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45223       };
45224     }
45225   }
45226 }
45227
45228
45229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45230   void * jresult ;
45231   Dali::TouchPoint *arg1 = 0 ;
45232   int arg2 ;
45233   std::vector< Dali::TouchPoint > *result = 0 ;
45234
45235   arg1 = (Dali::TouchPoint *)jarg1;
45236   if (!arg1) {
45237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45238     return 0;
45239   }
45240   arg2 = (int)jarg2;
45241   {
45242     try {
45243       try {
45244         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45245       }
45246       catch(std::out_of_range &_e) {
45247         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45248         return 0;
45249       }
45250
45251     } catch (std::out_of_range& e) {
45252       {
45253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45254       };
45255     } catch (std::exception& e) {
45256       {
45257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45258       };
45259     } catch (...) {
45260       {
45261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45262       };
45263     }
45264   }
45265   jresult = (void *)result;
45266   return jresult;
45267 }
45268
45269
45270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45271   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45272
45273   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45274   {
45275     try {
45276       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45277     } catch (std::out_of_range& e) {
45278       {
45279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45280       };
45281     } catch (std::exception& e) {
45282       {
45283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45284       };
45285     } catch (...) {
45286       {
45287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45288       };
45289     }
45290   }
45291 }
45292
45293
45294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45295   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45296   int arg2 ;
45297   int arg3 ;
45298
45299   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45300   arg2 = (int)jarg2;
45301   arg3 = (int)jarg3;
45302   {
45303     try {
45304       try {
45305         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45306       }
45307       catch(std::out_of_range &_e) {
45308         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45309         return ;
45310       }
45311       catch(std::invalid_argument &_e) {
45312         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45313         return ;
45314       }
45315
45316     } catch (std::out_of_range& e) {
45317       {
45318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45319       };
45320     } catch (std::exception& e) {
45321       {
45322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45323       };
45324     } catch (...) {
45325       {
45326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45327       };
45328     }
45329   }
45330 }
45331
45332
45333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45334   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45335   int arg2 ;
45336   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45337
45338   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45339   arg2 = (int)jarg2;
45340   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45341   if (!arg3) {
45342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45343     return ;
45344   }
45345   {
45346     try {
45347       try {
45348         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45349       }
45350       catch(std::out_of_range &_e) {
45351         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45352         return ;
45353       }
45354
45355     } catch (std::out_of_range& e) {
45356       {
45357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45358       };
45359     } catch (std::exception& e) {
45360       {
45361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45362       };
45363     } catch (...) {
45364       {
45365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45366       };
45367     }
45368   }
45369 }
45370
45371
45372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45373   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45374
45375   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45376   {
45377     try {
45378       delete arg1;
45379     } catch (std::out_of_range& e) {
45380       {
45381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45382       };
45383     } catch (std::exception& e) {
45384       {
45385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45386       };
45387     } catch (...) {
45388       {
45389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45390       };
45391     }
45392   }
45393 }
45394
45395
45396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45397   void * jresult ;
45398   Dali::Rect< int > *result = 0 ;
45399
45400   {
45401     try {
45402       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45403     } catch (std::out_of_range& e) {
45404       {
45405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45406       };
45407     } catch (std::exception& e) {
45408       {
45409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45410       };
45411     } catch (...) {
45412       {
45413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45414       };
45415     }
45416   }
45417   jresult = (void *)result;
45418   return jresult;
45419 }
45420
45421
45422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45423   void * jresult ;
45424   int arg1 ;
45425   int arg2 ;
45426   int arg3 ;
45427   int arg4 ;
45428   Dali::Rect< int > *result = 0 ;
45429
45430   arg1 = (int)jarg1;
45431   arg2 = (int)jarg2;
45432   arg3 = (int)jarg3;
45433   arg4 = (int)jarg4;
45434   {
45435     try {
45436       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45437     } catch (std::out_of_range& e) {
45438       {
45439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45440       };
45441     } catch (std::exception& e) {
45442       {
45443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45444       };
45445     } catch (...) {
45446       {
45447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45448       };
45449     }
45450   }
45451   jresult = (void *)result;
45452   return jresult;
45453 }
45454
45455
45456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45457   void * jresult ;
45458   Dali::Rect< int > *arg1 = 0 ;
45459   Dali::Rect< int > *result = 0 ;
45460
45461   arg1 = (Dali::Rect< int > *)jarg1;
45462   if (!arg1) {
45463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45464     return 0;
45465   }
45466   {
45467     try {
45468       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45469     } catch (std::out_of_range& e) {
45470       {
45471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45472       };
45473     } catch (std::exception& e) {
45474       {
45475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45476       };
45477     } catch (...) {
45478       {
45479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45480       };
45481     }
45482   }
45483   jresult = (void *)result;
45484   return jresult;
45485 }
45486
45487
45488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45489   void * jresult ;
45490   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45491   Dali::Rect< int > *arg2 = 0 ;
45492   Dali::Rect< int > *result = 0 ;
45493
45494   arg1 = (Dali::Rect< int > *)jarg1;
45495   arg2 = (Dali::Rect< int > *)jarg2;
45496   if (!arg2) {
45497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45498     return 0;
45499   }
45500   {
45501     try {
45502       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45503     } catch (std::out_of_range& e) {
45504       {
45505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45506       };
45507     } catch (std::exception& e) {
45508       {
45509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45510       };
45511     } catch (...) {
45512       {
45513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45514       };
45515     }
45516   }
45517   jresult = (void *)result;
45518   return jresult;
45519 }
45520
45521
45522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45523   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45524   int arg2 ;
45525   int arg3 ;
45526   int arg4 ;
45527   int arg5 ;
45528
45529   arg1 = (Dali::Rect< int > *)jarg1;
45530   arg2 = (int)jarg2;
45531   arg3 = (int)jarg3;
45532   arg4 = (int)jarg4;
45533   arg5 = (int)jarg5;
45534   {
45535     try {
45536       (arg1)->Set(arg2,arg3,arg4,arg5);
45537     } catch (std::out_of_range& e) {
45538       {
45539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45540       };
45541     } catch (std::exception& e) {
45542       {
45543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45544       };
45545     } catch (...) {
45546       {
45547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45548       };
45549     }
45550   }
45551 }
45552
45553
45554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45555   unsigned int jresult ;
45556   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45557   bool result;
45558
45559   arg1 = (Dali::Rect< int > *)jarg1;
45560   {
45561     try {
45562       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45563     } catch (std::out_of_range& e) {
45564       {
45565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45566       };
45567     } catch (std::exception& e) {
45568       {
45569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45570       };
45571     } catch (...) {
45572       {
45573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45574       };
45575     }
45576   }
45577   jresult = result;
45578   return jresult;
45579 }
45580
45581
45582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45583   int jresult ;
45584   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45585   int result;
45586
45587   arg1 = (Dali::Rect< int > *)jarg1;
45588   {
45589     try {
45590       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45591     } catch (std::out_of_range& e) {
45592       {
45593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45594       };
45595     } catch (std::exception& e) {
45596       {
45597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45598       };
45599     } catch (...) {
45600       {
45601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45602       };
45603     }
45604   }
45605   jresult = result;
45606   return jresult;
45607 }
45608
45609
45610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45611   int jresult ;
45612   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45613   int result;
45614
45615   arg1 = (Dali::Rect< int > *)jarg1;
45616   {
45617     try {
45618       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45619     } catch (std::out_of_range& e) {
45620       {
45621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45622       };
45623     } catch (std::exception& e) {
45624       {
45625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45626       };
45627     } catch (...) {
45628       {
45629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45630       };
45631     }
45632   }
45633   jresult = result;
45634   return jresult;
45635 }
45636
45637
45638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45639   int jresult ;
45640   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45641   int result;
45642
45643   arg1 = (Dali::Rect< int > *)jarg1;
45644   {
45645     try {
45646       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45647     } catch (std::out_of_range& e) {
45648       {
45649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45650       };
45651     } catch (std::exception& e) {
45652       {
45653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45654       };
45655     } catch (...) {
45656       {
45657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45658       };
45659     }
45660   }
45661   jresult = result;
45662   return jresult;
45663 }
45664
45665
45666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45667   int jresult ;
45668   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45669   int result;
45670
45671   arg1 = (Dali::Rect< int > *)jarg1;
45672   {
45673     try {
45674       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45675     } catch (std::out_of_range& e) {
45676       {
45677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45678       };
45679     } catch (std::exception& e) {
45680       {
45681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45682       };
45683     } catch (...) {
45684       {
45685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45686       };
45687     }
45688   }
45689   jresult = result;
45690   return jresult;
45691 }
45692
45693
45694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45695   int jresult ;
45696   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45697   int result;
45698
45699   arg1 = (Dali::Rect< int > *)jarg1;
45700   {
45701     try {
45702       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45703     } catch (std::out_of_range& e) {
45704       {
45705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45706       };
45707     } catch (std::exception& e) {
45708       {
45709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45710       };
45711     } catch (...) {
45712       {
45713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45714       };
45715     }
45716   }
45717   jresult = result;
45718   return jresult;
45719 }
45720
45721
45722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45723   unsigned int jresult ;
45724   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45725   Dali::Rect< int > *arg2 = 0 ;
45726   bool result;
45727
45728   arg1 = (Dali::Rect< int > *)jarg1;
45729   arg2 = (Dali::Rect< int > *)jarg2;
45730   if (!arg2) {
45731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45732     return 0;
45733   }
45734   {
45735     try {
45736       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45737     } catch (std::out_of_range& e) {
45738       {
45739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45740       };
45741     } catch (std::exception& e) {
45742       {
45743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45744       };
45745     } catch (...) {
45746       {
45747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45748       };
45749     }
45750   }
45751   jresult = result;
45752   return jresult;
45753 }
45754
45755
45756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45757   unsigned int jresult ;
45758   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45759   Dali::Rect< int > *arg2 = 0 ;
45760   bool result;
45761
45762   arg1 = (Dali::Rect< int > *)jarg1;
45763   arg2 = (Dali::Rect< int > *)jarg2;
45764   if (!arg2) {
45765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45766     return 0;
45767   }
45768   {
45769     try {
45770       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45771     } catch (std::out_of_range& e) {
45772       {
45773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45774       };
45775     } catch (std::exception& e) {
45776       {
45777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45778       };
45779     } catch (...) {
45780       {
45781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45782       };
45783     }
45784   }
45785   jresult = result;
45786   return jresult;
45787 }
45788
45789
45790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45791   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45792   int arg2 ;
45793
45794   arg1 = (Dali::Rect< int > *)jarg1;
45795   arg2 = (int)jarg2;
45796   if (arg1) (arg1)->x = arg2;
45797 }
45798
45799
45800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45801   int jresult ;
45802   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45803   int result;
45804
45805   arg1 = (Dali::Rect< int > *)jarg1;
45806   result = (int) ((arg1)->x);
45807   jresult = result;
45808   return jresult;
45809 }
45810
45811
45812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45813   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45814   int arg2 ;
45815
45816   arg1 = (Dali::Rect< int > *)jarg1;
45817   arg2 = (int)jarg2;
45818   if (arg1) (arg1)->left = arg2;
45819 }
45820
45821
45822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
45823   int jresult ;
45824   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45825   int result;
45826
45827   arg1 = (Dali::Rect< int > *)jarg1;
45828   result = (int) ((arg1)->left);
45829   jresult = result;
45830   return jresult;
45831 }
45832
45833
45834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
45835   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45836   int arg2 ;
45837
45838   arg1 = (Dali::Rect< int > *)jarg1;
45839   arg2 = (int)jarg2;
45840   if (arg1) (arg1)->y = arg2;
45841 }
45842
45843
45844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
45845   int jresult ;
45846   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45847   int result;
45848
45849   arg1 = (Dali::Rect< int > *)jarg1;
45850   result = (int) ((arg1)->y);
45851   jresult = result;
45852   return jresult;
45853 }
45854
45855
45856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
45857   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45858   int arg2 ;
45859
45860   arg1 = (Dali::Rect< int > *)jarg1;
45861   arg2 = (int)jarg2;
45862   if (arg1) (arg1)->right = arg2;
45863 }
45864
45865
45866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
45867   int jresult ;
45868   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45869   int result;
45870
45871   arg1 = (Dali::Rect< int > *)jarg1;
45872   result = (int) ((arg1)->right);
45873   jresult = result;
45874   return jresult;
45875 }
45876
45877
45878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
45879   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45880   int arg2 ;
45881
45882   arg1 = (Dali::Rect< int > *)jarg1;
45883   arg2 = (int)jarg2;
45884   if (arg1) (arg1)->width = arg2;
45885 }
45886
45887
45888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
45889   int jresult ;
45890   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45891   int result;
45892
45893   arg1 = (Dali::Rect< int > *)jarg1;
45894   result = (int) ((arg1)->width);
45895   jresult = result;
45896   return jresult;
45897 }
45898
45899
45900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
45901   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45902   int arg2 ;
45903
45904   arg1 = (Dali::Rect< int > *)jarg1;
45905   arg2 = (int)jarg2;
45906   if (arg1) (arg1)->bottom = arg2;
45907 }
45908
45909
45910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
45911   int jresult ;
45912   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45913   int result;
45914
45915   arg1 = (Dali::Rect< int > *)jarg1;
45916   result = (int) ((arg1)->bottom);
45917   jresult = result;
45918   return jresult;
45919 }
45920
45921
45922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
45923   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45924   int arg2 ;
45925
45926   arg1 = (Dali::Rect< int > *)jarg1;
45927   arg2 = (int)jarg2;
45928   if (arg1) (arg1)->height = arg2;
45929 }
45930
45931
45932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
45933   int jresult ;
45934   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45935   int result;
45936
45937   arg1 = (Dali::Rect< int > *)jarg1;
45938   result = (int) ((arg1)->height);
45939   jresult = result;
45940   return jresult;
45941 }
45942
45943
45944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
45945   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45946   int arg2 ;
45947
45948   arg1 = (Dali::Rect< int > *)jarg1;
45949   arg2 = (int)jarg2;
45950   if (arg1) (arg1)->top = arg2;
45951 }
45952
45953
45954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
45955   int jresult ;
45956   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45957   int result;
45958
45959   arg1 = (Dali::Rect< int > *)jarg1;
45960   result = (int) ((arg1)->top);
45961   jresult = result;
45962   return jresult;
45963 }
45964
45965
45966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
45967   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45968
45969   arg1 = (Dali::Rect< int > *)jarg1;
45970   {
45971     try {
45972       delete arg1;
45973     } catch (std::out_of_range& e) {
45974       {
45975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45976       };
45977     } catch (std::exception& e) {
45978       {
45979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45980       };
45981     } catch (...) {
45982       {
45983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45984       };
45985     }
45986   }
45987 }
45988
45989
45990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
45991   void * jresult ;
45992   Dali::Rect< float > *result = 0 ;
45993
45994   {
45995     try {
45996       result = (Dali::Rect< float > *)new Dali::Rect< float >();
45997     } catch (std::out_of_range& e) {
45998       {
45999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46000       };
46001     } catch (std::exception& e) {
46002       {
46003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46004       };
46005     } catch (...) {
46006       {
46007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46008       };
46009     }
46010   }
46011   jresult = (void *)result;
46012   return jresult;
46013 }
46014
46015
46016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46017   void * jresult ;
46018   float arg1 ;
46019   float arg2 ;
46020   float arg3 ;
46021   float arg4 ;
46022   Dali::Rect< float > *result = 0 ;
46023
46024   arg1 = (float)jarg1;
46025   arg2 = (float)jarg2;
46026   arg3 = (float)jarg3;
46027   arg4 = (float)jarg4;
46028   {
46029     try {
46030       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46031     } catch (std::out_of_range& e) {
46032       {
46033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46034       };
46035     } catch (std::exception& e) {
46036       {
46037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46038       };
46039     } catch (...) {
46040       {
46041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46042       };
46043     }
46044   }
46045   jresult = (void *)result;
46046   return jresult;
46047 }
46048
46049
46050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46051   void * jresult ;
46052   Dali::Rect< float > *arg1 = 0 ;
46053   Dali::Rect< float > *result = 0 ;
46054
46055   arg1 = (Dali::Rect< float > *)jarg1;
46056   if (!arg1) {
46057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46058     return 0;
46059   }
46060   {
46061     try {
46062       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46063     } catch (std::out_of_range& e) {
46064       {
46065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46066       };
46067     } catch (std::exception& e) {
46068       {
46069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46070       };
46071     } catch (...) {
46072       {
46073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46074       };
46075     }
46076   }
46077   jresult = (void *)result;
46078   return jresult;
46079 }
46080
46081
46082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46083   void * jresult ;
46084   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46085   Dali::Rect< float > *arg2 = 0 ;
46086   Dali::Rect< float > *result = 0 ;
46087
46088   arg1 = (Dali::Rect< float > *)jarg1;
46089   arg2 = (Dali::Rect< float > *)jarg2;
46090   if (!arg2) {
46091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46092     return 0;
46093   }
46094   {
46095     try {
46096       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46097     } catch (std::out_of_range& e) {
46098       {
46099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46100       };
46101     } catch (std::exception& e) {
46102       {
46103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46104       };
46105     } catch (...) {
46106       {
46107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46108       };
46109     }
46110   }
46111   jresult = (void *)result;
46112   return jresult;
46113 }
46114
46115
46116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46117   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46118   float arg2 ;
46119   float arg3 ;
46120   float arg4 ;
46121   float arg5 ;
46122
46123   arg1 = (Dali::Rect< float > *)jarg1;
46124   arg2 = (float)jarg2;
46125   arg3 = (float)jarg3;
46126   arg4 = (float)jarg4;
46127   arg5 = (float)jarg5;
46128   {
46129     try {
46130       (arg1)->Set(arg2,arg3,arg4,arg5);
46131     } catch (std::out_of_range& e) {
46132       {
46133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46134       };
46135     } catch (std::exception& e) {
46136       {
46137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46138       };
46139     } catch (...) {
46140       {
46141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46142       };
46143     }
46144   }
46145 }
46146
46147
46148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46149   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46150   float arg2 ;
46151
46152   arg1 = (Dali::Rect< float > *)jarg1;
46153   arg2 = (float)jarg2;
46154   if (arg1) (arg1)->x = arg2;
46155 }
46156
46157
46158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46159   float jresult ;
46160   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46161   float result;
46162
46163   arg1 = (Dali::Rect< float > *)jarg1;
46164   result = (float) ((arg1)->x);
46165   jresult = result;
46166   return jresult;
46167 }
46168
46169
46170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46171   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46172   float arg2 ;
46173
46174   arg1 = (Dali::Rect< float > *)jarg1;
46175   arg2 = (float)jarg2;
46176   if (arg1) (arg1)->left = arg2;
46177 }
46178
46179
46180 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46181   float jresult ;
46182   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46183   float result;
46184
46185   arg1 = (Dali::Rect< float > *)jarg1;
46186   result = (float) ((arg1)->left);
46187   jresult = result;
46188   return jresult;
46189 }
46190
46191
46192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46193   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46194   float arg2 ;
46195
46196   arg1 = (Dali::Rect< float > *)jarg1;
46197   arg2 = (float)jarg2;
46198   if (arg1) (arg1)->y = arg2;
46199 }
46200
46201
46202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46203   float jresult ;
46204   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46205   float result;
46206
46207   arg1 = (Dali::Rect< float > *)jarg1;
46208   result = (float) ((arg1)->y);
46209   jresult = result;
46210   return jresult;
46211 }
46212
46213
46214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46215   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46216   float arg2 ;
46217
46218   arg1 = (Dali::Rect< float > *)jarg1;
46219   arg2 = (float)jarg2;
46220   if (arg1) (arg1)->right = arg2;
46221 }
46222
46223
46224 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46225   float jresult ;
46226   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46227   float result;
46228
46229   arg1 = (Dali::Rect< float > *)jarg1;
46230   result = (float) ((arg1)->right);
46231   jresult = result;
46232   return jresult;
46233 }
46234
46235
46236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46237   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46238   float arg2 ;
46239
46240   arg1 = (Dali::Rect< float > *)jarg1;
46241   arg2 = (float)jarg2;
46242   if (arg1) (arg1)->width = arg2;
46243 }
46244
46245
46246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46247   float jresult ;
46248   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46249   float result;
46250
46251   arg1 = (Dali::Rect< float > *)jarg1;
46252   result = (float) ((arg1)->width);
46253   jresult = result;
46254   return jresult;
46255 }
46256
46257
46258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46259   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46260   float arg2 ;
46261
46262   arg1 = (Dali::Rect< float > *)jarg1;
46263   arg2 = (float)jarg2;
46264   if (arg1) (arg1)->bottom = arg2;
46265 }
46266
46267
46268 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46269   float jresult ;
46270   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46271   float result;
46272
46273   arg1 = (Dali::Rect< float > *)jarg1;
46274   result = (float) ((arg1)->bottom);
46275   jresult = result;
46276   return jresult;
46277 }
46278
46279
46280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46281   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46282   float arg2 ;
46283
46284   arg1 = (Dali::Rect< float > *)jarg1;
46285   arg2 = (float)jarg2;
46286   if (arg1) (arg1)->height = arg2;
46287 }
46288
46289
46290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46291   float jresult ;
46292   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46293   float result;
46294
46295   arg1 = (Dali::Rect< float > *)jarg1;
46296   result = (float) ((arg1)->height);
46297   jresult = result;
46298   return jresult;
46299 }
46300
46301
46302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46303   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46304   float arg2 ;
46305
46306   arg1 = (Dali::Rect< float > *)jarg1;
46307   arg2 = (float)jarg2;
46308   if (arg1) (arg1)->top = arg2;
46309 }
46310
46311
46312 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46313   float jresult ;
46314   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46315   float result;
46316
46317   arg1 = (Dali::Rect< float > *)jarg1;
46318   result = (float) ((arg1)->top);
46319   jresult = result;
46320   return jresult;
46321 }
46322
46323
46324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46325   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46326
46327   arg1 = (Dali::Rect< float > *)jarg1;
46328   {
46329     try {
46330       delete arg1;
46331     } catch (std::out_of_range& e) {
46332       {
46333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46334       };
46335     } catch (std::exception& e) {
46336       {
46337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46338       };
46339     } catch (...) {
46340       {
46341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46342       };
46343     }
46344   }
46345 }
46346
46347
46348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46349   int jresult ;
46350   int result;
46351
46352   result = (int)Dali::Vector< int >::BaseType;
46353   jresult = (int)result;
46354   return jresult;
46355 }
46356
46357
46358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46359   void * jresult ;
46360   Dali::Vector< int > *result = 0 ;
46361
46362   {
46363     try {
46364       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46365     } catch (std::out_of_range& e) {
46366       {
46367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46368       };
46369     } catch (std::exception& e) {
46370       {
46371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46372       };
46373     } catch (...) {
46374       {
46375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46376       };
46377     }
46378   }
46379   jresult = (void *)result;
46380   return jresult;
46381 }
46382
46383
46384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46385   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46386
46387   arg1 = (Dali::Vector< int > *)jarg1;
46388   {
46389     try {
46390       delete arg1;
46391     } catch (std::out_of_range& e) {
46392       {
46393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46394       };
46395     } catch (std::exception& e) {
46396       {
46397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46398       };
46399     } catch (...) {
46400       {
46401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46402       };
46403     }
46404   }
46405 }
46406
46407
46408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46409   void * jresult ;
46410   Dali::Vector< int > *arg1 = 0 ;
46411   Dali::Vector< int > *result = 0 ;
46412
46413   arg1 = (Dali::Vector< int > *)jarg1;
46414   if (!arg1) {
46415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46416     return 0;
46417   }
46418   {
46419     try {
46420       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46421     } catch (std::out_of_range& e) {
46422       {
46423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46424       };
46425     } catch (std::exception& e) {
46426       {
46427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46428       };
46429     } catch (...) {
46430       {
46431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46432       };
46433     }
46434   }
46435   jresult = (void *)result;
46436   return jresult;
46437 }
46438
46439
46440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46441   void * jresult ;
46442   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46443   Dali::Vector< int > *arg2 = 0 ;
46444   Dali::Vector< int > *result = 0 ;
46445
46446   arg1 = (Dali::Vector< int > *)jarg1;
46447   arg2 = (Dali::Vector< int > *)jarg2;
46448   if (!arg2) {
46449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46450     return 0;
46451   }
46452   {
46453     try {
46454       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46455     } catch (std::out_of_range& e) {
46456       {
46457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46458       };
46459     } catch (std::exception& e) {
46460       {
46461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46462       };
46463     } catch (...) {
46464       {
46465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46466       };
46467     }
46468   }
46469   jresult = (void *)result;
46470   return jresult;
46471 }
46472
46473
46474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46475   void * jresult ;
46476   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46477   Dali::Vector< int >::Iterator result;
46478
46479   arg1 = (Dali::Vector< int > *)jarg1;
46480   {
46481     try {
46482       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46483     } catch (std::out_of_range& e) {
46484       {
46485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46486       };
46487     } catch (std::exception& e) {
46488       {
46489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46490       };
46491     } catch (...) {
46492       {
46493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46494       };
46495     }
46496   }
46497   jresult = (void *)result;
46498   return jresult;
46499 }
46500
46501
46502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46503   void * jresult ;
46504   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46505   Dali::Vector< int >::Iterator result;
46506
46507   arg1 = (Dali::Vector< int > *)jarg1;
46508   {
46509     try {
46510       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46511     } catch (std::out_of_range& e) {
46512       {
46513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46514       };
46515     } catch (std::exception& e) {
46516       {
46517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46518       };
46519     } catch (...) {
46520       {
46521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46522       };
46523     }
46524   }
46525   jresult = (void *)result;
46526   return jresult;
46527 }
46528
46529
46530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46531   void * jresult ;
46532   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46533   Dali::Vector< int >::SizeType arg2 ;
46534   Dali::Vector< int >::ItemType *result = 0 ;
46535
46536   arg1 = (Dali::Vector< int > *)jarg1;
46537   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46538   {
46539     try {
46540       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46541     } catch (std::out_of_range& e) {
46542       {
46543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46544       };
46545     } catch (std::exception& e) {
46546       {
46547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46548       };
46549     } catch (...) {
46550       {
46551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46552       };
46553     }
46554   }
46555   jresult = (void *)result;
46556   return jresult;
46557 }
46558
46559
46560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46561   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46562   Dali::Vector< int >::ItemType *arg2 = 0 ;
46563   Dali::Vector< int >::ItemType temp2 ;
46564
46565   arg1 = (Dali::Vector< int > *)jarg1;
46566   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46567   arg2 = &temp2;
46568   {
46569     try {
46570       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46571     } catch (std::out_of_range& e) {
46572       {
46573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46574       };
46575     } catch (std::exception& e) {
46576       {
46577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46578       };
46579     } catch (...) {
46580       {
46581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46582       };
46583     }
46584   }
46585 }
46586
46587
46588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46589   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46590   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46591   Dali::Vector< int >::ItemType *arg3 = 0 ;
46592   Dali::Vector< int >::ItemType temp3 ;
46593
46594   arg1 = (Dali::Vector< int > *)jarg1;
46595   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46596   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46597   arg3 = &temp3;
46598   {
46599     try {
46600       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46601     } catch (std::out_of_range& e) {
46602       {
46603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46604       };
46605     } catch (std::exception& e) {
46606       {
46607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46608       };
46609     } catch (...) {
46610       {
46611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46612       };
46613     }
46614   }
46615 }
46616
46617
46618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46619   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46620   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46621   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46622   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46623
46624   arg1 = (Dali::Vector< int > *)jarg1;
46625   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46626   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46627   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46628   {
46629     try {
46630       (arg1)->Insert(arg2,arg3,arg4);
46631     } catch (std::out_of_range& e) {
46632       {
46633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46634       };
46635     } catch (std::exception& e) {
46636       {
46637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46638       };
46639     } catch (...) {
46640       {
46641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46642       };
46643     }
46644   }
46645 }
46646
46647
46648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46649   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46650   Dali::Vector< int >::SizeType arg2 ;
46651
46652   arg1 = (Dali::Vector< int > *)jarg1;
46653   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46654   {
46655     try {
46656       (arg1)->Reserve(arg2);
46657     } catch (std::out_of_range& e) {
46658       {
46659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46660       };
46661     } catch (std::exception& e) {
46662       {
46663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46664       };
46665     } catch (...) {
46666       {
46667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46668       };
46669     }
46670   }
46671 }
46672
46673
46674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46675   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46676   Dali::Vector< int >::SizeType arg2 ;
46677
46678   arg1 = (Dali::Vector< int > *)jarg1;
46679   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46680   {
46681     try {
46682       (arg1)->Resize(arg2);
46683     } catch (std::out_of_range& e) {
46684       {
46685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46686       };
46687     } catch (std::exception& e) {
46688       {
46689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46690       };
46691     } catch (...) {
46692       {
46693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46694       };
46695     }
46696   }
46697 }
46698
46699
46700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46701   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46702   Dali::Vector< int >::SizeType arg2 ;
46703   Dali::Vector< int >::ItemType *arg3 = 0 ;
46704   Dali::Vector< int >::ItemType temp3 ;
46705
46706   arg1 = (Dali::Vector< int > *)jarg1;
46707   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46708   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46709   arg3 = &temp3;
46710   {
46711     try {
46712       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46713     } catch (std::out_of_range& e) {
46714       {
46715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46716       };
46717     } catch (std::exception& e) {
46718       {
46719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46720       };
46721     } catch (...) {
46722       {
46723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46724       };
46725     }
46726   }
46727 }
46728
46729
46730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46731   void * jresult ;
46732   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46733   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46734   Dali::Vector< int >::Iterator result;
46735
46736   arg1 = (Dali::Vector< int > *)jarg1;
46737   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46738   {
46739     try {
46740       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46741     } catch (std::out_of_range& e) {
46742       {
46743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46744       };
46745     } catch (std::exception& e) {
46746       {
46747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46748       };
46749     } catch (...) {
46750       {
46751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46752       };
46753     }
46754   }
46755   jresult = (void *)result;
46756   return jresult;
46757 }
46758
46759
46760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46761   void * jresult ;
46762   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46763   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46764   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46765   Dali::Vector< int >::Iterator result;
46766
46767   arg1 = (Dali::Vector< int > *)jarg1;
46768   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46769   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46770   {
46771     try {
46772       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46773     } catch (std::out_of_range& e) {
46774       {
46775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46776       };
46777     } catch (std::exception& e) {
46778       {
46779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46780       };
46781     } catch (...) {
46782       {
46783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46784       };
46785     }
46786   }
46787   jresult = (void *)result;
46788   return jresult;
46789 }
46790
46791
46792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46793   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46794   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46795
46796   arg1 = (Dali::Vector< int > *)jarg1;
46797   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46798   {
46799     try {
46800       (arg1)->Remove(arg2);
46801     } catch (std::out_of_range& e) {
46802       {
46803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46804       };
46805     } catch (std::exception& e) {
46806       {
46807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46808       };
46809     } catch (...) {
46810       {
46811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46812       };
46813     }
46814   }
46815 }
46816
46817
46818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
46819   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46820   Dali::Vector< int > *arg2 = 0 ;
46821
46822   arg1 = (Dali::Vector< int > *)jarg1;
46823   arg2 = (Dali::Vector< int > *)jarg2;
46824   if (!arg2) {
46825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
46826     return ;
46827   }
46828   {
46829     try {
46830       (arg1)->Swap(*arg2);
46831     } catch (std::out_of_range& e) {
46832       {
46833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46834       };
46835     } catch (std::exception& e) {
46836       {
46837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46838       };
46839     } catch (...) {
46840       {
46841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46842       };
46843     }
46844   }
46845 }
46846
46847
46848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
46849   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46850
46851   arg1 = (Dali::Vector< int > *)jarg1;
46852   {
46853     try {
46854       (arg1)->Clear();
46855     } catch (std::out_of_range& e) {
46856       {
46857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46858       };
46859     } catch (std::exception& e) {
46860       {
46861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46862       };
46863     } catch (...) {
46864       {
46865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46866       };
46867     }
46868   }
46869 }
46870
46871
46872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
46873   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46874
46875   arg1 = (Dali::Vector< int > *)jarg1;
46876   {
46877     try {
46878       (arg1)->Release();
46879     } catch (std::out_of_range& e) {
46880       {
46881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46882       };
46883     } catch (std::exception& e) {
46884       {
46885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46886       };
46887     } catch (...) {
46888       {
46889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46890       };
46891     }
46892   }
46893 }
46894
46895
46896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
46897   int jresult ;
46898   int result;
46899
46900   result = (int)Dali::Vector< float >::BaseType;
46901   jresult = (int)result;
46902   return jresult;
46903 }
46904
46905
46906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
46907   void * jresult ;
46908   Dali::Vector< float > *result = 0 ;
46909
46910   {
46911     try {
46912       result = (Dali::Vector< float > *)new Dali::Vector< float >();
46913     } catch (std::out_of_range& e) {
46914       {
46915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46916       };
46917     } catch (std::exception& e) {
46918       {
46919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46920       };
46921     } catch (...) {
46922       {
46923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46924       };
46925     }
46926   }
46927   jresult = (void *)result;
46928   return jresult;
46929 }
46930
46931
46932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
46933   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46934
46935   arg1 = (Dali::Vector< float > *)jarg1;
46936   {
46937     try {
46938       delete arg1;
46939     } catch (std::out_of_range& e) {
46940       {
46941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46942       };
46943     } catch (std::exception& e) {
46944       {
46945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46946       };
46947     } catch (...) {
46948       {
46949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46950       };
46951     }
46952   }
46953 }
46954
46955
46956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
46957   void * jresult ;
46958   Dali::Vector< float > *arg1 = 0 ;
46959   Dali::Vector< float > *result = 0 ;
46960
46961   arg1 = (Dali::Vector< float > *)jarg1;
46962   if (!arg1) {
46963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
46964     return 0;
46965   }
46966   {
46967     try {
46968       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
46969     } catch (std::out_of_range& e) {
46970       {
46971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46972       };
46973     } catch (std::exception& e) {
46974       {
46975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46976       };
46977     } catch (...) {
46978       {
46979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46980       };
46981     }
46982   }
46983   jresult = (void *)result;
46984   return jresult;
46985 }
46986
46987
46988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
46989   void * jresult ;
46990   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46991   Dali::Vector< float > *arg2 = 0 ;
46992   Dali::Vector< float > *result = 0 ;
46993
46994   arg1 = (Dali::Vector< float > *)jarg1;
46995   arg2 = (Dali::Vector< float > *)jarg2;
46996   if (!arg2) {
46997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
46998     return 0;
46999   }
47000   {
47001     try {
47002       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47003     } catch (std::out_of_range& e) {
47004       {
47005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47006       };
47007     } catch (std::exception& e) {
47008       {
47009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47010       };
47011     } catch (...) {
47012       {
47013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47014       };
47015     }
47016   }
47017   jresult = (void *)result;
47018   return jresult;
47019 }
47020
47021
47022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47023   void * jresult ;
47024   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47025   Dali::Vector< float >::Iterator result;
47026
47027   arg1 = (Dali::Vector< float > *)jarg1;
47028   {
47029     try {
47030       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47031     } catch (std::out_of_range& e) {
47032       {
47033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47034       };
47035     } catch (std::exception& e) {
47036       {
47037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47038       };
47039     } catch (...) {
47040       {
47041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47042       };
47043     }
47044   }
47045   jresult = (void *)result;
47046   return jresult;
47047 }
47048
47049
47050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47051   void * jresult ;
47052   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47053   Dali::Vector< float >::Iterator result;
47054
47055   arg1 = (Dali::Vector< float > *)jarg1;
47056   {
47057     try {
47058       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47059     } catch (std::out_of_range& e) {
47060       {
47061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47062       };
47063     } catch (std::exception& e) {
47064       {
47065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47066       };
47067     } catch (...) {
47068       {
47069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47070       };
47071     }
47072   }
47073   jresult = (void *)result;
47074   return jresult;
47075 }
47076
47077
47078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47079   void * jresult ;
47080   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47081   Dali::Vector< float >::SizeType arg2 ;
47082   Dali::Vector< float >::ItemType *result = 0 ;
47083
47084   arg1 = (Dali::Vector< float > *)jarg1;
47085   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47086   {
47087     try {
47088       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47089     } catch (std::out_of_range& e) {
47090       {
47091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47092       };
47093     } catch (std::exception& e) {
47094       {
47095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47096       };
47097     } catch (...) {
47098       {
47099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47100       };
47101     }
47102   }
47103   jresult = (void *)result;
47104   return jresult;
47105 }
47106
47107
47108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47109   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47110   Dali::Vector< float >::ItemType *arg2 = 0 ;
47111   Dali::Vector< float >::ItemType temp2 ;
47112
47113   arg1 = (Dali::Vector< float > *)jarg1;
47114   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47115   arg2 = &temp2;
47116   {
47117     try {
47118       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47119     } catch (std::out_of_range& e) {
47120       {
47121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47122       };
47123     } catch (std::exception& e) {
47124       {
47125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47126       };
47127     } catch (...) {
47128       {
47129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47130       };
47131     }
47132   }
47133 }
47134
47135
47136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47137   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47138   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47139   Dali::Vector< float >::ItemType *arg3 = 0 ;
47140   Dali::Vector< float >::ItemType temp3 ;
47141
47142   arg1 = (Dali::Vector< float > *)jarg1;
47143   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47144   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47145   arg3 = &temp3;
47146   {
47147     try {
47148       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47149     } catch (std::out_of_range& e) {
47150       {
47151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47152       };
47153     } catch (std::exception& e) {
47154       {
47155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47156       };
47157     } catch (...) {
47158       {
47159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47160       };
47161     }
47162   }
47163 }
47164
47165
47166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47167   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47168   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47169   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47170   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47171
47172   arg1 = (Dali::Vector< float > *)jarg1;
47173   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47174   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47175   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47176   {
47177     try {
47178       (arg1)->Insert(arg2,arg3,arg4);
47179     } catch (std::out_of_range& e) {
47180       {
47181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47182       };
47183     } catch (std::exception& e) {
47184       {
47185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47186       };
47187     } catch (...) {
47188       {
47189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47190       };
47191     }
47192   }
47193 }
47194
47195
47196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47197   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47198   Dali::Vector< float >::SizeType arg2 ;
47199
47200   arg1 = (Dali::Vector< float > *)jarg1;
47201   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47202   {
47203     try {
47204       (arg1)->Reserve(arg2);
47205     } catch (std::out_of_range& e) {
47206       {
47207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47208       };
47209     } catch (std::exception& e) {
47210       {
47211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47212       };
47213     } catch (...) {
47214       {
47215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47216       };
47217     }
47218   }
47219 }
47220
47221
47222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47223   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47224   Dali::Vector< float >::SizeType arg2 ;
47225
47226   arg1 = (Dali::Vector< float > *)jarg1;
47227   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47228   {
47229     try {
47230       (arg1)->Resize(arg2);
47231     } catch (std::out_of_range& e) {
47232       {
47233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47234       };
47235     } catch (std::exception& e) {
47236       {
47237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47238       };
47239     } catch (...) {
47240       {
47241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47242       };
47243     }
47244   }
47245 }
47246
47247
47248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47249   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47250   Dali::Vector< float >::SizeType arg2 ;
47251   Dali::Vector< float >::ItemType *arg3 = 0 ;
47252   Dali::Vector< float >::ItemType temp3 ;
47253
47254   arg1 = (Dali::Vector< float > *)jarg1;
47255   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47256   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47257   arg3 = &temp3;
47258   {
47259     try {
47260       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47261     } catch (std::out_of_range& e) {
47262       {
47263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47264       };
47265     } catch (std::exception& e) {
47266       {
47267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47268       };
47269     } catch (...) {
47270       {
47271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47272       };
47273     }
47274   }
47275 }
47276
47277
47278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47279   void * jresult ;
47280   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47281   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47282   Dali::Vector< float >::Iterator result;
47283
47284   arg1 = (Dali::Vector< float > *)jarg1;
47285   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47286   {
47287     try {
47288       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47289     } catch (std::out_of_range& e) {
47290       {
47291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47292       };
47293     } catch (std::exception& e) {
47294       {
47295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47296       };
47297     } catch (...) {
47298       {
47299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47300       };
47301     }
47302   }
47303   jresult = (void *)result;
47304   return jresult;
47305 }
47306
47307
47308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47309   void * jresult ;
47310   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47311   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47312   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47313   Dali::Vector< float >::Iterator result;
47314
47315   arg1 = (Dali::Vector< float > *)jarg1;
47316   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47317   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47318   {
47319     try {
47320       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47321     } catch (std::out_of_range& e) {
47322       {
47323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47324       };
47325     } catch (std::exception& e) {
47326       {
47327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47328       };
47329     } catch (...) {
47330       {
47331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47332       };
47333     }
47334   }
47335   jresult = (void *)result;
47336   return jresult;
47337 }
47338
47339
47340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47341   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47342   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47343
47344   arg1 = (Dali::Vector< float > *)jarg1;
47345   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47346   {
47347     try {
47348       (arg1)->Remove(arg2);
47349     } catch (std::out_of_range& e) {
47350       {
47351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47352       };
47353     } catch (std::exception& e) {
47354       {
47355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47356       };
47357     } catch (...) {
47358       {
47359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47360       };
47361     }
47362   }
47363 }
47364
47365
47366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47367   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47368   Dali::Vector< float > *arg2 = 0 ;
47369
47370   arg1 = (Dali::Vector< float > *)jarg1;
47371   arg2 = (Dali::Vector< float > *)jarg2;
47372   if (!arg2) {
47373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47374     return ;
47375   }
47376   {
47377     try {
47378       (arg1)->Swap(*arg2);
47379     } catch (std::out_of_range& e) {
47380       {
47381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47382       };
47383     } catch (std::exception& e) {
47384       {
47385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47386       };
47387     } catch (...) {
47388       {
47389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47390       };
47391     }
47392   }
47393 }
47394
47395
47396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47397   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47398
47399   arg1 = (Dali::Vector< float > *)jarg1;
47400   {
47401     try {
47402       (arg1)->Clear();
47403     } catch (std::out_of_range& e) {
47404       {
47405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47406       };
47407     } catch (std::exception& e) {
47408       {
47409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47410       };
47411     } catch (...) {
47412       {
47413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47414       };
47415     }
47416   }
47417 }
47418
47419
47420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47421   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47422
47423   arg1 = (Dali::Vector< float > *)jarg1;
47424   {
47425     try {
47426       (arg1)->Release();
47427     } catch (std::out_of_range& e) {
47428       {
47429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47430       };
47431     } catch (std::exception& e) {
47432       {
47433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47434       };
47435     } catch (...) {
47436       {
47437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47438       };
47439     }
47440   }
47441 }
47442
47443
47444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47445   int jresult ;
47446   int result;
47447
47448   result = (int)Dali::Vector< unsigned char >::BaseType;
47449   jresult = (int)result;
47450   return jresult;
47451 }
47452
47453
47454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47455   void * jresult ;
47456   Dali::Vector< unsigned char > *result = 0 ;
47457
47458   {
47459     try {
47460       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47461     } catch (std::out_of_range& e) {
47462       {
47463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47464       };
47465     } catch (std::exception& e) {
47466       {
47467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47468       };
47469     } catch (...) {
47470       {
47471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47472       };
47473     }
47474   }
47475   jresult = (void *)result;
47476   return jresult;
47477 }
47478
47479
47480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47481   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47482
47483   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47484   {
47485     try {
47486       delete arg1;
47487     } catch (std::out_of_range& e) {
47488       {
47489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47490       };
47491     } catch (std::exception& e) {
47492       {
47493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47494       };
47495     } catch (...) {
47496       {
47497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47498       };
47499     }
47500   }
47501 }
47502
47503
47504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47505   void * jresult ;
47506   Dali::Vector< unsigned char > *arg1 = 0 ;
47507   Dali::Vector< unsigned char > *result = 0 ;
47508
47509   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47510   if (!arg1) {
47511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47512     return 0;
47513   }
47514   {
47515     try {
47516       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47517     } catch (std::out_of_range& e) {
47518       {
47519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47520       };
47521     } catch (std::exception& e) {
47522       {
47523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47524       };
47525     } catch (...) {
47526       {
47527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47528       };
47529     }
47530   }
47531   jresult = (void *)result;
47532   return jresult;
47533 }
47534
47535
47536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47537   void * jresult ;
47538   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47539   Dali::Vector< unsigned char > *arg2 = 0 ;
47540   Dali::Vector< unsigned char > *result = 0 ;
47541
47542   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47543   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47544   if (!arg2) {
47545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47546     return 0;
47547   }
47548   {
47549     try {
47550       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47551     } catch (std::out_of_range& e) {
47552       {
47553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47554       };
47555     } catch (std::exception& e) {
47556       {
47557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47558       };
47559     } catch (...) {
47560       {
47561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47562       };
47563     }
47564   }
47565   jresult = (void *)result;
47566   return jresult;
47567 }
47568
47569
47570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47571   void * jresult ;
47572   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47573   Dali::Vector< unsigned char >::Iterator result;
47574
47575   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47576   {
47577     try {
47578       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47579     } catch (std::out_of_range& e) {
47580       {
47581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47582       };
47583     } catch (std::exception& e) {
47584       {
47585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47586       };
47587     } catch (...) {
47588       {
47589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47590       };
47591     }
47592   }
47593   jresult = (void *)result;
47594   return jresult;
47595 }
47596
47597
47598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47599   void * jresult ;
47600   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47601   Dali::Vector< unsigned char >::Iterator result;
47602
47603   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47604   {
47605     try {
47606       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47607     } catch (std::out_of_range& e) {
47608       {
47609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47610       };
47611     } catch (std::exception& e) {
47612       {
47613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47614       };
47615     } catch (...) {
47616       {
47617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47618       };
47619     }
47620   }
47621   jresult = (void *)result;
47622   return jresult;
47623 }
47624
47625
47626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47627   void * jresult ;
47628   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47629   Dali::Vector< unsigned char >::SizeType arg2 ;
47630   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47631
47632   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47633   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47634   {
47635     try {
47636       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47637     } catch (std::out_of_range& e) {
47638       {
47639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47640       };
47641     } catch (std::exception& e) {
47642       {
47643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47644       };
47645     } catch (...) {
47646       {
47647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47648       };
47649     }
47650   }
47651   jresult = (void *)result;
47652   return jresult;
47653 }
47654
47655
47656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47657   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47658   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47659   Dali::Vector< unsigned char >::ItemType temp2 ;
47660
47661   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47662   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47663   arg2 = &temp2;
47664   {
47665     try {
47666       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47667     } catch (std::out_of_range& e) {
47668       {
47669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47670       };
47671     } catch (std::exception& e) {
47672       {
47673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47674       };
47675     } catch (...) {
47676       {
47677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47678       };
47679     }
47680   }
47681 }
47682
47683
47684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47685   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47686   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47687   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47688   Dali::Vector< unsigned char >::ItemType temp3 ;
47689
47690   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47691   arg2 = jarg2;
47692   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47693   arg3 = &temp3;
47694   {
47695     try {
47696       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47697     } catch (std::out_of_range& e) {
47698       {
47699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47700       };
47701     } catch (std::exception& e) {
47702       {
47703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47704       };
47705     } catch (...) {
47706       {
47707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47708       };
47709     }
47710   }
47711
47712
47713 }
47714
47715
47716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47717   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47718   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47719   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47720   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47721
47722   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47723   arg2 = jarg2;
47724   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47725   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47726   {
47727     try {
47728       (arg1)->Insert(arg2,arg3,arg4);
47729     } catch (std::out_of_range& e) {
47730       {
47731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47732       };
47733     } catch (std::exception& e) {
47734       {
47735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47736       };
47737     } catch (...) {
47738       {
47739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47740       };
47741     }
47742   }
47743
47744
47745 }
47746
47747
47748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47749   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47750   Dali::Vector< unsigned char >::SizeType arg2 ;
47751
47752   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47753   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47754   {
47755     try {
47756       (arg1)->Reserve(arg2);
47757     } catch (std::out_of_range& e) {
47758       {
47759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47760       };
47761     } catch (std::exception& e) {
47762       {
47763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47764       };
47765     } catch (...) {
47766       {
47767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47768       };
47769     }
47770   }
47771 }
47772
47773
47774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47775   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47776   Dali::Vector< unsigned char >::SizeType arg2 ;
47777
47778   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47779   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47780   {
47781     try {
47782       (arg1)->Resize(arg2);
47783     } catch (std::out_of_range& e) {
47784       {
47785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47786       };
47787     } catch (std::exception& e) {
47788       {
47789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47790       };
47791     } catch (...) {
47792       {
47793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47794       };
47795     }
47796   }
47797 }
47798
47799
47800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47801   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47802   Dali::Vector< unsigned char >::SizeType arg2 ;
47803   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47804   Dali::Vector< unsigned char >::ItemType temp3 ;
47805
47806   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47807   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47808   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47809   arg3 = &temp3;
47810   {
47811     try {
47812       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47813     } catch (std::out_of_range& e) {
47814       {
47815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47816       };
47817     } catch (std::exception& e) {
47818       {
47819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47820       };
47821     } catch (...) {
47822       {
47823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47824       };
47825     }
47826   }
47827 }
47828
47829
47830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
47831   void * jresult ;
47832   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47833   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47834   Dali::Vector< unsigned char >::Iterator result;
47835
47836   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47837   arg2 = jarg2;
47838   {
47839     try {
47840       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
47841     } catch (std::out_of_range& e) {
47842       {
47843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47844       };
47845     } catch (std::exception& e) {
47846       {
47847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47848       };
47849     } catch (...) {
47850       {
47851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47852       };
47853     }
47854   }
47855   jresult = (void *)result;
47856
47857
47858   return jresult;
47859 }
47860
47861
47862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
47863   void * jresult ;
47864   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47865   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47866   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47867   Dali::Vector< unsigned char >::Iterator result;
47868
47869   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47870   arg2 = jarg2;
47871   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47872   {
47873     try {
47874       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
47875     } catch (std::out_of_range& e) {
47876       {
47877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47878       };
47879     } catch (std::exception& e) {
47880       {
47881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47882       };
47883     } catch (...) {
47884       {
47885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47886       };
47887     }
47888   }
47889   jresult = (void *)result;
47890
47891
47892   return jresult;
47893 }
47894
47895
47896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
47897   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47898   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47899
47900   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47901   arg2 = jarg2;
47902   {
47903     try {
47904       (arg1)->Remove(arg2);
47905     } catch (std::out_of_range& e) {
47906       {
47907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47908       };
47909     } catch (std::exception& e) {
47910       {
47911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47912       };
47913     } catch (...) {
47914       {
47915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47916       };
47917     }
47918   }
47919
47920
47921 }
47922
47923
47924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
47925   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47926   Dali::Vector< unsigned char > *arg2 = 0 ;
47927
47928   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47929   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47930   if (!arg2) {
47931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
47932     return ;
47933   }
47934   {
47935     try {
47936       (arg1)->Swap(*arg2);
47937     } catch (std::out_of_range& e) {
47938       {
47939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47940       };
47941     } catch (std::exception& e) {
47942       {
47943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47944       };
47945     } catch (...) {
47946       {
47947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47948       };
47949     }
47950   }
47951 }
47952
47953
47954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
47955   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47956
47957   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47958   {
47959     try {
47960       (arg1)->Clear();
47961     } catch (std::out_of_range& e) {
47962       {
47963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47964       };
47965     } catch (std::exception& e) {
47966       {
47967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47968       };
47969     } catch (...) {
47970       {
47971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47972       };
47973     }
47974   }
47975 }
47976
47977
47978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
47979   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47980
47981   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47982   {
47983     try {
47984       (arg1)->Release();
47985     } catch (std::out_of_range& e) {
47986       {
47987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47988       };
47989     } catch (std::exception& e) {
47990       {
47991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47992       };
47993     } catch (...) {
47994       {
47995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47996       };
47997     }
47998   }
47999 }
48000
48001
48002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48003   int jresult ;
48004   int result;
48005
48006   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48007   jresult = (int)result;
48008   return jresult;
48009 }
48010
48011
48012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48013   void * jresult ;
48014   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48015
48016   {
48017     try {
48018       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48019     } catch (std::out_of_range& e) {
48020       {
48021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48022       };
48023     } catch (std::exception& e) {
48024       {
48025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48026       };
48027     } catch (...) {
48028       {
48029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48030       };
48031     }
48032   }
48033   jresult = (void *)result;
48034   return jresult;
48035 }
48036
48037
48038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48039   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48040
48041   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48042   {
48043     try {
48044       delete arg1;
48045     } catch (std::out_of_range& e) {
48046       {
48047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48048       };
48049     } catch (std::exception& e) {
48050       {
48051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48052       };
48053     } catch (...) {
48054       {
48055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48056       };
48057     }
48058   }
48059 }
48060
48061
48062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48063   void * jresult ;
48064   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48065   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48066
48067   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48068   if (!arg1) {
48069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48070     return 0;
48071   }
48072   {
48073     try {
48074       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48075     } catch (std::out_of_range& e) {
48076       {
48077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48078       };
48079     } catch (std::exception& e) {
48080       {
48081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48082       };
48083     } catch (...) {
48084       {
48085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48086       };
48087     }
48088   }
48089   jresult = (void *)result;
48090   return jresult;
48091 }
48092
48093
48094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48095   void * jresult ;
48096   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48097   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48098   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48099
48100   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48101   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48102   if (!arg2) {
48103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48104     return 0;
48105   }
48106   {
48107     try {
48108       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48109     } catch (std::out_of_range& e) {
48110       {
48111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48112       };
48113     } catch (std::exception& e) {
48114       {
48115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48116       };
48117     } catch (...) {
48118       {
48119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48120       };
48121     }
48122   }
48123   jresult = (void *)result;
48124   return jresult;
48125 }
48126
48127
48128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48129   void * jresult ;
48130   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48131   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48132
48133   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48134   {
48135     try {
48136       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48137     } catch (std::out_of_range& e) {
48138       {
48139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48140       };
48141     } catch (std::exception& e) {
48142       {
48143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48144       };
48145     } catch (...) {
48146       {
48147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48148       };
48149     }
48150   }
48151   jresult = (void *)result;
48152   return jresult;
48153 }
48154
48155
48156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48157   void * jresult ;
48158   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48159   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48160
48161   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48162   {
48163     try {
48164       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48165     } catch (std::out_of_range& e) {
48166       {
48167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48168       };
48169     } catch (std::exception& e) {
48170       {
48171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48172       };
48173     } catch (...) {
48174       {
48175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48176       };
48177     }
48178   }
48179   jresult = (void *)result;
48180   return jresult;
48181 }
48182
48183
48184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48185   void * jresult ;
48186   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48187   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48188   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48189
48190   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48191   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48192   {
48193     try {
48194       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48195     } catch (std::out_of_range& e) {
48196       {
48197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48198       };
48199     } catch (std::exception& e) {
48200       {
48201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48202       };
48203     } catch (...) {
48204       {
48205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48206       };
48207     }
48208   }
48209   jresult = (void *)result;
48210   return jresult;
48211 }
48212
48213
48214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48215   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48216   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48217
48218   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48219   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48220   if (!arg2) {
48221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48222     return ;
48223   }
48224   {
48225     try {
48226       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48227     } catch (std::out_of_range& e) {
48228       {
48229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48230       };
48231     } catch (std::exception& e) {
48232       {
48233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48234       };
48235     } catch (...) {
48236       {
48237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48238       };
48239     }
48240   }
48241 }
48242
48243
48244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48245   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48246   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48247   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48248
48249   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48250   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48251   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48252   if (!arg3) {
48253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48254     return ;
48255   }
48256   {
48257     try {
48258       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48259     } catch (std::out_of_range& e) {
48260       {
48261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48262       };
48263     } catch (std::exception& e) {
48264       {
48265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48266       };
48267     } catch (...) {
48268       {
48269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48270       };
48271     }
48272   }
48273 }
48274
48275
48276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48277   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48278   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48279   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48280   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48281
48282   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48283   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48284   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48285   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48286   {
48287     try {
48288       (arg1)->Insert(arg2,arg3,arg4);
48289     } catch (std::out_of_range& e) {
48290       {
48291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48292       };
48293     } catch (std::exception& e) {
48294       {
48295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48296       };
48297     } catch (...) {
48298       {
48299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48300       };
48301     }
48302   }
48303 }
48304
48305
48306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48307   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48308   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48309
48310   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48311   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48312   {
48313     try {
48314       (arg1)->Reserve(arg2);
48315     } catch (std::out_of_range& e) {
48316       {
48317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48318       };
48319     } catch (std::exception& e) {
48320       {
48321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48322       };
48323     } catch (...) {
48324       {
48325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48326       };
48327     }
48328   }
48329 }
48330
48331
48332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48333   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48334   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48335
48336   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48337   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48338   {
48339     try {
48340       (arg1)->Resize(arg2);
48341     } catch (std::out_of_range& e) {
48342       {
48343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48344       };
48345     } catch (std::exception& e) {
48346       {
48347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48348       };
48349     } catch (...) {
48350       {
48351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48352       };
48353     }
48354   }
48355 }
48356
48357
48358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48359   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48360   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48361   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48362
48363   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48364   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48365   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48366   if (!arg3) {
48367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48368     return ;
48369   }
48370   {
48371     try {
48372       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48373     } catch (std::out_of_range& e) {
48374       {
48375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48376       };
48377     } catch (std::exception& e) {
48378       {
48379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48380       };
48381     } catch (...) {
48382       {
48383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48384       };
48385     }
48386   }
48387 }
48388
48389
48390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48391   void * jresult ;
48392   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48393   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48394   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48395
48396   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48397   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48398   {
48399     try {
48400       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48401     } catch (std::out_of_range& e) {
48402       {
48403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48404       };
48405     } catch (std::exception& e) {
48406       {
48407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48408       };
48409     } catch (...) {
48410       {
48411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48412       };
48413     }
48414   }
48415   jresult = (void *)result;
48416   return jresult;
48417 }
48418
48419
48420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48421   void * jresult ;
48422   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48423   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48424   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48425   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48426
48427   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48428   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48429   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48430   {
48431     try {
48432       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48433     } catch (std::out_of_range& e) {
48434       {
48435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48436       };
48437     } catch (std::exception& e) {
48438       {
48439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48440       };
48441     } catch (...) {
48442       {
48443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48444       };
48445     }
48446   }
48447   jresult = (void *)result;
48448   return jresult;
48449 }
48450
48451
48452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48453   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48454   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48455
48456   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48457   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48458   {
48459     try {
48460       (arg1)->Remove(arg2);
48461     } catch (std::out_of_range& e) {
48462       {
48463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48464       };
48465     } catch (std::exception& e) {
48466       {
48467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48468       };
48469     } catch (...) {
48470       {
48471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48472       };
48473     }
48474   }
48475 }
48476
48477
48478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48479   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48480   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48481
48482   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48483   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48484   if (!arg2) {
48485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48486     return ;
48487   }
48488   {
48489     try {
48490       (arg1)->Swap(*arg2);
48491     } catch (std::out_of_range& e) {
48492       {
48493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48494       };
48495     } catch (std::exception& e) {
48496       {
48497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48498       };
48499     } catch (...) {
48500       {
48501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48502       };
48503     }
48504   }
48505 }
48506
48507
48508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48509   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48510
48511   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48512   {
48513     try {
48514       (arg1)->Clear();
48515     } catch (std::out_of_range& e) {
48516       {
48517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48518       };
48519     } catch (std::exception& e) {
48520       {
48521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48522       };
48523     } catch (...) {
48524       {
48525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48526       };
48527     }
48528   }
48529 }
48530
48531
48532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48533   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48534
48535   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48536   {
48537     try {
48538       (arg1)->Release();
48539     } catch (std::out_of_range& e) {
48540       {
48541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48542       };
48543     } catch (std::exception& e) {
48544       {
48545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48546       };
48547     } catch (...) {
48548       {
48549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48550       };
48551     }
48552   }
48553 }
48554
48555
48556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48557   void * jresult ;
48558   Dali::Signal< void () > *result = 0 ;
48559
48560   {
48561     try {
48562       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48563     } catch (std::out_of_range& e) {
48564       {
48565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48566       };
48567     } catch (std::exception& e) {
48568       {
48569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48570       };
48571     } catch (...) {
48572       {
48573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48574       };
48575     }
48576   }
48577   jresult = (void *)result;
48578   return jresult;
48579 }
48580
48581
48582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48583   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48584
48585   arg1 = (Dali::Signal< void () > *)jarg1;
48586   {
48587     try {
48588       delete arg1;
48589     } catch (std::out_of_range& e) {
48590       {
48591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48592       };
48593     } catch (std::exception& e) {
48594       {
48595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48596       };
48597     } catch (...) {
48598       {
48599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48600       };
48601     }
48602   }
48603 }
48604
48605
48606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48607   unsigned int jresult ;
48608   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48609   bool result;
48610
48611   arg1 = (Dali::Signal< void () > *)jarg1;
48612   {
48613     try {
48614       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48615     } catch (std::out_of_range& e) {
48616       {
48617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48618       };
48619     } catch (std::exception& e) {
48620       {
48621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48622       };
48623     } catch (...) {
48624       {
48625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48626       };
48627     }
48628   }
48629   jresult = result;
48630   return jresult;
48631 }
48632
48633
48634 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48635   unsigned long jresult ;
48636   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48637   std::size_t result;
48638
48639   arg1 = (Dali::Signal< void () > *)jarg1;
48640   {
48641     try {
48642       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48643     } catch (std::out_of_range& e) {
48644       {
48645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48646       };
48647     } catch (std::exception& e) {
48648       {
48649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48650       };
48651     } catch (...) {
48652       {
48653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48654       };
48655     }
48656   }
48657   jresult = (unsigned long)result;
48658   return jresult;
48659 }
48660
48661
48662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48663   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48664   void (*arg2)() = (void (*)()) 0 ;
48665
48666   arg1 = (Dali::Signal< void () > *)jarg1;
48667   arg2 = (void (*)())jarg2;
48668   {
48669     try {
48670       (arg1)->Connect(arg2);
48671     } catch (std::out_of_range& e) {
48672       {
48673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48674       };
48675     } catch (std::exception& e) {
48676       {
48677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48678       };
48679     } catch (...) {
48680       {
48681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48682       };
48683     }
48684   }
48685 }
48686
48687
48688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48689   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48690   void (*arg2)() = (void (*)()) 0 ;
48691
48692   arg1 = (Dali::Signal< void () > *)jarg1;
48693   arg2 = (void (*)())jarg2;
48694   {
48695     try {
48696       (arg1)->Disconnect(arg2);
48697     } catch (std::out_of_range& e) {
48698       {
48699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48700       };
48701     } catch (std::exception& e) {
48702       {
48703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48704       };
48705     } catch (...) {
48706       {
48707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48708       };
48709     }
48710   }
48711 }
48712
48713
48714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48715   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48716   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48717   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48718
48719   arg1 = (Dali::Signal< void () > *)jarg1;
48720   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48721   arg3 = (Dali::FunctorDelegate *)jarg3;
48722   {
48723     try {
48724       (arg1)->Connect(arg2,arg3);
48725     } catch (std::out_of_range& e) {
48726       {
48727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48728       };
48729     } catch (std::exception& e) {
48730       {
48731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48732       };
48733     } catch (...) {
48734       {
48735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48736       };
48737     }
48738   }
48739 }
48740
48741
48742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48743   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48744
48745   arg1 = (Dali::Signal< void () > *)jarg1;
48746   {
48747     try {
48748       (arg1)->Emit();
48749     } catch (std::out_of_range& e) {
48750       {
48751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48752       };
48753     } catch (std::exception& e) {
48754       {
48755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48756       };
48757     } catch (...) {
48758       {
48759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48760       };
48761     }
48762   }
48763 }
48764
48765
48766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48767   unsigned int jresult ;
48768   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48769   bool result;
48770
48771   arg1 = (Dali::Signal< void (float) > *)jarg1;
48772   {
48773     try {
48774       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48775     } catch (std::out_of_range& e) {
48776       {
48777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48778       };
48779     } catch (std::exception& e) {
48780       {
48781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48782       };
48783     } catch (...) {
48784       {
48785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48786       };
48787     }
48788   }
48789   jresult = result;
48790   return jresult;
48791 }
48792
48793
48794 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48795   unsigned long jresult ;
48796   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48797   std::size_t result;
48798
48799   arg1 = (Dali::Signal< void (float) > *)jarg1;
48800   {
48801     try {
48802       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48803     } catch (std::out_of_range& e) {
48804       {
48805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48806       };
48807     } catch (std::exception& e) {
48808       {
48809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48810       };
48811     } catch (...) {
48812       {
48813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48814       };
48815     }
48816   }
48817   jresult = (unsigned long)result;
48818   return jresult;
48819 }
48820
48821
48822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
48823   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48824   void (*arg2)(float) = (void (*)(float)) 0 ;
48825
48826   arg1 = (Dali::Signal< void (float) > *)jarg1;
48827   arg2 = (void (*)(float))jarg2;
48828   {
48829     try {
48830       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
48831     } catch (std::out_of_range& e) {
48832       {
48833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48834       };
48835     } catch (std::exception& e) {
48836       {
48837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48838       };
48839     } catch (...) {
48840       {
48841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48842       };
48843     }
48844   }
48845 }
48846
48847
48848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
48849   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48850   void (*arg2)(float) = (void (*)(float)) 0 ;
48851
48852   arg1 = (Dali::Signal< void (float) > *)jarg1;
48853   arg2 = (void (*)(float))jarg2;
48854   {
48855     try {
48856       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
48857     } catch (std::out_of_range& e) {
48858       {
48859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48860       };
48861     } catch (std::exception& e) {
48862       {
48863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48864       };
48865     } catch (...) {
48866       {
48867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48868       };
48869     }
48870   }
48871 }
48872
48873
48874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
48875   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48876   float arg2 ;
48877
48878   arg1 = (Dali::Signal< void (float) > *)jarg1;
48879   arg2 = (float)jarg2;
48880   {
48881     try {
48882       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
48883     } catch (std::out_of_range& e) {
48884       {
48885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48886       };
48887     } catch (std::exception& e) {
48888       {
48889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48890       };
48891     } catch (...) {
48892       {
48893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48894       };
48895     }
48896   }
48897 }
48898
48899
48900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
48901   void * jresult ;
48902   Dali::Signal< void (float) > *result = 0 ;
48903
48904   {
48905     try {
48906       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
48907     } catch (std::out_of_range& e) {
48908       {
48909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48910       };
48911     } catch (std::exception& e) {
48912       {
48913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48914       };
48915     } catch (...) {
48916       {
48917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48918       };
48919     }
48920   }
48921   jresult = (void *)result;
48922   return jresult;
48923 }
48924
48925
48926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
48927   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48928
48929   arg1 = (Dali::Signal< void (float) > *)jarg1;
48930   {
48931     try {
48932       delete arg1;
48933     } catch (std::out_of_range& e) {
48934       {
48935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48936       };
48937     } catch (std::exception& e) {
48938       {
48939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48940       };
48941     } catch (...) {
48942       {
48943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48944       };
48945     }
48946   }
48947 }
48948
48949
48950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
48951   unsigned int jresult ;
48952   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48953   bool result;
48954
48955   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48956   {
48957     try {
48958       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48959     } catch (std::out_of_range& e) {
48960       {
48961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48962       };
48963     } catch (std::exception& e) {
48964       {
48965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48966       };
48967     } catch (...) {
48968       {
48969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48970       };
48971     }
48972   }
48973   jresult = result;
48974   return jresult;
48975 }
48976
48977
48978 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
48979   unsigned long jresult ;
48980   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48981   std::size_t result;
48982
48983   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48984   {
48985     try {
48986       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48987     } catch (std::out_of_range& e) {
48988       {
48989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48990       };
48991     } catch (std::exception& e) {
48992       {
48993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48994       };
48995     } catch (...) {
48996       {
48997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48998       };
48999     }
49000   }
49001   jresult = (unsigned long)result;
49002   return jresult;
49003 }
49004
49005
49006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49007   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49008   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49009
49010   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49011   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49012   {
49013     try {
49014       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49015     } catch (std::out_of_range& e) {
49016       {
49017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49018       };
49019     } catch (std::exception& e) {
49020       {
49021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49022       };
49023     } catch (...) {
49024       {
49025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49026       };
49027     }
49028   }
49029 }
49030
49031
49032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49033   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49034   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49035
49036   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49037   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49038   {
49039     try {
49040       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49041     } catch (std::out_of_range& e) {
49042       {
49043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49044       };
49045     } catch (std::exception& e) {
49046       {
49047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49048       };
49049     } catch (...) {
49050       {
49051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49052       };
49053     }
49054   }
49055 }
49056
49057
49058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49059   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49060   Dali::BaseHandle arg2 ;
49061   Dali::BaseHandle *argp2 ;
49062
49063   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49064   argp2 = (Dali::BaseHandle *)jarg2;
49065   if (!argp2) {
49066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49067     return ;
49068   }
49069   arg2 = *argp2;
49070   {
49071     try {
49072       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49073     } catch (std::out_of_range& e) {
49074       {
49075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49076       };
49077     } catch (std::exception& e) {
49078       {
49079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49080       };
49081     } catch (...) {
49082       {
49083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49084       };
49085     }
49086   }
49087 }
49088
49089
49090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49091   void * jresult ;
49092   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49093
49094   {
49095     try {
49096       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49097     } catch (std::out_of_range& e) {
49098       {
49099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49100       };
49101     } catch (std::exception& e) {
49102       {
49103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49104       };
49105     } catch (...) {
49106       {
49107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49108       };
49109     }
49110   }
49111   jresult = (void *)result;
49112   return jresult;
49113 }
49114
49115
49116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49117   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49118
49119   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49120   {
49121     try {
49122       delete arg1;
49123     } catch (std::out_of_range& e) {
49124       {
49125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49126       };
49127     } catch (std::exception& e) {
49128       {
49129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49130       };
49131     } catch (...) {
49132       {
49133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49134       };
49135     }
49136   }
49137 }
49138
49139
49140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49141   unsigned int jresult ;
49142   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49143   bool result;
49144
49145   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49146   {
49147     try {
49148       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49149     } catch (std::out_of_range& e) {
49150       {
49151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49152       };
49153     } catch (std::exception& e) {
49154       {
49155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49156       };
49157     } catch (...) {
49158       {
49159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49160       };
49161     }
49162   }
49163   jresult = result;
49164   return jresult;
49165 }
49166
49167
49168 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49169   unsigned long jresult ;
49170   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49171   std::size_t result;
49172
49173   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49174   {
49175     try {
49176       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49177     } catch (std::out_of_range& e) {
49178       {
49179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49180       };
49181     } catch (std::exception& e) {
49182       {
49183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49184       };
49185     } catch (...) {
49186       {
49187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49188       };
49189     }
49190   }
49191   jresult = (unsigned long)result;
49192   return jresult;
49193 }
49194
49195
49196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49197   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49198   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49199
49200   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49201   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49202   {
49203     try {
49204       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49205     } catch (std::out_of_range& e) {
49206       {
49207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49208       };
49209     } catch (std::exception& e) {
49210       {
49211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49212       };
49213     } catch (...) {
49214       {
49215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49216       };
49217     }
49218   }
49219 }
49220
49221
49222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49223   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49224   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49225
49226   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49227   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49228   {
49229     try {
49230       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49231     } catch (std::out_of_range& e) {
49232       {
49233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49234       };
49235     } catch (std::exception& e) {
49236       {
49237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49238       };
49239     } catch (...) {
49240       {
49241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49242       };
49243     }
49244   }
49245 }
49246
49247
49248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49249   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49250   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49251
49252   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49253   arg2 = (Dali::RefObject *)jarg2;
49254   {
49255     try {
49256       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49257     } catch (std::out_of_range& e) {
49258       {
49259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49260       };
49261     } catch (std::exception& e) {
49262       {
49263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49264       };
49265     } catch (...) {
49266       {
49267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49268       };
49269     }
49270   }
49271 }
49272
49273
49274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49275   void * jresult ;
49276   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49277
49278   {
49279     try {
49280       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49281     } catch (std::out_of_range& e) {
49282       {
49283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49284       };
49285     } catch (std::exception& e) {
49286       {
49287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49288       };
49289     } catch (...) {
49290       {
49291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49292       };
49293     }
49294   }
49295   jresult = (void *)result;
49296   return jresult;
49297 }
49298
49299
49300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49301   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49302
49303   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49304   {
49305     try {
49306       delete arg1;
49307     } catch (std::out_of_range& e) {
49308       {
49309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49310       };
49311     } catch (std::exception& e) {
49312       {
49313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49314       };
49315     } catch (...) {
49316       {
49317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49318       };
49319     }
49320   }
49321 }
49322
49323
49324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49325   unsigned int jresult ;
49326   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49327   bool result;
49328
49329   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49330   {
49331     try {
49332       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49333     } catch (std::out_of_range& e) {
49334       {
49335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49336       };
49337     } catch (std::exception& e) {
49338       {
49339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49340       };
49341     } catch (...) {
49342       {
49343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49344       };
49345     }
49346   }
49347   jresult = result;
49348   return jresult;
49349 }
49350
49351
49352 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49353   unsigned long jresult ;
49354   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49355   std::size_t result;
49356
49357   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49358   {
49359     try {
49360       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49361     } catch (std::out_of_range& e) {
49362       {
49363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49364       };
49365     } catch (std::exception& e) {
49366       {
49367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49368       };
49369     } catch (...) {
49370       {
49371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49372       };
49373     }
49374   }
49375   jresult = (unsigned long)result;
49376   return jresult;
49377 }
49378
49379
49380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49381   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49382   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49383
49384   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49385   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49386   {
49387     try {
49388       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49389     } catch (std::out_of_range& e) {
49390       {
49391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49392       };
49393     } catch (std::exception& e) {
49394       {
49395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49396       };
49397     } catch (...) {
49398       {
49399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49400       };
49401     }
49402   }
49403 }
49404
49405
49406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49407   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49408   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49409
49410   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49411   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49412   {
49413     try {
49414       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49415     } catch (std::out_of_range& e) {
49416       {
49417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49418       };
49419     } catch (std::exception& e) {
49420       {
49421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49422       };
49423     } catch (...) {
49424       {
49425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49426       };
49427     }
49428   }
49429 }
49430
49431
49432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49433   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49434   Dali::PropertyNotification *arg2 = 0 ;
49435
49436   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49437   arg2 = (Dali::PropertyNotification *)jarg2;
49438   if (!arg2) {
49439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49440     return ;
49441   }
49442   {
49443     try {
49444       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49445     } catch (std::out_of_range& e) {
49446       {
49447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49448       };
49449     } catch (std::exception& e) {
49450       {
49451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49452       };
49453     } catch (...) {
49454       {
49455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49456       };
49457     }
49458   }
49459 }
49460
49461
49462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49463   void * jresult ;
49464   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49465
49466   {
49467     try {
49468       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49469     } catch (std::out_of_range& e) {
49470       {
49471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49472       };
49473     } catch (std::exception& e) {
49474       {
49475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49476       };
49477     } catch (...) {
49478       {
49479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49480       };
49481     }
49482   }
49483   jresult = (void *)result;
49484   return jresult;
49485 }
49486
49487
49488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49489   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49490
49491   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49492   {
49493     try {
49494       delete arg1;
49495     } catch (std::out_of_range& e) {
49496       {
49497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49498       };
49499     } catch (std::exception& e) {
49500       {
49501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49502       };
49503     } catch (...) {
49504       {
49505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49506       };
49507     }
49508   }
49509 }
49510
49511
49512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49513   unsigned int jresult ;
49514   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49515   bool result;
49516
49517   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49518   {
49519     try {
49520       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49521     } catch (std::out_of_range& e) {
49522       {
49523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49524       };
49525     } catch (std::exception& e) {
49526       {
49527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49528       };
49529     } catch (...) {
49530       {
49531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49532       };
49533     }
49534   }
49535   jresult = result;
49536   return jresult;
49537 }
49538
49539
49540 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49541   unsigned long jresult ;
49542   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49543   std::size_t result;
49544
49545   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49546   {
49547     try {
49548       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49549     } catch (std::out_of_range& e) {
49550       {
49551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49552       };
49553     } catch (std::exception& e) {
49554       {
49555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49556       };
49557     } catch (...) {
49558       {
49559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49560       };
49561     }
49562   }
49563   jresult = (unsigned long)result;
49564   return jresult;
49565 }
49566
49567
49568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49569   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49570   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49571
49572   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49573   arg2 = (void (*)(Dali::Image))jarg2;
49574   {
49575     try {
49576       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49577     } catch (std::out_of_range& e) {
49578       {
49579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49580       };
49581     } catch (std::exception& e) {
49582       {
49583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49584       };
49585     } catch (...) {
49586       {
49587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49588       };
49589     }
49590   }
49591 }
49592
49593
49594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49595   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49596   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49597
49598   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49599   arg2 = (void (*)(Dali::Image))jarg2;
49600   {
49601     try {
49602       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49603     } catch (std::out_of_range& e) {
49604       {
49605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49606       };
49607     } catch (std::exception& e) {
49608       {
49609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49610       };
49611     } catch (...) {
49612       {
49613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49614       };
49615     }
49616   }
49617 }
49618
49619
49620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49621   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49622   Dali::Image arg2 ;
49623   Dali::Image *argp2 ;
49624
49625   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49626   argp2 = (Dali::Image *)jarg2;
49627   if (!argp2) {
49628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49629     return ;
49630   }
49631   arg2 = *argp2;
49632   {
49633     try {
49634       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49635     } catch (std::out_of_range& e) {
49636       {
49637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49638       };
49639     } catch (std::exception& e) {
49640       {
49641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49642       };
49643     } catch (...) {
49644       {
49645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49646       };
49647     }
49648   }
49649 }
49650
49651
49652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49653   void * jresult ;
49654   Dali::Signal< void (Dali::Image) > *result = 0 ;
49655
49656   {
49657     try {
49658       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49659     } catch (std::out_of_range& e) {
49660       {
49661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49662       };
49663     } catch (std::exception& e) {
49664       {
49665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49666       };
49667     } catch (...) {
49668       {
49669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49670       };
49671     }
49672   }
49673   jresult = (void *)result;
49674   return jresult;
49675 }
49676
49677
49678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49679   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49680
49681   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49682   {
49683     try {
49684       delete arg1;
49685     } catch (std::out_of_range& e) {
49686       {
49687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49688       };
49689     } catch (std::exception& e) {
49690       {
49691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49692       };
49693     } catch (...) {
49694       {
49695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49696       };
49697     }
49698   }
49699 }
49700
49701
49702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49703   void * jresult ;
49704   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49705
49706   {
49707     try {
49708       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49709     } catch (std::out_of_range& e) {
49710       {
49711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49712       };
49713     } catch (std::exception& e) {
49714       {
49715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49716       };
49717     } catch (...) {
49718       {
49719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49720       };
49721     }
49722   }
49723   jresult = (void *)result;
49724   return jresult;
49725 }
49726
49727
49728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49729   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49730
49731   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49732   {
49733     try {
49734       delete arg1;
49735     } catch (std::out_of_range& e) {
49736       {
49737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49738       };
49739     } catch (std::exception& e) {
49740       {
49741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49742       };
49743     } catch (...) {
49744       {
49745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49746       };
49747     }
49748   }
49749 }
49750
49751
49752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49753   unsigned int jresult ;
49754   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49755   bool result;
49756
49757   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49758   {
49759     try {
49760       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);
49761     } catch (std::out_of_range& e) {
49762       {
49763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49764       };
49765     } catch (std::exception& e) {
49766       {
49767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49768       };
49769     } catch (...) {
49770       {
49771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49772       };
49773     }
49774   }
49775   jresult = result;
49776   return jresult;
49777 }
49778
49779
49780 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49781   unsigned long jresult ;
49782   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49783   std::size_t result;
49784
49785   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49786   {
49787     try {
49788       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);
49789     } catch (std::out_of_range& e) {
49790       {
49791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49792       };
49793     } catch (std::exception& e) {
49794       {
49795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49796       };
49797     } catch (...) {
49798       {
49799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49800       };
49801     }
49802   }
49803   jresult = (unsigned long)result;
49804   return jresult;
49805 }
49806
49807
49808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49809   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49810   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49811
49812   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49813   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49814   {
49815     try {
49816       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49817     } catch (std::out_of_range& e) {
49818       {
49819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49820       };
49821     } catch (std::exception& e) {
49822       {
49823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49824       };
49825     } catch (...) {
49826       {
49827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49828       };
49829     }
49830   }
49831 }
49832
49833
49834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49835   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49836   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49837
49838   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49839   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49840   {
49841     try {
49842       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49843     } catch (std::out_of_range& e) {
49844       {
49845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49846       };
49847     } catch (std::exception& e) {
49848       {
49849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49850       };
49851     } catch (...) {
49852       {
49853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49854       };
49855     }
49856   }
49857 }
49858
49859
49860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49861   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49862   Dali::Actor arg2 ;
49863   Dali::LongPressGesture *arg3 = 0 ;
49864   Dali::Actor *argp2 ;
49865
49866   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49867   argp2 = (Dali::Actor *)jarg2;
49868   if (!argp2) {
49869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49870     return ;
49871   }
49872   arg2 = *argp2;
49873   arg3 = (Dali::LongPressGesture *)jarg3;
49874   if (!arg3) {
49875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
49876     return ;
49877   }
49878   {
49879     try {
49880       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
49881     } catch (std::out_of_range& e) {
49882       {
49883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49884       };
49885     } catch (std::exception& e) {
49886       {
49887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49888       };
49889     } catch (...) {
49890       {
49891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49892       };
49893     }
49894   }
49895 }
49896
49897
49898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
49899   void * jresult ;
49900   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
49901
49902   {
49903     try {
49904       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
49905     } catch (std::out_of_range& e) {
49906       {
49907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49908       };
49909     } catch (std::exception& e) {
49910       {
49911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49912       };
49913     } catch (...) {
49914       {
49915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49916       };
49917     }
49918   }
49919   jresult = (void *)result;
49920   return jresult;
49921 }
49922
49923
49924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
49925   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49926
49927   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49928   {
49929     try {
49930       delete arg1;
49931     } catch (std::out_of_range& e) {
49932       {
49933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49934       };
49935     } catch (std::exception& e) {
49936       {
49937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49938       };
49939     } catch (...) {
49940       {
49941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49942       };
49943     }
49944   }
49945 }
49946
49947
49948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
49949   unsigned int jresult ;
49950   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49951   bool result;
49952
49953   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49954   {
49955     try {
49956       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);
49957     } catch (std::out_of_range& e) {
49958       {
49959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49960       };
49961     } catch (std::exception& e) {
49962       {
49963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49964       };
49965     } catch (...) {
49966       {
49967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49968       };
49969     }
49970   }
49971   jresult = result;
49972   return jresult;
49973 }
49974
49975
49976 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
49977   unsigned long jresult ;
49978   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49979   std::size_t result;
49980
49981   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49982   {
49983     try {
49984       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);
49985     } catch (std::out_of_range& e) {
49986       {
49987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49988       };
49989     } catch (std::exception& e) {
49990       {
49991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49992       };
49993     } catch (...) {
49994       {
49995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49996       };
49997     }
49998   }
49999   jresult = (unsigned long)result;
50000   return jresult;
50001 }
50002
50003
50004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50005   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50006   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50007
50008   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50009   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50010   {
50011     try {
50012       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50013     } catch (std::out_of_range& e) {
50014       {
50015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50016       };
50017     } catch (std::exception& e) {
50018       {
50019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50020       };
50021     } catch (...) {
50022       {
50023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50024       };
50025     }
50026   }
50027 }
50028
50029
50030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50031   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50032   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50033
50034   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50035   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50036   {
50037     try {
50038       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50039     } catch (std::out_of_range& e) {
50040       {
50041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50042       };
50043     } catch (std::exception& e) {
50044       {
50045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50046       };
50047     } catch (...) {
50048       {
50049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50050       };
50051     }
50052   }
50053 }
50054
50055
50056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50057   unsigned int jresult ;
50058   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50059   Dali::Actor arg2 ;
50060   Dali::TouchData *arg3 = 0 ;
50061   Dali::Actor *argp2 ;
50062   bool result;
50063
50064   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50065   argp2 = (Dali::Actor *)jarg2;
50066   if (!argp2) {
50067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50068     return 0;
50069   }
50070   arg2 = *argp2;
50071   arg3 = (Dali::TouchData *)jarg3;
50072   if (!arg3) {
50073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50074     return 0;
50075   }
50076   {
50077     try {
50078       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50079     } catch (std::out_of_range& e) {
50080       {
50081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50082       };
50083     } catch (std::exception& e) {
50084       {
50085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50086       };
50087     } catch (...) {
50088       {
50089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50090       };
50091     }
50092   }
50093   jresult = result;
50094   return jresult;
50095 }
50096
50097
50098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50099   void * jresult ;
50100   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50101
50102   {
50103     try {
50104       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50105     } catch (std::out_of_range& e) {
50106       {
50107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50108       };
50109     } catch (std::exception& e) {
50110       {
50111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50112       };
50113     } catch (...) {
50114       {
50115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50116       };
50117     }
50118   }
50119   jresult = (void *)result;
50120   return jresult;
50121 }
50122
50123
50124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50125   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50126
50127   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50128   {
50129     try {
50130       delete arg1;
50131     } catch (std::out_of_range& e) {
50132       {
50133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50134       };
50135     } catch (std::exception& e) {
50136       {
50137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50138       };
50139     } catch (...) {
50140       {
50141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50142       };
50143     }
50144   }
50145 }
50146
50147
50148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50149   unsigned int jresult ;
50150   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50151   bool result;
50152
50153   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50154   {
50155     try {
50156       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);
50157     } catch (std::out_of_range& e) {
50158       {
50159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50160       };
50161     } catch (std::exception& e) {
50162       {
50163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50164       };
50165     } catch (...) {
50166       {
50167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50168       };
50169     }
50170   }
50171   jresult = result;
50172   return jresult;
50173 }
50174
50175
50176 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50177   unsigned long jresult ;
50178   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50179   std::size_t result;
50180
50181   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50182   {
50183     try {
50184       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);
50185     } catch (std::out_of_range& e) {
50186       {
50187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50188       };
50189     } catch (std::exception& e) {
50190       {
50191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50192       };
50193     } catch (...) {
50194       {
50195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50196       };
50197     }
50198   }
50199   jresult = (unsigned long)result;
50200   return jresult;
50201 }
50202
50203
50204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50205   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50206   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50207
50208   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50209   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50210   {
50211     try {
50212       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50213     } catch (std::out_of_range& e) {
50214       {
50215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50216       };
50217     } catch (std::exception& e) {
50218       {
50219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50220       };
50221     } catch (...) {
50222       {
50223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50224       };
50225     }
50226   }
50227 }
50228
50229
50230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50231   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50232   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50233
50234   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50235   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50236   {
50237     try {
50238       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50239     } catch (std::out_of_range& e) {
50240       {
50241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50242       };
50243     } catch (std::exception& e) {
50244       {
50245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50246       };
50247     } catch (...) {
50248       {
50249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50250       };
50251     }
50252   }
50253 }
50254
50255
50256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50257   unsigned int jresult ;
50258   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50259   Dali::Actor arg2 ;
50260   Dali::HoverEvent *arg3 = 0 ;
50261   Dali::Actor *argp2 ;
50262   bool result;
50263
50264   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50265   argp2 = (Dali::Actor *)jarg2;
50266   if (!argp2) {
50267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50268     return 0;
50269   }
50270   arg2 = *argp2;
50271   arg3 = (Dali::HoverEvent *)jarg3;
50272   if (!arg3) {
50273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50274     return 0;
50275   }
50276   {
50277     try {
50278       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50279     } catch (std::out_of_range& e) {
50280       {
50281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50282       };
50283     } catch (std::exception& e) {
50284       {
50285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50286       };
50287     } catch (...) {
50288       {
50289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50290       };
50291     }
50292   }
50293   jresult = result;
50294   return jresult;
50295 }
50296
50297
50298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50299   void * jresult ;
50300   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50301
50302   {
50303     try {
50304       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50305     } catch (std::out_of_range& e) {
50306       {
50307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50308       };
50309     } catch (std::exception& e) {
50310       {
50311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50312       };
50313     } catch (...) {
50314       {
50315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50316       };
50317     }
50318   }
50319   jresult = (void *)result;
50320   return jresult;
50321 }
50322
50323
50324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50325   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50326
50327   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50328   {
50329     try {
50330       delete arg1;
50331     } catch (std::out_of_range& e) {
50332       {
50333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50334       };
50335     } catch (std::exception& e) {
50336       {
50337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50338       };
50339     } catch (...) {
50340       {
50341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50342       };
50343     }
50344   }
50345 }
50346
50347
50348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50349   unsigned int jresult ;
50350   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50351   bool result;
50352
50353   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50354   {
50355     try {
50356       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);
50357     } catch (std::out_of_range& e) {
50358       {
50359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50360       };
50361     } catch (std::exception& e) {
50362       {
50363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50364       };
50365     } catch (...) {
50366       {
50367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50368       };
50369     }
50370   }
50371   jresult = result;
50372   return jresult;
50373 }
50374
50375
50376 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50377   unsigned long jresult ;
50378   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50379   std::size_t result;
50380
50381   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50382   {
50383     try {
50384       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);
50385     } catch (std::out_of_range& e) {
50386       {
50387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50388       };
50389     } catch (std::exception& e) {
50390       {
50391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50392       };
50393     } catch (...) {
50394       {
50395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50396       };
50397     }
50398   }
50399   jresult = (unsigned long)result;
50400   return jresult;
50401 }
50402
50403
50404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50405   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50406   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50407
50408   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50409   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50410   {
50411     try {
50412       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50413     } catch (std::out_of_range& e) {
50414       {
50415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50416       };
50417     } catch (std::exception& e) {
50418       {
50419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50420       };
50421     } catch (...) {
50422       {
50423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50424       };
50425     }
50426   }
50427 }
50428
50429
50430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50431   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50432   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50433
50434   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50435   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50436   {
50437     try {
50438       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50439     } catch (std::out_of_range& e) {
50440       {
50441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50442       };
50443     } catch (std::exception& e) {
50444       {
50445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50446       };
50447     } catch (...) {
50448       {
50449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50450       };
50451     }
50452   }
50453 }
50454
50455
50456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50457   unsigned int jresult ;
50458   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50459   Dali::Actor arg2 ;
50460   Dali::WheelEvent *arg3 = 0 ;
50461   Dali::Actor *argp2 ;
50462   bool result;
50463
50464   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50465   argp2 = (Dali::Actor *)jarg2;
50466   if (!argp2) {
50467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50468     return 0;
50469   }
50470   arg2 = *argp2;
50471   arg3 = (Dali::WheelEvent *)jarg3;
50472   if (!arg3) {
50473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50474     return 0;
50475   }
50476   {
50477     try {
50478       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50479     } catch (std::out_of_range& e) {
50480       {
50481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50482       };
50483     } catch (std::exception& e) {
50484       {
50485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50486       };
50487     } catch (...) {
50488       {
50489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50490       };
50491     }
50492   }
50493   jresult = result;
50494   return jresult;
50495 }
50496
50497
50498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50499   void * jresult ;
50500   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50501
50502   {
50503     try {
50504       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50505     } catch (std::out_of_range& e) {
50506       {
50507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50508       };
50509     } catch (std::exception& e) {
50510       {
50511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50512       };
50513     } catch (...) {
50514       {
50515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50516       };
50517     }
50518   }
50519   jresult = (void *)result;
50520   return jresult;
50521 }
50522
50523
50524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50525   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50526
50527   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50528   {
50529     try {
50530       delete arg1;
50531     } catch (std::out_of_range& e) {
50532       {
50533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50534       };
50535     } catch (std::exception& e) {
50536       {
50537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50538       };
50539     } catch (...) {
50540       {
50541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50542       };
50543     }
50544   }
50545 }
50546
50547
50548 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50549   unsigned int jresult ;
50550   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50551   bool result;
50552
50553   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50554   {
50555     try {
50556       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50557     } catch (std::out_of_range& e) {
50558       {
50559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50560       };
50561     } catch (std::exception& e) {
50562       {
50563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50564       };
50565     } catch (...) {
50566       {
50567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50568       };
50569     }
50570   }
50571   jresult = result;
50572   return jresult;
50573 }
50574
50575
50576 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50577   unsigned long jresult ;
50578   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50579   std::size_t result;
50580
50581   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50582   {
50583     try {
50584       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50585     } catch (std::out_of_range& e) {
50586       {
50587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50588       };
50589     } catch (std::exception& e) {
50590       {
50591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50592       };
50593     } catch (...) {
50594       {
50595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50596       };
50597     }
50598   }
50599   jresult = (unsigned long)result;
50600   return jresult;
50601 }
50602
50603
50604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50605   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50606   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50607
50608   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50609   arg2 = (void (*)(Dali::Actor))jarg2;
50610   {
50611     try {
50612       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50613     } catch (std::out_of_range& e) {
50614       {
50615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50616       };
50617     } catch (std::exception& e) {
50618       {
50619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50620       };
50621     } catch (...) {
50622       {
50623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50624       };
50625     }
50626   }
50627 }
50628
50629
50630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50631   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50632   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50633
50634   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50635   arg2 = (void (*)(Dali::Actor))jarg2;
50636   {
50637     try {
50638       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50639     } catch (std::out_of_range& e) {
50640       {
50641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50642       };
50643     } catch (std::exception& e) {
50644       {
50645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50646       };
50647     } catch (...) {
50648       {
50649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50650       };
50651     }
50652   }
50653 }
50654
50655
50656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50657   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50658   Dali::Actor arg2 ;
50659   Dali::Actor *argp2 ;
50660
50661   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50662   argp2 = (Dali::Actor *)jarg2;
50663   if (!argp2) {
50664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50665     return ;
50666   }
50667   arg2 = *argp2;
50668   {
50669     try {
50670       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50671     } catch (std::out_of_range& e) {
50672       {
50673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50674       };
50675     } catch (std::exception& e) {
50676       {
50677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50678       };
50679     } catch (...) {
50680       {
50681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50682       };
50683     }
50684   }
50685 }
50686
50687
50688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50689   void * jresult ;
50690   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50691
50692   {
50693     try {
50694       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50695     } catch (std::out_of_range& e) {
50696       {
50697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50698       };
50699     } catch (std::exception& e) {
50700       {
50701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50702       };
50703     } catch (...) {
50704       {
50705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50706       };
50707     }
50708   }
50709   jresult = (void *)result;
50710   return jresult;
50711 }
50712
50713
50714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50715   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50716
50717   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50718   {
50719     try {
50720       delete arg1;
50721     } catch (std::out_of_range& e) {
50722       {
50723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50724       };
50725     } catch (std::exception& e) {
50726       {
50727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50728       };
50729     } catch (...) {
50730       {
50731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50732       };
50733     }
50734   }
50735 }
50736
50737
50738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50739   unsigned int jresult ;
50740   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50741   bool result;
50742
50743   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50744   {
50745     try {
50746       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50747     } catch (std::out_of_range& e) {
50748       {
50749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50750       };
50751     } catch (std::exception& e) {
50752       {
50753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50754       };
50755     } catch (...) {
50756       {
50757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50758       };
50759     }
50760   }
50761   jresult = result;
50762   return jresult;
50763 }
50764
50765
50766 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50767   unsigned long jresult ;
50768   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50769   std::size_t result;
50770
50771   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50772   {
50773     try {
50774       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50775     } catch (std::out_of_range& e) {
50776       {
50777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50778       };
50779     } catch (std::exception& e) {
50780       {
50781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50782       };
50783     } catch (...) {
50784       {
50785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50786       };
50787     }
50788   }
50789   jresult = (unsigned long)result;
50790   return jresult;
50791 }
50792
50793
50794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50795   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50796   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50797
50798   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50799   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50800   {
50801     try {
50802       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50803     } catch (std::out_of_range& e) {
50804       {
50805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50806       };
50807     } catch (std::exception& e) {
50808       {
50809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50810       };
50811     } catch (...) {
50812       {
50813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50814       };
50815     }
50816   }
50817 }
50818
50819
50820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
50821   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50822   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50823
50824   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50825   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50826   {
50827     try {
50828       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50829     } catch (std::out_of_range& e) {
50830       {
50831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50832       };
50833     } catch (std::exception& e) {
50834       {
50835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50836       };
50837     } catch (...) {
50838       {
50839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50840       };
50841     }
50842   }
50843 }
50844
50845
50846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
50847   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50848   Dali::KeyEvent *arg2 = 0 ;
50849
50850   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50851   arg2 = (Dali::KeyEvent *)jarg2;
50852   if (!arg2) {
50853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
50854     return ;
50855   }
50856   {
50857     try {
50858       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
50859     } catch (std::out_of_range& e) {
50860       {
50861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50862       };
50863     } catch (std::exception& e) {
50864       {
50865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50866       };
50867     } catch (...) {
50868       {
50869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50870       };
50871     }
50872   }
50873 }
50874
50875
50876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
50877   void * jresult ;
50878   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
50879
50880   {
50881     try {
50882       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
50883     } catch (std::out_of_range& e) {
50884       {
50885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50886       };
50887     } catch (std::exception& e) {
50888       {
50889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50890       };
50891     } catch (...) {
50892       {
50893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50894       };
50895     }
50896   }
50897   jresult = (void *)result;
50898   return jresult;
50899 }
50900
50901
50902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
50903   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50904
50905   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50906   {
50907     try {
50908       delete arg1;
50909     } catch (std::out_of_range& e) {
50910       {
50911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50912       };
50913     } catch (std::exception& e) {
50914       {
50915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50916       };
50917     } catch (...) {
50918       {
50919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50920       };
50921     }
50922   }
50923 }
50924
50925
50926 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
50927   unsigned int jresult ;
50928   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50929   bool result;
50930
50931   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50932   {
50933     try {
50934       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50935     } catch (std::out_of_range& e) {
50936       {
50937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50938       };
50939     } catch (std::exception& e) {
50940       {
50941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50942       };
50943     } catch (...) {
50944       {
50945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50946       };
50947     }
50948   }
50949   jresult = result;
50950   return jresult;
50951 }
50952
50953
50954 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
50955   unsigned long jresult ;
50956   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50957   std::size_t result;
50958
50959   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50960   {
50961     try {
50962       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50963     } catch (std::out_of_range& e) {
50964       {
50965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50966       };
50967     } catch (std::exception& e) {
50968       {
50969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50970       };
50971     } catch (...) {
50972       {
50973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50974       };
50975     }
50976   }
50977   jresult = (unsigned long)result;
50978   return jresult;
50979 }
50980
50981
50982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
50983   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50984   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
50985
50986   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50987   arg2 = (void (*)(Dali::TouchData const &))jarg2;
50988   {
50989     try {
50990       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50991     } catch (std::out_of_range& e) {
50992       {
50993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50994       };
50995     } catch (std::exception& e) {
50996       {
50997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50998       };
50999     } catch (...) {
51000       {
51001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51002       };
51003     }
51004   }
51005 }
51006
51007
51008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51009   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51010   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51011
51012   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51013   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51014   {
51015     try {
51016       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51017     } catch (std::out_of_range& e) {
51018       {
51019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51020       };
51021     } catch (std::exception& e) {
51022       {
51023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51024       };
51025     } catch (...) {
51026       {
51027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51028       };
51029     }
51030   }
51031 }
51032
51033
51034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51035   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51036   Dali::TouchData *arg2 = 0 ;
51037
51038   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51039   arg2 = (Dali::TouchData *)jarg2;
51040   if (!arg2) {
51041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51042     return ;
51043   }
51044   {
51045     try {
51046       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51047     } catch (std::out_of_range& e) {
51048       {
51049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51050       };
51051     } catch (std::exception& e) {
51052       {
51053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51054       };
51055     } catch (...) {
51056       {
51057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51058       };
51059     }
51060   }
51061 }
51062
51063
51064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51065   void * jresult ;
51066   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51067
51068   {
51069     try {
51070       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51071     } catch (std::out_of_range& e) {
51072       {
51073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51074       };
51075     } catch (std::exception& e) {
51076       {
51077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51078       };
51079     } catch (...) {
51080       {
51081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51082       };
51083     }
51084   }
51085   jresult = (void *)result;
51086   return jresult;
51087 }
51088
51089
51090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51091   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51092
51093   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51094   {
51095     try {
51096       delete arg1;
51097     } catch (std::out_of_range& e) {
51098       {
51099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51100       };
51101     } catch (std::exception& e) {
51102       {
51103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51104       };
51105     } catch (...) {
51106       {
51107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51108       };
51109     }
51110   }
51111 }
51112
51113
51114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51115   unsigned int jresult ;
51116   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51117   bool result;
51118
51119   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51120   {
51121     try {
51122       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51123     } catch (std::out_of_range& e) {
51124       {
51125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51126       };
51127     } catch (std::exception& e) {
51128       {
51129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51130       };
51131     } catch (...) {
51132       {
51133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51134       };
51135     }
51136   }
51137   jresult = result;
51138   return jresult;
51139 }
51140
51141
51142 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51143   unsigned long jresult ;
51144   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51145   std::size_t result;
51146
51147   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51148   {
51149     try {
51150       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51151     } catch (std::out_of_range& e) {
51152       {
51153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51154       };
51155     } catch (std::exception& e) {
51156       {
51157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51158       };
51159     } catch (...) {
51160       {
51161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51162       };
51163     }
51164   }
51165   jresult = (unsigned long)result;
51166   return jresult;
51167 }
51168
51169
51170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51171   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51172   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51173
51174   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51175   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51176   {
51177     try {
51178       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51179     } catch (std::out_of_range& e) {
51180       {
51181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51182       };
51183     } catch (std::exception& e) {
51184       {
51185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51186       };
51187     } catch (...) {
51188       {
51189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51190       };
51191     }
51192   }
51193 }
51194
51195
51196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51197   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51198   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51199
51200   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51201   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51202   {
51203     try {
51204       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51205     } catch (std::out_of_range& e) {
51206       {
51207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51208       };
51209     } catch (std::exception& e) {
51210       {
51211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51212       };
51213     } catch (...) {
51214       {
51215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51216       };
51217     }
51218   }
51219 }
51220
51221
51222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51223   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51224   Dali::WheelEvent *arg2 = 0 ;
51225
51226   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51227   arg2 = (Dali::WheelEvent *)jarg2;
51228   if (!arg2) {
51229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51230     return ;
51231   }
51232   {
51233     try {
51234       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51235     } catch (std::out_of_range& e) {
51236       {
51237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51238       };
51239     } catch (std::exception& e) {
51240       {
51241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51242       };
51243     } catch (...) {
51244       {
51245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51246       };
51247     }
51248   }
51249 }
51250
51251
51252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51253   void * jresult ;
51254   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51255
51256   {
51257     try {
51258       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51259     } catch (std::out_of_range& e) {
51260       {
51261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51262       };
51263     } catch (std::exception& e) {
51264       {
51265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51266       };
51267     } catch (...) {
51268       {
51269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51270       };
51271     }
51272   }
51273   jresult = (void *)result;
51274   return jresult;
51275 }
51276
51277
51278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51279   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51280
51281   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51282   {
51283     try {
51284       delete arg1;
51285     } catch (std::out_of_range& e) {
51286       {
51287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51288       };
51289     } catch (std::exception& e) {
51290       {
51291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51292       };
51293     } catch (...) {
51294       {
51295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51296       };
51297     }
51298   }
51299 }
51300
51301
51302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51303   void * jresult ;
51304   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51305
51306   {
51307     try {
51308       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51309     } catch (std::out_of_range& e) {
51310       {
51311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51312       };
51313     } catch (std::exception& e) {
51314       {
51315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51316       };
51317     } catch (...) {
51318       {
51319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51320       };
51321     }
51322   }
51323   jresult = (void *)result;
51324   return jresult;
51325 }
51326
51327
51328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51329   void * jresult ;
51330   Dali::Radian arg1 ;
51331   Dali::Radian arg2 ;
51332   Dali::Radian *argp1 ;
51333   Dali::Radian *argp2 ;
51334   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51335
51336   argp1 = (Dali::Radian *)jarg1;
51337   if (!argp1) {
51338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51339     return 0;
51340   }
51341   arg1 = *argp1;
51342   argp2 = (Dali::Radian *)jarg2;
51343   if (!argp2) {
51344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51345     return 0;
51346   }
51347   arg2 = *argp2;
51348   {
51349     try {
51350       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51351     } catch (std::out_of_range& e) {
51352       {
51353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51354       };
51355     } catch (std::exception& e) {
51356       {
51357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51358       };
51359     } catch (...) {
51360       {
51361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51362       };
51363     }
51364   }
51365   jresult = (void *)result;
51366   return jresult;
51367 }
51368
51369
51370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51371   void * jresult ;
51372   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51373   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51374
51375   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51376   if (!arg1) {
51377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51378     return 0;
51379   }
51380   {
51381     try {
51382       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51383     } catch (std::out_of_range& e) {
51384       {
51385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51386       };
51387     } catch (std::exception& e) {
51388       {
51389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51390       };
51391     } catch (...) {
51392       {
51393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51394       };
51395     }
51396   }
51397   jresult = (void *)result;
51398   return jresult;
51399 }
51400
51401
51402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51403   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51404   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51405
51406   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51407   arg2 = (Dali::Radian *)jarg2;
51408   if (arg1) (arg1)->first = *arg2;
51409 }
51410
51411
51412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51413   void * jresult ;
51414   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51415   Dali::Radian *result = 0 ;
51416
51417   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51418   result = (Dali::Radian *)& ((arg1)->first);
51419   jresult = (void *)result;
51420   return jresult;
51421 }
51422
51423
51424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51425   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51426   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51427
51428   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51429   arg2 = (Dali::Radian *)jarg2;
51430   if (arg1) (arg1)->second = *arg2;
51431 }
51432
51433
51434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51435   void * jresult ;
51436   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51437   Dali::Radian *result = 0 ;
51438
51439   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51440   result = (Dali::Radian *)& ((arg1)->second);
51441   jresult = (void *)result;
51442   return jresult;
51443 }
51444
51445
51446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51447   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51448
51449   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51450   {
51451     try {
51452       delete arg1;
51453     } catch (std::out_of_range& e) {
51454       {
51455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51456       };
51457     } catch (std::exception& e) {
51458       {
51459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51460       };
51461     } catch (...) {
51462       {
51463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51464       };
51465     }
51466   }
51467 }
51468
51469
51470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51471   unsigned int jresult ;
51472   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51473   bool result;
51474
51475   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51476   {
51477     try {
51478       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);
51479     } catch (std::out_of_range& e) {
51480       {
51481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51482       };
51483     } catch (std::exception& e) {
51484       {
51485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51486       };
51487     } catch (...) {
51488       {
51489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51490       };
51491     }
51492   }
51493   jresult = result;
51494   return jresult;
51495 }
51496
51497
51498 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51499   unsigned long jresult ;
51500   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51501   std::size_t result;
51502
51503   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51504   {
51505     try {
51506       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);
51507     } catch (std::out_of_range& e) {
51508       {
51509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51510       };
51511     } catch (std::exception& e) {
51512       {
51513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51514       };
51515     } catch (...) {
51516       {
51517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51518       };
51519     }
51520   }
51521   jresult = (unsigned long)result;
51522   return jresult;
51523 }
51524
51525
51526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51527   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51528   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51529
51530   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51531   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51532   {
51533     try {
51534       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51535     } catch (std::out_of_range& e) {
51536       {
51537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51538       };
51539     } catch (std::exception& e) {
51540       {
51541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51542       };
51543     } catch (...) {
51544       {
51545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51546       };
51547     }
51548   }
51549 }
51550
51551
51552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51553   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51554   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51555
51556   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51557   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51558   {
51559     try {
51560       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51561     } catch (std::out_of_range& e) {
51562       {
51563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51564       };
51565     } catch (std::exception& e) {
51566       {
51567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51568       };
51569     } catch (...) {
51570       {
51571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51572       };
51573     }
51574   }
51575 }
51576
51577
51578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51579   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51580   Dali::Actor arg2 ;
51581   Dali::PanGesture *arg3 = 0 ;
51582   Dali::Actor *argp2 ;
51583
51584   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51585   argp2 = (Dali::Actor *)jarg2;
51586   if (!argp2) {
51587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51588     return ;
51589   }
51590   arg2 = *argp2;
51591   arg3 = (Dali::PanGesture *)jarg3;
51592   if (!arg3) {
51593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51594     return ;
51595   }
51596   {
51597     try {
51598       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51599     } catch (std::out_of_range& e) {
51600       {
51601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51602       };
51603     } catch (std::exception& e) {
51604       {
51605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51606       };
51607     } catch (...) {
51608       {
51609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51610       };
51611     }
51612   }
51613 }
51614
51615
51616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51617   void * jresult ;
51618   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51619
51620   {
51621     try {
51622       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51623     } catch (std::out_of_range& e) {
51624       {
51625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51626       };
51627     } catch (std::exception& e) {
51628       {
51629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51630       };
51631     } catch (...) {
51632       {
51633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51634       };
51635     }
51636   }
51637   jresult = (void *)result;
51638   return jresult;
51639 }
51640
51641
51642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51643   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51644
51645   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51646   {
51647     try {
51648       delete arg1;
51649     } catch (std::out_of_range& e) {
51650       {
51651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51652       };
51653     } catch (std::exception& e) {
51654       {
51655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51656       };
51657     } catch (...) {
51658       {
51659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51660       };
51661     }
51662   }
51663 }
51664
51665
51666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51667   unsigned int jresult ;
51668   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51669   bool result;
51670
51671   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51672   {
51673     try {
51674       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);
51675     } catch (std::out_of_range& e) {
51676       {
51677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51678       };
51679     } catch (std::exception& e) {
51680       {
51681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51682       };
51683     } catch (...) {
51684       {
51685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51686       };
51687     }
51688   }
51689   jresult = result;
51690   return jresult;
51691 }
51692
51693
51694 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51695   unsigned long jresult ;
51696   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51697   std::size_t result;
51698
51699   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51700   {
51701     try {
51702       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);
51703     } catch (std::out_of_range& e) {
51704       {
51705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51706       };
51707     } catch (std::exception& e) {
51708       {
51709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51710       };
51711     } catch (...) {
51712       {
51713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51714       };
51715     }
51716   }
51717   jresult = (unsigned long)result;
51718   return jresult;
51719 }
51720
51721
51722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51723   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51724   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51725
51726   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51727   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51728   {
51729     try {
51730       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51731     } catch (std::out_of_range& e) {
51732       {
51733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51734       };
51735     } catch (std::exception& e) {
51736       {
51737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51738       };
51739     } catch (...) {
51740       {
51741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51742       };
51743     }
51744   }
51745 }
51746
51747
51748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51749   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51750   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51751
51752   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51753   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51754   {
51755     try {
51756       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51757     } catch (std::out_of_range& e) {
51758       {
51759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51760       };
51761     } catch (std::exception& e) {
51762       {
51763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51764       };
51765     } catch (...) {
51766       {
51767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51768       };
51769     }
51770   }
51771 }
51772
51773
51774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51775   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51776   Dali::Actor arg2 ;
51777   Dali::PinchGesture *arg3 = 0 ;
51778   Dali::Actor *argp2 ;
51779
51780   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51781   argp2 = (Dali::Actor *)jarg2;
51782   if (!argp2) {
51783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51784     return ;
51785   }
51786   arg2 = *argp2;
51787   arg3 = (Dali::PinchGesture *)jarg3;
51788   if (!arg3) {
51789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51790     return ;
51791   }
51792   {
51793     try {
51794       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51795     } catch (std::out_of_range& e) {
51796       {
51797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51798       };
51799     } catch (std::exception& e) {
51800       {
51801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51802       };
51803     } catch (...) {
51804       {
51805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51806       };
51807     }
51808   }
51809 }
51810
51811
51812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51813   void * jresult ;
51814   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51815
51816   {
51817     try {
51818       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
51819     } catch (std::out_of_range& e) {
51820       {
51821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51822       };
51823     } catch (std::exception& e) {
51824       {
51825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51826       };
51827     } catch (...) {
51828       {
51829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51830       };
51831     }
51832   }
51833   jresult = (void *)result;
51834   return jresult;
51835 }
51836
51837
51838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
51839   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51840
51841   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51842   {
51843     try {
51844       delete arg1;
51845     } catch (std::out_of_range& e) {
51846       {
51847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51848       };
51849     } catch (std::exception& e) {
51850       {
51851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51852       };
51853     } catch (...) {
51854       {
51855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51856       };
51857     }
51858   }
51859 }
51860
51861
51862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
51863   unsigned int jresult ;
51864   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51865   bool result;
51866
51867   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51868   {
51869     try {
51870       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);
51871     } catch (std::out_of_range& e) {
51872       {
51873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51874       };
51875     } catch (std::exception& e) {
51876       {
51877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51878       };
51879     } catch (...) {
51880       {
51881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51882       };
51883     }
51884   }
51885   jresult = result;
51886   return jresult;
51887 }
51888
51889
51890 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51891   unsigned long jresult ;
51892   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51893   std::size_t result;
51894
51895   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51896   {
51897     try {
51898       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);
51899     } catch (std::out_of_range& e) {
51900       {
51901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51902       };
51903     } catch (std::exception& e) {
51904       {
51905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51906       };
51907     } catch (...) {
51908       {
51909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51910       };
51911     }
51912   }
51913   jresult = (unsigned long)result;
51914   return jresult;
51915 }
51916
51917
51918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51919   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51920   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51921
51922   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51923   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51924   {
51925     try {
51926       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51927     } catch (std::out_of_range& e) {
51928       {
51929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51930       };
51931     } catch (std::exception& e) {
51932       {
51933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51934       };
51935     } catch (...) {
51936       {
51937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51938       };
51939     }
51940   }
51941 }
51942
51943
51944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51945   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51946   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51947
51948   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51949   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51950   {
51951     try {
51952       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51953     } catch (std::out_of_range& e) {
51954       {
51955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51956       };
51957     } catch (std::exception& e) {
51958       {
51959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51960       };
51961     } catch (...) {
51962       {
51963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51964       };
51965     }
51966   }
51967 }
51968
51969
51970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51971   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51972   Dali::Actor arg2 ;
51973   Dali::TapGesture *arg3 = 0 ;
51974   Dali::Actor *argp2 ;
51975
51976   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51977   argp2 = (Dali::Actor *)jarg2;
51978   if (!argp2) {
51979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51980     return ;
51981   }
51982   arg2 = *argp2;
51983   arg3 = (Dali::TapGesture *)jarg3;
51984   if (!arg3) {
51985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
51986     return ;
51987   }
51988   {
51989     try {
51990       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
51991     } catch (std::out_of_range& e) {
51992       {
51993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51994       };
51995     } catch (std::exception& e) {
51996       {
51997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51998       };
51999     } catch (...) {
52000       {
52001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52002       };
52003     }
52004   }
52005 }
52006
52007
52008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52009   void * jresult ;
52010   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52011
52012   {
52013     try {
52014       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52015     } catch (std::out_of_range& e) {
52016       {
52017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52018       };
52019     } catch (std::exception& e) {
52020       {
52021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52022       };
52023     } catch (...) {
52024       {
52025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52026       };
52027     }
52028   }
52029   jresult = (void *)result;
52030   return jresult;
52031 }
52032
52033
52034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52035   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52036
52037   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52038   {
52039     try {
52040       delete arg1;
52041     } catch (std::out_of_range& e) {
52042       {
52043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52044       };
52045     } catch (std::exception& e) {
52046       {
52047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52048       };
52049     } catch (...) {
52050       {
52051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52052       };
52053     }
52054   }
52055 }
52056
52057
52058 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52059   unsigned int jresult ;
52060   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52061   bool result;
52062
52063   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52064   {
52065     try {
52066       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52067     } catch (std::out_of_range& e) {
52068       {
52069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52070       };
52071     } catch (std::exception& e) {
52072       {
52073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52074       };
52075     } catch (...) {
52076       {
52077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52078       };
52079     }
52080   }
52081   jresult = result;
52082   return jresult;
52083 }
52084
52085
52086 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52087   unsigned long jresult ;
52088   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52089   std::size_t result;
52090
52091   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52092   {
52093     try {
52094       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52095     } catch (std::out_of_range& e) {
52096       {
52097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52098       };
52099     } catch (std::exception& e) {
52100       {
52101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52102       };
52103     } catch (...) {
52104       {
52105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52106       };
52107     }
52108   }
52109   jresult = (unsigned long)result;
52110   return jresult;
52111 }
52112
52113
52114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52115   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52116   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52117
52118   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52119   arg2 = (void (*)(Dali::Animation &))jarg2;
52120   {
52121     try {
52122       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52123     } catch (std::out_of_range& e) {
52124       {
52125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52126       };
52127     } catch (std::exception& e) {
52128       {
52129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52130       };
52131     } catch (...) {
52132       {
52133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52134       };
52135     }
52136   }
52137 }
52138
52139
52140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52141   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52142   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52143
52144   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52145   arg2 = (void (*)(Dali::Animation &))jarg2;
52146   {
52147     try {
52148       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52149     } catch (std::out_of_range& e) {
52150       {
52151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52152       };
52153     } catch (std::exception& e) {
52154       {
52155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52156       };
52157     } catch (...) {
52158       {
52159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52160       };
52161     }
52162   }
52163 }
52164
52165
52166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52167   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52168   Dali::Animation *arg2 = 0 ;
52169
52170   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52171   arg2 = (Dali::Animation *)jarg2;
52172   if (!arg2) {
52173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52174     return ;
52175   }
52176   {
52177     try {
52178       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52179     } catch (std::out_of_range& e) {
52180       {
52181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52182       };
52183     } catch (std::exception& e) {
52184       {
52185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52186       };
52187     } catch (...) {
52188       {
52189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52190       };
52191     }
52192   }
52193 }
52194
52195
52196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52197   void * jresult ;
52198   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52199
52200   {
52201     try {
52202       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52203     } catch (std::out_of_range& e) {
52204       {
52205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52206       };
52207     } catch (std::exception& e) {
52208       {
52209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52210       };
52211     } catch (...) {
52212       {
52213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52214       };
52215     }
52216   }
52217   jresult = (void *)result;
52218   return jresult;
52219 }
52220
52221
52222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52223   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52224
52225   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52226   {
52227     try {
52228       delete arg1;
52229     } catch (std::out_of_range& e) {
52230       {
52231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52232       };
52233     } catch (std::exception& e) {
52234       {
52235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52236       };
52237     } catch (...) {
52238       {
52239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52240       };
52241     }
52242   }
52243 }
52244
52245
52246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52247   unsigned int jresult ;
52248   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52249   bool result;
52250
52251   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52252   {
52253     try {
52254       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52255     } catch (std::out_of_range& e) {
52256       {
52257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52258       };
52259     } catch (std::exception& e) {
52260       {
52261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52262       };
52263     } catch (...) {
52264       {
52265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52266       };
52267     }
52268   }
52269   jresult = result;
52270   return jresult;
52271 }
52272
52273
52274 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52275   unsigned long jresult ;
52276   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52277   std::size_t result;
52278
52279   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52280   {
52281     try {
52282       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52283     } catch (std::out_of_range& e) {
52284       {
52285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52286       };
52287     } catch (std::exception& e) {
52288       {
52289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52290       };
52291     } catch (...) {
52292       {
52293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52294       };
52295     }
52296   }
52297   jresult = (unsigned long)result;
52298   return jresult;
52299 }
52300
52301
52302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52303   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52304   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52305
52306   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52307   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52308   {
52309     try {
52310       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52311     } catch (std::out_of_range& e) {
52312       {
52313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52314       };
52315     } catch (std::exception& e) {
52316       {
52317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52318       };
52319     } catch (...) {
52320       {
52321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52322       };
52323     }
52324   }
52325 }
52326
52327
52328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52329   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52330   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52331
52332   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52333   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52334   {
52335     try {
52336       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52337     } catch (std::out_of_range& e) {
52338       {
52339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52340       };
52341     } catch (std::exception& e) {
52342       {
52343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52344       };
52345     } catch (...) {
52346       {
52347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52348       };
52349     }
52350   }
52351 }
52352
52353
52354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52355   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52356   Dali::ResourceImage arg2 ;
52357   Dali::ResourceImage *argp2 ;
52358
52359   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52360   argp2 = (Dali::ResourceImage *)jarg2;
52361   if (!argp2) {
52362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52363     return ;
52364   }
52365   arg2 = *argp2;
52366   {
52367     try {
52368       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52369     } catch (std::out_of_range& e) {
52370       {
52371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52372       };
52373     } catch (std::exception& e) {
52374       {
52375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52376       };
52377     } catch (...) {
52378       {
52379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52380       };
52381     }
52382   }
52383 }
52384
52385
52386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52387   void * jresult ;
52388   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52389
52390   {
52391     try {
52392       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52393     } catch (std::out_of_range& e) {
52394       {
52395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52396       };
52397     } catch (std::exception& e) {
52398       {
52399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52400       };
52401     } catch (...) {
52402       {
52403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52404       };
52405     }
52406   }
52407   jresult = (void *)result;
52408   return jresult;
52409 }
52410
52411
52412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52413   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52414
52415   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52416   {
52417     try {
52418       delete arg1;
52419     } catch (std::out_of_range& e) {
52420       {
52421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52422       };
52423     } catch (std::exception& e) {
52424       {
52425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52426       };
52427     } catch (...) {
52428       {
52429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52430       };
52431     }
52432   }
52433 }
52434
52435
52436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52437   void * jresult ;
52438   Dali::Timer *result = 0 ;
52439
52440   {
52441     try {
52442       result = (Dali::Timer *)new Dali::Timer();
52443     } catch (std::out_of_range& e) {
52444       {
52445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52446       };
52447     } catch (std::exception& e) {
52448       {
52449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52450       };
52451     } catch (...) {
52452       {
52453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52454       };
52455     }
52456   }
52457   jresult = (void *)result;
52458   return jresult;
52459 }
52460
52461
52462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52463   void * jresult ;
52464   unsigned int arg1 ;
52465   Dali::Timer result;
52466
52467   arg1 = (unsigned int)jarg1;
52468   {
52469     try {
52470       result = Dali::Timer::New(arg1);
52471     } catch (std::out_of_range& e) {
52472       {
52473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52474       };
52475     } catch (std::exception& e) {
52476       {
52477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52478       };
52479     } catch (...) {
52480       {
52481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52482       };
52483     }
52484   }
52485   jresult = new Dali::Timer((const Dali::Timer &)result);
52486   return jresult;
52487 }
52488
52489
52490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52491   void * jresult ;
52492   Dali::Timer *arg1 = 0 ;
52493   Dali::Timer *result = 0 ;
52494
52495   arg1 = (Dali::Timer *)jarg1;
52496   if (!arg1) {
52497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52498     return 0;
52499   }
52500   {
52501     try {
52502       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52503     } catch (std::out_of_range& e) {
52504       {
52505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52506       };
52507     } catch (std::exception& e) {
52508       {
52509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52510       };
52511     } catch (...) {
52512       {
52513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52514       };
52515     }
52516   }
52517   jresult = (void *)result;
52518   return jresult;
52519 }
52520
52521
52522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52523   void * jresult ;
52524   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52525   Dali::Timer *arg2 = 0 ;
52526   Dali::Timer *result = 0 ;
52527
52528   arg1 = (Dali::Timer *)jarg1;
52529   arg2 = (Dali::Timer *)jarg2;
52530   if (!arg2) {
52531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52532     return 0;
52533   }
52534   {
52535     try {
52536       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52537     } catch (std::out_of_range& e) {
52538       {
52539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52540       };
52541     } catch (std::exception& e) {
52542       {
52543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52544       };
52545     } catch (...) {
52546       {
52547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52548       };
52549     }
52550   }
52551   jresult = (void *)result;
52552   return jresult;
52553 }
52554
52555
52556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52557   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52558
52559   arg1 = (Dali::Timer *)jarg1;
52560   {
52561     try {
52562       delete arg1;
52563     } catch (std::out_of_range& e) {
52564       {
52565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52566       };
52567     } catch (std::exception& e) {
52568       {
52569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52570       };
52571     } catch (...) {
52572       {
52573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52574       };
52575     }
52576   }
52577 }
52578
52579
52580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52581   void * jresult ;
52582   Dali::BaseHandle arg1 ;
52583   Dali::BaseHandle *argp1 ;
52584   Dali::Timer result;
52585
52586   argp1 = (Dali::BaseHandle *)jarg1;
52587   if (!argp1) {
52588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52589     return 0;
52590   }
52591   arg1 = *argp1;
52592   {
52593     try {
52594       result = Dali::Timer::DownCast(arg1);
52595     } catch (std::out_of_range& e) {
52596       {
52597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52598       };
52599     } catch (std::exception& e) {
52600       {
52601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52602       };
52603     } catch (...) {
52604       {
52605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52606       };
52607     }
52608   }
52609   jresult = new Dali::Timer((const Dali::Timer &)result);
52610   return jresult;
52611 }
52612
52613
52614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52615   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52616
52617   arg1 = (Dali::Timer *)jarg1;
52618   {
52619     try {
52620       (arg1)->Start();
52621     } catch (std::out_of_range& e) {
52622       {
52623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52624       };
52625     } catch (std::exception& e) {
52626       {
52627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52628       };
52629     } catch (...) {
52630       {
52631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52632       };
52633     }
52634   }
52635 }
52636
52637
52638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
52639   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52640
52641   arg1 = (Dali::Timer *)jarg1;
52642   {
52643     try {
52644       (arg1)->Stop();
52645     } catch (std::out_of_range& e) {
52646       {
52647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52648       };
52649     } catch (std::exception& e) {
52650       {
52651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52652       };
52653     } catch (...) {
52654       {
52655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52656       };
52657     }
52658   }
52659 }
52660
52661
52662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
52663   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52664   unsigned int arg2 ;
52665
52666   arg1 = (Dali::Timer *)jarg1;
52667   arg2 = (unsigned int)jarg2;
52668   {
52669     try {
52670       (arg1)->SetInterval(arg2);
52671     } catch (std::out_of_range& e) {
52672       {
52673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52674       };
52675     } catch (std::exception& e) {
52676       {
52677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52678       };
52679     } catch (...) {
52680       {
52681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52682       };
52683     }
52684   }
52685 }
52686
52687
52688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
52689   unsigned int jresult ;
52690   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52691   unsigned int result;
52692
52693   arg1 = (Dali::Timer *)jarg1;
52694   {
52695     try {
52696       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
52697     } catch (std::out_of_range& e) {
52698       {
52699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52700       };
52701     } catch (std::exception& e) {
52702       {
52703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52704       };
52705     } catch (...) {
52706       {
52707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52708       };
52709     }
52710   }
52711   jresult = result;
52712   return jresult;
52713 }
52714
52715
52716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
52717   unsigned int jresult ;
52718   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52719   bool result;
52720
52721   arg1 = (Dali::Timer *)jarg1;
52722   {
52723     try {
52724       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
52725     } catch (std::out_of_range& e) {
52726       {
52727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52728       };
52729     } catch (std::exception& e) {
52730       {
52731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52732       };
52733     } catch (...) {
52734       {
52735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52736       };
52737     }
52738   }
52739   jresult = result;
52740   return jresult;
52741 }
52742
52743
52744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
52745   void * jresult ;
52746   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52747   Dali::Timer::TimerSignalType *result = 0 ;
52748
52749   arg1 = (Dali::Timer *)jarg1;
52750   {
52751     try {
52752       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
52753     } catch (std::out_of_range& e) {
52754       {
52755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52756       };
52757     } catch (std::exception& e) {
52758       {
52759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52760       };
52761     } catch (...) {
52762       {
52763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52764       };
52765     }
52766   }
52767   jresult = (void *)result;
52768   return jresult;
52769 }
52770
52771
52772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
52773   void * jresult ;
52774   Dali::DragAndDropDetector *result = 0 ;
52775
52776   {
52777     try {
52778       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
52779     } catch (std::out_of_range& e) {
52780       {
52781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52782       };
52783     } catch (std::exception& e) {
52784       {
52785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52786       };
52787     } catch (...) {
52788       {
52789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52790       };
52791     }
52792   }
52793   jresult = (void *)result;
52794   return jresult;
52795 }
52796
52797
52798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
52799   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52800
52801   arg1 = (Dali::DragAndDropDetector *)jarg1;
52802   {
52803     try {
52804       delete arg1;
52805     } catch (std::out_of_range& e) {
52806       {
52807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52808       };
52809     } catch (std::exception& e) {
52810       {
52811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52812       };
52813     } catch (...) {
52814       {
52815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52816       };
52817     }
52818   }
52819 }
52820
52821
52822 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
52823   char * jresult ;
52824   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52825   std::string *result = 0 ;
52826
52827   arg1 = (Dali::DragAndDropDetector *)jarg1;
52828   {
52829     try {
52830       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
52831     } catch (std::out_of_range& e) {
52832       {
52833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52834       };
52835     } catch (std::exception& e) {
52836       {
52837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52838       };
52839     } catch (...) {
52840       {
52841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52842       };
52843     }
52844   }
52845   jresult = SWIG_csharp_string_callback(result->c_str());
52846   return jresult;
52847 }
52848
52849
52850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
52851   void * jresult ;
52852   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52853   Dali::Vector2 result;
52854
52855   arg1 = (Dali::DragAndDropDetector *)jarg1;
52856   {
52857     try {
52858       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
52859     } catch (std::out_of_range& e) {
52860       {
52861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52862       };
52863     } catch (std::exception& e) {
52864       {
52865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52866       };
52867     } catch (...) {
52868       {
52869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52870       };
52871     }
52872   }
52873   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
52874   return jresult;
52875 }
52876
52877
52878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
52879   void * jresult ;
52880   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52881   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52882
52883   arg1 = (Dali::DragAndDropDetector *)jarg1;
52884   {
52885     try {
52886       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
52887     } catch (std::out_of_range& e) {
52888       {
52889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52890       };
52891     } catch (std::exception& e) {
52892       {
52893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52894       };
52895     } catch (...) {
52896       {
52897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52898       };
52899     }
52900   }
52901   jresult = (void *)result;
52902   return jresult;
52903 }
52904
52905
52906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
52907   void * jresult ;
52908   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52909   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52910
52911   arg1 = (Dali::DragAndDropDetector *)jarg1;
52912   {
52913     try {
52914       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
52915     } catch (std::out_of_range& e) {
52916       {
52917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52918       };
52919     } catch (std::exception& e) {
52920       {
52921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52922       };
52923     } catch (...) {
52924       {
52925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52926       };
52927     }
52928   }
52929   jresult = (void *)result;
52930   return jresult;
52931 }
52932
52933
52934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
52935   void * jresult ;
52936   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52937   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52938
52939   arg1 = (Dali::DragAndDropDetector *)jarg1;
52940   {
52941     try {
52942       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
52943     } catch (std::out_of_range& e) {
52944       {
52945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52946       };
52947     } catch (std::exception& e) {
52948       {
52949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52950       };
52951     } catch (...) {
52952       {
52953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52954       };
52955     }
52956   }
52957   jresult = (void *)result;
52958   return jresult;
52959 }
52960
52961
52962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
52963   void * jresult ;
52964   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52965   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52966
52967   arg1 = (Dali::DragAndDropDetector *)jarg1;
52968   {
52969     try {
52970       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
52971     } catch (std::out_of_range& e) {
52972       {
52973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52974       };
52975     } catch (std::exception& e) {
52976       {
52977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52978       };
52979     } catch (...) {
52980       {
52981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52982       };
52983     }
52984   }
52985   jresult = (void *)result;
52986   return jresult;
52987 }
52988
52989
52990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
52991   void * jresult ;
52992   Dali::ApplicationExtensions *result = 0 ;
52993
52994   {
52995     try {
52996       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
52997     } catch (std::out_of_range& e) {
52998       {
52999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53000       };
53001     } catch (std::exception& e) {
53002       {
53003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53004       };
53005     } catch (...) {
53006       {
53007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53008       };
53009     }
53010   }
53011   jresult = (void *)result;
53012   return jresult;
53013 }
53014
53015
53016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53017   void * jresult ;
53018   Dali::Application *arg1 = (Dali::Application *) 0 ;
53019   Dali::ApplicationExtensions *result = 0 ;
53020
53021   arg1 = (Dali::Application *)jarg1;
53022   {
53023     try {
53024       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53025     } catch (std::out_of_range& e) {
53026       {
53027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53028       };
53029     } catch (std::exception& e) {
53030       {
53031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53032       };
53033     } catch (...) {
53034       {
53035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53036       };
53037     }
53038   }
53039   jresult = (void *)result;
53040   return jresult;
53041 }
53042
53043
53044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53045   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53046
53047   arg1 = (Dali::ApplicationExtensions *)jarg1;
53048   {
53049     try {
53050       delete arg1;
53051     } catch (std::out_of_range& e) {
53052       {
53053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53054       };
53055     } catch (std::exception& e) {
53056       {
53057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53058       };
53059     } catch (...) {
53060       {
53061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53062       };
53063     }
53064   }
53065 }
53066
53067
53068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53069   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53070
53071   arg1 = (Dali::ApplicationExtensions *)jarg1;
53072   {
53073     try {
53074       (arg1)->Init();
53075     } catch (std::out_of_range& e) {
53076       {
53077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53078       };
53079     } catch (std::exception& e) {
53080       {
53081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53082       };
53083     } catch (...) {
53084       {
53085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53086       };
53087     }
53088   }
53089 }
53090
53091
53092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53093   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53094
53095   arg1 = (Dali::ApplicationExtensions *)jarg1;
53096   {
53097     try {
53098       (arg1)->Terminate();
53099     } catch (std::out_of_range& e) {
53100       {
53101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53102       };
53103     } catch (std::exception& e) {
53104       {
53105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53106       };
53107     } catch (...) {
53108       {
53109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53110       };
53111     }
53112   }
53113 }
53114
53115
53116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53117   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53118
53119   arg1 = (Dali::ApplicationExtensions *)jarg1;
53120   {
53121     try {
53122       (arg1)->Pause();
53123     } catch (std::out_of_range& e) {
53124       {
53125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53126       };
53127     } catch (std::exception& e) {
53128       {
53129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53130       };
53131     } catch (...) {
53132       {
53133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53134       };
53135     }
53136   }
53137 }
53138
53139
53140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53141   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53142
53143   arg1 = (Dali::ApplicationExtensions *)jarg1;
53144   {
53145     try {
53146       (arg1)->Resume();
53147     } catch (std::out_of_range& e) {
53148       {
53149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53150       };
53151     } catch (std::exception& e) {
53152       {
53153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53154       };
53155     } catch (...) {
53156       {
53157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53158       };
53159     }
53160   }
53161 }
53162
53163
53164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53165   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53166
53167   arg1 = (Dali::ApplicationExtensions *)jarg1;
53168   {
53169     try {
53170       (arg1)->LanguageChange();
53171     } catch (std::out_of_range& e) {
53172       {
53173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53174       };
53175     } catch (std::exception& e) {
53176       {
53177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53178       };
53179     } catch (...) {
53180       {
53181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53182       };
53183     }
53184   }
53185 }
53186
53187
53188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53189   void * jresult ;
53190   Dali::PositionSize arg1 ;
53191   std::string *arg2 = 0 ;
53192   bool arg3 ;
53193   Dali::PositionSize *argp1 ;
53194   Dali::Window result;
53195
53196   argp1 = (Dali::PositionSize *)jarg1;
53197   if (!argp1) {
53198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53199     return 0;
53200   }
53201   arg1 = *argp1;
53202   if (!jarg2) {
53203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53204     return 0;
53205   }
53206   std::string arg2_str(jarg2);
53207   arg2 = &arg2_str;
53208   arg3 = jarg3 ? true : false;
53209   {
53210     try {
53211       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53212     } catch (std::out_of_range& e) {
53213       {
53214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53215       };
53216     } catch (std::exception& e) {
53217       {
53218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53219       };
53220     } catch (...) {
53221       {
53222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53223       };
53224     }
53225   }
53226   jresult = new Dali::Window((const Dali::Window &)result);
53227
53228   //argout typemap for const std::string&
53229
53230   return jresult;
53231 }
53232
53233
53234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53235   void * jresult ;
53236   Dali::PositionSize arg1 ;
53237   std::string *arg2 = 0 ;
53238   Dali::PositionSize *argp1 ;
53239   Dali::Window result;
53240
53241   argp1 = (Dali::PositionSize *)jarg1;
53242   if (!argp1) {
53243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53244     return 0;
53245   }
53246   arg1 = *argp1;
53247   if (!jarg2) {
53248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53249     return 0;
53250   }
53251   std::string arg2_str(jarg2);
53252   arg2 = &arg2_str;
53253   {
53254     try {
53255       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53256     } catch (std::out_of_range& e) {
53257       {
53258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53259       };
53260     } catch (std::exception& e) {
53261       {
53262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53263       };
53264     } catch (...) {
53265       {
53266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53267       };
53268     }
53269   }
53270   jresult = new Dali::Window((const Dali::Window &)result);
53271
53272   //argout typemap for const std::string&
53273
53274   return jresult;
53275 }
53276
53277
53278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53279   void * jresult ;
53280   Dali::PositionSize arg1 ;
53281   std::string *arg2 = 0 ;
53282   std::string *arg3 = 0 ;
53283   bool arg4 ;
53284   Dali::PositionSize *argp1 ;
53285   Dali::Window result;
53286
53287   argp1 = (Dali::PositionSize *)jarg1;
53288   if (!argp1) {
53289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53290     return 0;
53291   }
53292   arg1 = *argp1;
53293   if (!jarg2) {
53294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53295     return 0;
53296   }
53297   std::string arg2_str(jarg2);
53298   arg2 = &arg2_str;
53299   if (!jarg3) {
53300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53301     return 0;
53302   }
53303   std::string arg3_str(jarg3);
53304   arg3 = &arg3_str;
53305   arg4 = jarg4 ? true : false;
53306   {
53307     try {
53308       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53309     } catch (std::out_of_range& e) {
53310       {
53311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53312       };
53313     } catch (std::exception& e) {
53314       {
53315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53316       };
53317     } catch (...) {
53318       {
53319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53320       };
53321     }
53322   }
53323   jresult = new Dali::Window((const Dali::Window &)result);
53324
53325   //argout typemap for const std::string&
53326
53327
53328   //argout typemap for const std::string&
53329
53330   return jresult;
53331 }
53332
53333
53334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53335   void * jresult ;
53336   Dali::PositionSize arg1 ;
53337   std::string *arg2 = 0 ;
53338   std::string *arg3 = 0 ;
53339   Dali::PositionSize *argp1 ;
53340   Dali::Window result;
53341
53342   argp1 = (Dali::PositionSize *)jarg1;
53343   if (!argp1) {
53344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53345     return 0;
53346   }
53347   arg1 = *argp1;
53348   if (!jarg2) {
53349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53350     return 0;
53351   }
53352   std::string arg2_str(jarg2);
53353   arg2 = &arg2_str;
53354   if (!jarg3) {
53355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53356     return 0;
53357   }
53358   std::string arg3_str(jarg3);
53359   arg3 = &arg3_str;
53360   {
53361     try {
53362       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53363     } catch (std::out_of_range& e) {
53364       {
53365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53366       };
53367     } catch (std::exception& e) {
53368       {
53369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53370       };
53371     } catch (...) {
53372       {
53373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53374       };
53375     }
53376   }
53377   jresult = new Dali::Window((const Dali::Window &)result);
53378
53379   //argout typemap for const std::string&
53380
53381
53382   //argout typemap for const std::string&
53383
53384   return jresult;
53385 }
53386
53387
53388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53389   void * jresult ;
53390   Dali::Window *result = 0 ;
53391
53392   {
53393     try {
53394       result = (Dali::Window *)new Dali::Window();
53395     } catch (std::out_of_range& e) {
53396       {
53397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53398       };
53399     } catch (std::exception& e) {
53400       {
53401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53402       };
53403     } catch (...) {
53404       {
53405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53406       };
53407     }
53408   }
53409   jresult = (void *)result;
53410   return jresult;
53411 }
53412
53413
53414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53415   Dali::Window *arg1 = (Dali::Window *) 0 ;
53416
53417   arg1 = (Dali::Window *)jarg1;
53418   {
53419     try {
53420       delete arg1;
53421     } catch (std::out_of_range& e) {
53422       {
53423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53424       };
53425     } catch (std::exception& e) {
53426       {
53427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53428       };
53429     } catch (...) {
53430       {
53431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53432       };
53433     }
53434   }
53435 }
53436
53437
53438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53439   void * jresult ;
53440   Dali::Window *arg1 = 0 ;
53441   Dali::Window *result = 0 ;
53442
53443   arg1 = (Dali::Window *)jarg1;
53444   if (!arg1) {
53445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53446     return 0;
53447   }
53448   {
53449     try {
53450       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53451     } catch (std::out_of_range& e) {
53452       {
53453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53454       };
53455     } catch (std::exception& e) {
53456       {
53457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53458       };
53459     } catch (...) {
53460       {
53461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53462       };
53463     }
53464   }
53465   jresult = (void *)result;
53466   return jresult;
53467 }
53468
53469
53470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53471   void * jresult ;
53472   Dali::Window *arg1 = (Dali::Window *) 0 ;
53473   Dali::Window *arg2 = 0 ;
53474   Dali::Window *result = 0 ;
53475
53476   arg1 = (Dali::Window *)jarg1;
53477   arg2 = (Dali::Window *)jarg2;
53478   if (!arg2) {
53479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53480     return 0;
53481   }
53482   {
53483     try {
53484       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53485     } catch (std::out_of_range& e) {
53486       {
53487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53488       };
53489     } catch (std::exception& e) {
53490       {
53491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53492       };
53493     } catch (...) {
53494       {
53495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53496       };
53497     }
53498   }
53499   jresult = (void *)result;
53500   return jresult;
53501 }
53502
53503
53504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53505   Dali::Window *arg1 = (Dali::Window *) 0 ;
53506   Dali::Window::IndicatorVisibleMode arg2 ;
53507
53508   arg1 = (Dali::Window *)jarg1;
53509   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53510   {
53511     try {
53512       (arg1)->ShowIndicator(arg2);
53513     } catch (std::out_of_range& e) {
53514       {
53515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53516       };
53517     } catch (std::exception& e) {
53518       {
53519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53520       };
53521     } catch (...) {
53522       {
53523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53524       };
53525     }
53526   }
53527 }
53528
53529
53530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53531   Dali::Window *arg1 = (Dali::Window *) 0 ;
53532   Dali::Window::IndicatorBgOpacity arg2 ;
53533
53534   arg1 = (Dali::Window *)jarg1;
53535   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53536   {
53537     try {
53538       (arg1)->SetIndicatorBgOpacity(arg2);
53539     } catch (std::out_of_range& e) {
53540       {
53541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53542       };
53543     } catch (std::exception& e) {
53544       {
53545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53546       };
53547     } catch (...) {
53548       {
53549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53550       };
53551     }
53552   }
53553 }
53554
53555
53556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
53557   Dali::Window *arg1 = (Dali::Window *) 0 ;
53558   Dali::Window::WindowOrientation arg2 ;
53559
53560   arg1 = (Dali::Window *)jarg1;
53561   arg2 = (Dali::Window::WindowOrientation)jarg2;
53562   {
53563     try {
53564       (arg1)->RotateIndicator(arg2);
53565     } catch (std::out_of_range& e) {
53566       {
53567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53568       };
53569     } catch (std::exception& e) {
53570       {
53571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53572       };
53573     } catch (...) {
53574       {
53575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53576       };
53577     }
53578   }
53579 }
53580
53581
53582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
53583   Dali::Window *arg1 = (Dali::Window *) 0 ;
53584   std::string arg2 ;
53585   std::string arg3 ;
53586
53587   arg1 = (Dali::Window *)jarg1;
53588   if (!jarg2) {
53589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53590     return ;
53591   }
53592   (&arg2)->assign(jarg2);
53593   if (!jarg3) {
53594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53595     return ;
53596   }
53597   (&arg3)->assign(jarg3);
53598   {
53599     try {
53600       (arg1)->SetClass(arg2,arg3);
53601     } catch (std::out_of_range& e) {
53602       {
53603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53604       };
53605     } catch (std::exception& e) {
53606       {
53607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53608       };
53609     } catch (...) {
53610       {
53611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53612       };
53613     }
53614   }
53615 }
53616
53617
53618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
53619   Dali::Window *arg1 = (Dali::Window *) 0 ;
53620
53621   arg1 = (Dali::Window *)jarg1;
53622   {
53623     try {
53624       (arg1)->Raise();
53625     } catch (std::out_of_range& e) {
53626       {
53627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53628       };
53629     } catch (std::exception& e) {
53630       {
53631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53632       };
53633     } catch (...) {
53634       {
53635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53636       };
53637     }
53638   }
53639 }
53640
53641
53642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
53643   Dali::Window *arg1 = (Dali::Window *) 0 ;
53644
53645   arg1 = (Dali::Window *)jarg1;
53646   {
53647     try {
53648       (arg1)->Lower();
53649     } catch (std::out_of_range& e) {
53650       {
53651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53652       };
53653     } catch (std::exception& e) {
53654       {
53655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53656       };
53657     } catch (...) {
53658       {
53659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53660       };
53661     }
53662   }
53663 }
53664
53665
53666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
53667   Dali::Window *arg1 = (Dali::Window *) 0 ;
53668
53669   arg1 = (Dali::Window *)jarg1;
53670   {
53671     try {
53672       (arg1)->Activate();
53673     } catch (std::out_of_range& e) {
53674       {
53675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53676       };
53677     } catch (std::exception& e) {
53678       {
53679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53680       };
53681     } catch (...) {
53682       {
53683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53684       };
53685     }
53686   }
53687 }
53688
53689
53690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
53691   Dali::Window *arg1 = (Dali::Window *) 0 ;
53692   Dali::Window::WindowOrientation arg2 ;
53693
53694   arg1 = (Dali::Window *)jarg1;
53695   arg2 = (Dali::Window::WindowOrientation)jarg2;
53696   {
53697     try {
53698       (arg1)->AddAvailableOrientation(arg2);
53699     } catch (std::out_of_range& e) {
53700       {
53701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53702       };
53703     } catch (std::exception& e) {
53704       {
53705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53706       };
53707     } catch (...) {
53708       {
53709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53710       };
53711     }
53712   }
53713 }
53714
53715
53716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
53717   Dali::Window *arg1 = (Dali::Window *) 0 ;
53718   Dali::Window::WindowOrientation arg2 ;
53719
53720   arg1 = (Dali::Window *)jarg1;
53721   arg2 = (Dali::Window::WindowOrientation)jarg2;
53722   {
53723     try {
53724       (arg1)->RemoveAvailableOrientation(arg2);
53725     } catch (std::out_of_range& e) {
53726       {
53727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53728       };
53729     } catch (std::exception& e) {
53730       {
53731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53732       };
53733     } catch (...) {
53734       {
53735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53736       };
53737     }
53738   }
53739 }
53740
53741
53742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
53743   Dali::Window *arg1 = (Dali::Window *) 0 ;
53744   Dali::Window::WindowOrientation arg2 ;
53745
53746   arg1 = (Dali::Window *)jarg1;
53747   arg2 = (Dali::Window::WindowOrientation)jarg2;
53748   {
53749     try {
53750       (arg1)->SetPreferredOrientation(arg2);
53751     } catch (std::out_of_range& e) {
53752       {
53753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53754       };
53755     } catch (std::exception& e) {
53756       {
53757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53758       };
53759     } catch (...) {
53760       {
53761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53762       };
53763     }
53764   }
53765 }
53766
53767
53768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
53769   int jresult ;
53770   Dali::Window *arg1 = (Dali::Window *) 0 ;
53771   Dali::Window::WindowOrientation result;
53772
53773   arg1 = (Dali::Window *)jarg1;
53774   {
53775     try {
53776       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
53777     } catch (std::out_of_range& e) {
53778       {
53779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53780       };
53781     } catch (std::exception& e) {
53782       {
53783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53784       };
53785     } catch (...) {
53786       {
53787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53788       };
53789     }
53790   }
53791   jresult = (int)result;
53792   return jresult;
53793 }
53794
53795
53796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
53797   void * jresult ;
53798   Dali::Window *arg1 = (Dali::Window *) 0 ;
53799   Dali::DragAndDropDetector result;
53800
53801   arg1 = (Dali::Window *)jarg1;
53802   {
53803     try {
53804       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
53805     } catch (std::out_of_range& e) {
53806       {
53807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53808       };
53809     } catch (std::exception& e) {
53810       {
53811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53812       };
53813     } catch (...) {
53814       {
53815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53816       };
53817     }
53818   }
53819   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
53820   return jresult;
53821 }
53822
53823
53824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
53825   void * jresult ;
53826   Dali::Window *arg1 = (Dali::Window *) 0 ;
53827   Dali::Any result;
53828
53829   arg1 = (Dali::Window *)jarg1;
53830   {
53831     try {
53832       result = ((Dali::Window const *)arg1)->GetNativeHandle();
53833     } catch (std::out_of_range& e) {
53834       {
53835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53836       };
53837     } catch (std::exception& e) {
53838       {
53839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53840       };
53841     } catch (...) {
53842       {
53843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53844       };
53845     }
53846   }
53847   jresult = new Dali::Any((const Dali::Any &)result);
53848   return jresult;
53849 }
53850
53851
53852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
53853   void * jresult ;
53854   Dali::Window arg1 ;
53855   Dali::Window *argp1 ;
53856   Dali::DevelWindow::FocusSignalType *result = 0 ;
53857
53858   argp1 = (Dali::Window *)jarg1;
53859   if (!argp1) {
53860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53861     return 0;
53862   }
53863   arg1 = *argp1;
53864   {
53865     try {
53866       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
53867     } catch (std::out_of_range& e) {
53868       {
53869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53870       };
53871     } catch (std::exception& e) {
53872       {
53873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53874       };
53875     } catch (...) {
53876       {
53877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53878       };
53879     }
53880   }
53881   jresult = (void *)result;
53882   return jresult;
53883 }
53884
53885
53886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
53887   Dali::Window arg1 ;
53888   bool arg2 ;
53889   Dali::Window *argp1 ;
53890
53891   argp1 = (Dali::Window *)jarg1;
53892   if (!argp1) {
53893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53894     return ;
53895   }
53896   arg1 = *argp1;
53897   arg2 = jarg2 ? true : false;
53898   {
53899     try {
53900       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
53901     } catch (std::out_of_range& e) {
53902       {
53903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53904       };
53905     } catch (std::exception& e) {
53906       {
53907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53908       };
53909     } catch (...) {
53910       {
53911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53912       };
53913     }
53914   }
53915 }
53916
53917
53918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
53919   unsigned int jresult ;
53920   Dali::Window arg1 ;
53921   Dali::Window *argp1 ;
53922   bool result;
53923
53924   argp1 = (Dali::Window *)jarg1;
53925   if (!argp1) {
53926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53927     return 0;
53928   }
53929   arg1 = *argp1;
53930   {
53931     try {
53932       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
53933     } catch (std::out_of_range& e) {
53934       {
53935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53936       };
53937     } catch (std::exception& e) {
53938       {
53939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53940       };
53941     } catch (...) {
53942       {
53943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53944       };
53945     }
53946   }
53947   jresult = result;
53948   return jresult;
53949 }
53950
53951
53952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
53953   Dali::Window arg1 ;
53954   Dali::Window *argp1 ;
53955
53956   argp1 = (Dali::Window *)jarg1;
53957   if (!argp1) {
53958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53959     return ;
53960   }
53961   arg1 = *argp1;
53962   {
53963     try {
53964       Dali::DevelWindow::Show(arg1);
53965     } catch (std::out_of_range& e) {
53966       {
53967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53968       };
53969     } catch (std::exception& e) {
53970       {
53971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53972       };
53973     } catch (...) {
53974       {
53975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53976       };
53977     }
53978   }
53979 }
53980
53981
53982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
53983   Dali::Window arg1 ;
53984   Dali::Window *argp1 ;
53985
53986   argp1 = (Dali::Window *)jarg1;
53987   if (!argp1) {
53988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53989     return ;
53990   }
53991   arg1 = *argp1;
53992   {
53993     try {
53994       Dali::DevelWindow::Hide(arg1);
53995     } catch (std::out_of_range& e) {
53996       {
53997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53998       };
53999     } catch (std::exception& e) {
54000       {
54001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54002       };
54003     } catch (...) {
54004       {
54005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54006       };
54007     }
54008   }
54009 }
54010
54011
54012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54013   unsigned int jresult ;
54014   Dali::Window arg1 ;
54015   Dali::Window *argp1 ;
54016   bool result;
54017
54018   argp1 = (Dali::Window *)jarg1;
54019   if (!argp1) {
54020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54021     return 0;
54022   }
54023   arg1 = *argp1;
54024   {
54025     try {
54026       result = (bool)Dali::DevelWindow::IsVisible(arg1);
54027     } catch (std::out_of_range& e) {
54028       {
54029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54030       };
54031     } catch (std::exception& e) {
54032       {
54033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54034       };
54035     } catch (...) {
54036       {
54037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54038       };
54039     }
54040   }
54041   jresult = result;
54042   return jresult;
54043 }
54044
54045
54046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
54047   void * jresult ;
54048   Dali::Application result;
54049
54050   {
54051     try {
54052       result = Dali::Application::New();
54053     } catch (std::out_of_range& e) {
54054       {
54055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54056       };
54057     } catch (std::exception& e) {
54058       {
54059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54060       };
54061     } catch (...) {
54062       {
54063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54064       };
54065     }
54066   }
54067   jresult = new Dali::Application((const Dali::Application &)result);
54068   return jresult;
54069 }
54070
54071
54072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
54073   void * jresult ;
54074   int *arg1 = (int *) 0 ;
54075   char ***arg2 ;
54076   Dali::Application result;
54077
54078   {
54079     // Todo generate argv data from the C# args
54080     char **array;         // two dimensional array
54081     int numStrings = 1;     // number of strings
54082     int stringLength = 30;      // max string length.
54083     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54084     argV = array;
54085
54086     // allocate the string data
54087     for( int i=0; i < numStrings; i++)
54088     {
54089       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54090     }
54091     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54092
54093     strcpy( array[0], "dali-csharp-app");
54094
54095     arg1 = &argC;
54096     arg2 = &argV;
54097   }
54098   {
54099     try {
54100       result = Dali::Application::New(arg1,arg2);
54101     } catch (std::out_of_range& e) {
54102       {
54103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54104       };
54105     } catch (std::exception& e) {
54106       {
54107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54108       };
54109     } catch (...) {
54110       {
54111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54112       };
54113     }
54114   }
54115   jresult = new Dali::Application((const Dali::Application &)result);
54116   return jresult;
54117 }
54118
54119
54120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
54121   void * jresult ;
54122   int *arg1 = (int *) 0 ;
54123   char ***arg2 ;
54124   std::string *arg3 = 0 ;
54125   Dali::Application result;
54126
54127   {
54128     // Todo generate argv data from the C# args
54129     char **array;         // two dimensional array
54130     int numStrings = 1;     // number of strings
54131     int stringLength = 30;      // max string length.
54132     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54133     argV = array;
54134
54135     // allocate the string data
54136     for( int i=0; i < numStrings; i++)
54137     {
54138       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54139     }
54140     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54141
54142     strcpy( array[0], "dali-csharp-app");
54143
54144     arg1 = &argC;
54145     arg2 = &argV;
54146   }
54147   if (!jarg3) {
54148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54149     return 0;
54150   }
54151   std::string arg3_str(jarg3);
54152   arg3 = &arg3_str;
54153   {
54154     try {
54155       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
54156     } catch (std::out_of_range& e) {
54157       {
54158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54159       };
54160     } catch (std::exception& e) {
54161       {
54162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54163       };
54164     } catch (...) {
54165       {
54166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54167       };
54168     }
54169   }
54170   jresult = new Dali::Application((const Dali::Application &)result);
54171
54172   //argout typemap for const std::string&
54173
54174   return jresult;
54175 }
54176
54177
54178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
54179   void * jresult ;
54180   int *arg1 = (int *) 0 ;
54181   char ***arg2 ;
54182   std::string *arg3 = 0 ;
54183   Dali::Application::WINDOW_MODE arg4 ;
54184   Dali::Application result;
54185
54186   {
54187     // Todo generate argv data from the C# args
54188     char **array;         // two dimensional array
54189     int numStrings = 1;     // number of strings
54190     int stringLength = 30;      // max string length.
54191     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54192     argV = array;
54193
54194     // allocate the string data
54195     for( int i=0; i < numStrings; i++)
54196     {
54197       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54198     }
54199     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54200
54201     strcpy( array[0], "dali-csharp-app");
54202
54203     arg1 = &argC;
54204     arg2 = &argV;
54205   }
54206   if (!jarg3) {
54207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54208     return 0;
54209   }
54210   std::string arg3_str(jarg3);
54211   arg3 = &arg3_str;
54212   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
54213   {
54214     try {
54215       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
54216     } catch (std::out_of_range& e) {
54217       {
54218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54219       };
54220     } catch (std::exception& e) {
54221       {
54222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54223       };
54224     } catch (...) {
54225       {
54226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54227       };
54228     }
54229   }
54230   jresult = new Dali::Application((const Dali::Application &)result);
54231
54232   //argout typemap for const std::string&
54233
54234   return jresult;
54235 }
54236
54237
54238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
54239   void * jresult ;
54240   Dali::Application *result = 0 ;
54241
54242   {
54243     try {
54244       result = (Dali::Application *)new Dali::Application();
54245     } catch (std::out_of_range& e) {
54246       {
54247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54248       };
54249     } catch (std::exception& e) {
54250       {
54251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54252       };
54253     } catch (...) {
54254       {
54255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54256       };
54257     }
54258   }
54259   jresult = (void *)result;
54260   return jresult;
54261 }
54262
54263
54264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
54265   void * jresult ;
54266   Dali::Application *arg1 = 0 ;
54267   Dali::Application *result = 0 ;
54268
54269   arg1 = (Dali::Application *)jarg1;
54270   if (!arg1) {
54271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54272     return 0;
54273   }
54274   {
54275     try {
54276       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
54277     } catch (std::out_of_range& e) {
54278       {
54279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54280       };
54281     } catch (std::exception& e) {
54282       {
54283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54284       };
54285     } catch (...) {
54286       {
54287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54288       };
54289     }
54290   }
54291   jresult = (void *)result;
54292   return jresult;
54293 }
54294
54295
54296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
54297   void * jresult ;
54298   Dali::Application *arg1 = (Dali::Application *) 0 ;
54299   Dali::Application *arg2 = 0 ;
54300   Dali::Application *result = 0 ;
54301
54302   arg1 = (Dali::Application *)jarg1;
54303   arg2 = (Dali::Application *)jarg2;
54304   if (!arg2) {
54305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54306     return 0;
54307   }
54308   {
54309     try {
54310       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
54311     } catch (std::out_of_range& e) {
54312       {
54313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54314       };
54315     } catch (std::exception& e) {
54316       {
54317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54318       };
54319     } catch (...) {
54320       {
54321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54322       };
54323     }
54324   }
54325   jresult = (void *)result;
54326   return jresult;
54327 }
54328
54329
54330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
54331   Dali::Application *arg1 = (Dali::Application *) 0 ;
54332
54333   arg1 = (Dali::Application *)jarg1;
54334   {
54335     try {
54336       delete arg1;
54337     } catch (std::out_of_range& e) {
54338       {
54339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54340       };
54341     } catch (std::exception& e) {
54342       {
54343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54344       };
54345     } catch (...) {
54346       {
54347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54348       };
54349     }
54350   }
54351 }
54352
54353
54354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
54355   Dali::Application *arg1 = (Dali::Application *) 0 ;
54356
54357   arg1 = (Dali::Application *)jarg1;
54358   {
54359     try {
54360       (arg1)->MainLoop();
54361     } catch (std::out_of_range& e) {
54362       {
54363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54364       };
54365     } catch (std::exception& e) {
54366       {
54367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54368       };
54369     } catch (...) {
54370       {
54371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54372       };
54373     }
54374   }
54375 }
54376
54377
54378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
54379   Dali::Application *arg1 = (Dali::Application *) 0 ;
54380   Configuration::ContextLoss arg2 ;
54381   Configuration::ContextLoss *argp2 ;
54382
54383   arg1 = (Dali::Application *)jarg1;
54384   argp2 = (Configuration::ContextLoss *)jarg2;
54385   if (!argp2) {
54386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
54387     return ;
54388   }
54389   arg2 = *argp2;
54390   {
54391     try {
54392       (arg1)->MainLoop(arg2);
54393     } catch (std::out_of_range& e) {
54394       {
54395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54396       };
54397     } catch (std::exception& e) {
54398       {
54399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54400       };
54401     } catch (...) {
54402       {
54403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54404       };
54405     }
54406   }
54407 }
54408
54409
54410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
54411   Dali::Application *arg1 = (Dali::Application *) 0 ;
54412
54413   arg1 = (Dali::Application *)jarg1;
54414   {
54415     try {
54416       (arg1)->Lower();
54417     } catch (std::out_of_range& e) {
54418       {
54419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54420       };
54421     } catch (std::exception& e) {
54422       {
54423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54424       };
54425     } catch (...) {
54426       {
54427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54428       };
54429     }
54430   }
54431 }
54432
54433
54434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
54435   Dali::Application *arg1 = (Dali::Application *) 0 ;
54436
54437   arg1 = (Dali::Application *)jarg1;
54438   {
54439     try {
54440       (arg1)->Quit();
54441     } catch (std::out_of_range& e) {
54442       {
54443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54444       };
54445     } catch (std::exception& e) {
54446       {
54447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54448       };
54449     } catch (...) {
54450       {
54451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54452       };
54453     }
54454   }
54455 }
54456
54457
54458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
54459   unsigned int jresult ;
54460   Dali::Application *arg1 = (Dali::Application *) 0 ;
54461   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
54462   bool result;
54463
54464   arg1 = (Dali::Application *)jarg1;
54465   arg2 = (Dali::CallbackBase *)jarg2;
54466   {
54467     try {
54468       result = (bool)(arg1)->AddIdle(arg2);
54469     } catch (std::out_of_range& e) {
54470       {
54471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54472       };
54473     } catch (std::exception& e) {
54474       {
54475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54476       };
54477     } catch (...) {
54478       {
54479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54480       };
54481     }
54482   }
54483   jresult = result;
54484   return jresult;
54485 }
54486
54487
54488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
54489   void * jresult ;
54490   Dali::Application *arg1 = (Dali::Application *) 0 ;
54491   Dali::Window result;
54492
54493   arg1 = (Dali::Application *)jarg1;
54494   {
54495     try {
54496       result = (arg1)->GetWindow();
54497     } catch (std::out_of_range& e) {
54498       {
54499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54500       };
54501     } catch (std::exception& e) {
54502       {
54503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54504       };
54505     } catch (...) {
54506       {
54507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54508       };
54509     }
54510   }
54511   jresult = new Dali::Window((const Dali::Window &)result);
54512   return jresult;
54513 }
54514
54515
54516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
54517   Dali::Application *arg1 = (Dali::Application *) 0 ;
54518   Dali::PositionSize arg2 ;
54519   std::string *arg3 = 0 ;
54520   Dali::PositionSize *argp2 ;
54521
54522   arg1 = (Dali::Application *)jarg1;
54523   argp2 = (Dali::PositionSize *)jarg2;
54524   if (!argp2) {
54525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54526     return ;
54527   }
54528   arg2 = *argp2;
54529   if (!jarg3) {
54530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54531     return ;
54532   }
54533   std::string arg3_str(jarg3);
54534   arg3 = &arg3_str;
54535   {
54536     try {
54537       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
54538     } catch (std::out_of_range& e) {
54539       {
54540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54541       };
54542     } catch (std::exception& e) {
54543       {
54544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54545       };
54546     } catch (...) {
54547       {
54548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54549       };
54550     }
54551   }
54552
54553   //argout typemap for const std::string&
54554
54555 }
54556
54557
54558 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
54559   char * jresult ;
54560   std::string result;
54561
54562   {
54563     try {
54564       result = Dali::Application::GetResourcePath();
54565     } catch (std::out_of_range& e) {
54566       {
54567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54568       };
54569     } catch (std::exception& e) {
54570       {
54571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54572       };
54573     } catch (...) {
54574       {
54575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54576       };
54577     }
54578   }
54579   jresult = SWIG_csharp_string_callback((&result)->c_str());
54580   return jresult;
54581 }
54582
54583
54584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
54585   Dali::Application *arg1 = (Dali::Application *) 0 ;
54586   Dali::ViewMode arg2 ;
54587
54588   arg1 = (Dali::Application *)jarg1;
54589   arg2 = (Dali::ViewMode)jarg2;
54590   {
54591     try {
54592       (arg1)->SetViewMode(arg2);
54593     } catch (std::out_of_range& e) {
54594       {
54595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54596       };
54597     } catch (std::exception& e) {
54598       {
54599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54600       };
54601     } catch (...) {
54602       {
54603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54604       };
54605     }
54606   }
54607 }
54608
54609
54610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
54611   int jresult ;
54612   Dali::Application *arg1 = (Dali::Application *) 0 ;
54613   Dali::ViewMode result;
54614
54615   arg1 = (Dali::Application *)jarg1;
54616   {
54617     try {
54618       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
54619     } catch (std::out_of_range& e) {
54620       {
54621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54622       };
54623     } catch (std::exception& e) {
54624       {
54625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54626       };
54627     } catch (...) {
54628       {
54629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54630       };
54631     }
54632   }
54633   jresult = (int)result;
54634   return jresult;
54635 }
54636
54637
54638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
54639   Dali::Application *arg1 = (Dali::Application *) 0 ;
54640   float arg2 ;
54641
54642   arg1 = (Dali::Application *)jarg1;
54643   arg2 = (float)jarg2;
54644   {
54645     try {
54646       (arg1)->SetStereoBase(arg2);
54647     } catch (std::out_of_range& e) {
54648       {
54649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54650       };
54651     } catch (std::exception& e) {
54652       {
54653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54654       };
54655     } catch (...) {
54656       {
54657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54658       };
54659     }
54660   }
54661 }
54662
54663
54664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
54665   float jresult ;
54666   Dali::Application *arg1 = (Dali::Application *) 0 ;
54667   float result;
54668
54669   arg1 = (Dali::Application *)jarg1;
54670   {
54671     try {
54672       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
54673     } catch (std::out_of_range& e) {
54674       {
54675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54676       };
54677     } catch (std::exception& e) {
54678       {
54679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54680       };
54681     } catch (...) {
54682       {
54683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54684       };
54685     }
54686   }
54687   jresult = result;
54688   return jresult;
54689 }
54690
54691
54692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
54693   void * jresult ;
54694   Dali::Application *arg1 = (Dali::Application *) 0 ;
54695   Dali::Application::AppSignalType *result = 0 ;
54696
54697   arg1 = (Dali::Application *)jarg1;
54698   {
54699     try {
54700       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
54701     } catch (std::out_of_range& e) {
54702       {
54703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54704       };
54705     } catch (std::exception& e) {
54706       {
54707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54708       };
54709     } catch (...) {
54710       {
54711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54712       };
54713     }
54714   }
54715   jresult = (void *)result;
54716   return jresult;
54717 }
54718
54719
54720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
54721   void * jresult ;
54722   Dali::Application *arg1 = (Dali::Application *) 0 ;
54723   Dali::Application::AppSignalType *result = 0 ;
54724
54725   arg1 = (Dali::Application *)jarg1;
54726   {
54727     try {
54728       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
54729     } catch (std::out_of_range& e) {
54730       {
54731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54732       };
54733     } catch (std::exception& e) {
54734       {
54735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54736       };
54737     } catch (...) {
54738       {
54739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54740       };
54741     }
54742   }
54743   jresult = (void *)result;
54744   return jresult;
54745 }
54746
54747
54748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
54749   void * jresult ;
54750   Dali::Application *arg1 = (Dali::Application *) 0 ;
54751   Dali::Application::AppSignalType *result = 0 ;
54752
54753   arg1 = (Dali::Application *)jarg1;
54754   {
54755     try {
54756       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
54757     } catch (std::out_of_range& e) {
54758       {
54759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54760       };
54761     } catch (std::exception& e) {
54762       {
54763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54764       };
54765     } catch (...) {
54766       {
54767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54768       };
54769     }
54770   }
54771   jresult = (void *)result;
54772   return jresult;
54773 }
54774
54775
54776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
54777   void * jresult ;
54778   Dali::Application *arg1 = (Dali::Application *) 0 ;
54779   Dali::Application::AppSignalType *result = 0 ;
54780
54781   arg1 = (Dali::Application *)jarg1;
54782   {
54783     try {
54784       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
54785     } catch (std::out_of_range& e) {
54786       {
54787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54788       };
54789     } catch (std::exception& e) {
54790       {
54791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54792       };
54793     } catch (...) {
54794       {
54795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54796       };
54797     }
54798   }
54799   jresult = (void *)result;
54800   return jresult;
54801 }
54802
54803
54804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
54805   void * jresult ;
54806   Dali::Application *arg1 = (Dali::Application *) 0 ;
54807   Dali::Application::AppSignalType *result = 0 ;
54808
54809   arg1 = (Dali::Application *)jarg1;
54810   {
54811     try {
54812       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
54813     } catch (std::out_of_range& e) {
54814       {
54815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54816       };
54817     } catch (std::exception& e) {
54818       {
54819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54820       };
54821     } catch (...) {
54822       {
54823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54824       };
54825     }
54826   }
54827   jresult = (void *)result;
54828   return jresult;
54829 }
54830
54831
54832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
54833   void * jresult ;
54834   Dali::Application *arg1 = (Dali::Application *) 0 ;
54835   Dali::Application::AppSignalType *result = 0 ;
54836
54837   arg1 = (Dali::Application *)jarg1;
54838   {
54839     try {
54840       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
54841     } catch (std::out_of_range& e) {
54842       {
54843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54844       };
54845     } catch (std::exception& e) {
54846       {
54847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54848       };
54849     } catch (...) {
54850       {
54851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54852       };
54853     }
54854   }
54855   jresult = (void *)result;
54856   return jresult;
54857 }
54858
54859
54860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
54861   void * jresult ;
54862   Dali::Application *arg1 = (Dali::Application *) 0 ;
54863   Dali::Application::AppControlSignalType *result = 0 ;
54864
54865   arg1 = (Dali::Application *)jarg1;
54866   {
54867     try {
54868       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
54869     } catch (std::out_of_range& e) {
54870       {
54871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54872       };
54873     } catch (std::exception& e) {
54874       {
54875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54876       };
54877     } catch (...) {
54878       {
54879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54880       };
54881     }
54882   }
54883   jresult = (void *)result;
54884   return jresult;
54885 }
54886
54887
54888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
54889   void * jresult ;
54890   Dali::Application *arg1 = (Dali::Application *) 0 ;
54891   Dali::Application::AppSignalType *result = 0 ;
54892
54893   arg1 = (Dali::Application *)jarg1;
54894   {
54895     try {
54896       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
54897     } catch (std::out_of_range& e) {
54898       {
54899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54900       };
54901     } catch (std::exception& e) {
54902       {
54903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54904       };
54905     } catch (...) {
54906       {
54907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54908       };
54909     }
54910   }
54911   jresult = (void *)result;
54912   return jresult;
54913 }
54914
54915
54916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
54917   void * jresult ;
54918   Dali::Application *arg1 = (Dali::Application *) 0 ;
54919   Dali::Application::AppSignalType *result = 0 ;
54920
54921   arg1 = (Dali::Application *)jarg1;
54922   {
54923     try {
54924       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
54925     } catch (std::out_of_range& e) {
54926       {
54927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54928       };
54929     } catch (std::exception& e) {
54930       {
54931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54932       };
54933     } catch (...) {
54934       {
54935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54936       };
54937     }
54938   }
54939   jresult = (void *)result;
54940   return jresult;
54941 }
54942
54943
54944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
54945   void * jresult ;
54946   Dali::Application *arg1 = (Dali::Application *) 0 ;
54947   Dali::Application::AppSignalType *result = 0 ;
54948
54949   arg1 = (Dali::Application *)jarg1;
54950   {
54951     try {
54952       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
54953     } catch (std::out_of_range& e) {
54954       {
54955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54956       };
54957     } catch (std::exception& e) {
54958       {
54959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54960       };
54961     } catch (...) {
54962       {
54963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54964       };
54965     }
54966   }
54967   jresult = (void *)result;
54968   return jresult;
54969 }
54970
54971
54972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
54973   void * jresult ;
54974   Dali::Application *arg1 = (Dali::Application *) 0 ;
54975   Dali::Application::AppSignalType *result = 0 ;
54976
54977   arg1 = (Dali::Application *)jarg1;
54978   {
54979     try {
54980       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
54981     } catch (std::out_of_range& e) {
54982       {
54983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54984       };
54985     } catch (std::exception& e) {
54986       {
54987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54988       };
54989     } catch (...) {
54990       {
54991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54992       };
54993     }
54994   }
54995   jresult = (void *)result;
54996   return jresult;
54997 }
54998
54999
55000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
55001   unsigned int jresult ;
55002   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55003   bool result;
55004
55005   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55006   {
55007     try {
55008       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
55009     } catch (std::out_of_range& e) {
55010       {
55011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55012       };
55013     } catch (std::exception& e) {
55014       {
55015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55016       };
55017     } catch (...) {
55018       {
55019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55020       };
55021     }
55022   }
55023   jresult = result;
55024   return jresult;
55025 }
55026
55027
55028 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
55029   unsigned long jresult ;
55030   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55031   std::size_t result;
55032
55033   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55034   {
55035     try {
55036       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
55037     } catch (std::out_of_range& e) {
55038       {
55039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55040       };
55041     } catch (std::exception& e) {
55042       {
55043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55044       };
55045     } catch (...) {
55046       {
55047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55048       };
55049     }
55050   }
55051   jresult = (unsigned long)result;
55052   return jresult;
55053 }
55054
55055
55056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
55057   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55058   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55059
55060   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55061   arg2 = (void (*)(Dali::Application &))jarg2;
55062   {
55063     try {
55064       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
55065     } catch (std::out_of_range& e) {
55066       {
55067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55068       };
55069     } catch (std::exception& e) {
55070       {
55071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55072       };
55073     } catch (...) {
55074       {
55075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55076       };
55077     }
55078   }
55079 }
55080
55081
55082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
55083   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55084   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55085
55086   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55087   arg2 = (void (*)(Dali::Application &))jarg2;
55088   {
55089     try {
55090       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
55091     } catch (std::out_of_range& e) {
55092       {
55093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55094       };
55095     } catch (std::exception& e) {
55096       {
55097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55098       };
55099     } catch (...) {
55100       {
55101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55102       };
55103     }
55104   }
55105 }
55106
55107
55108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
55109   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55110   Dali::Application *arg2 = 0 ;
55111
55112   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55113   arg2 = (Dali::Application *)jarg2;
55114   if (!arg2) {
55115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55116     return ;
55117   }
55118   {
55119     try {
55120       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
55121     } catch (std::out_of_range& e) {
55122       {
55123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55124       };
55125     } catch (std::exception& e) {
55126       {
55127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55128       };
55129     } catch (...) {
55130       {
55131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55132       };
55133     }
55134   }
55135 }
55136
55137
55138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
55139   void * jresult ;
55140   Dali::Signal< void (Dali::Application &) > *result = 0 ;
55141
55142   {
55143     try {
55144       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
55145     } catch (std::out_of_range& e) {
55146       {
55147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55148       };
55149     } catch (std::exception& e) {
55150       {
55151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55152       };
55153     } catch (...) {
55154       {
55155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55156       };
55157     }
55158   }
55159   jresult = (void *)result;
55160   return jresult;
55161 }
55162
55163
55164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
55165   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55166
55167   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55168   {
55169     try {
55170       delete arg1;
55171     } catch (std::out_of_range& e) {
55172       {
55173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55174       };
55175     } catch (std::exception& e) {
55176       {
55177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55178       };
55179     } catch (...) {
55180       {
55181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55182       };
55183     }
55184   }
55185 }
55186
55187
55188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
55189   unsigned int jresult ;
55190   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55191   bool result;
55192
55193   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55194   {
55195     try {
55196       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55197     } catch (std::out_of_range& e) {
55198       {
55199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55200       };
55201     } catch (std::exception& e) {
55202       {
55203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55204       };
55205     } catch (...) {
55206       {
55207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55208       };
55209     }
55210   }
55211   jresult = result;
55212   return jresult;
55213 }
55214
55215
55216 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
55217   unsigned long jresult ;
55218   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55219   std::size_t result;
55220
55221   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55222   {
55223     try {
55224       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55225     } catch (std::out_of_range& e) {
55226       {
55227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55228       };
55229     } catch (std::exception& e) {
55230       {
55231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55232       };
55233     } catch (...) {
55234       {
55235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55236       };
55237     }
55238   }
55239   jresult = (unsigned long)result;
55240   return jresult;
55241 }
55242
55243
55244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
55245   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55246   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55247
55248   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55249   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55250   {
55251     try {
55252       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
55253     } catch (std::out_of_range& e) {
55254       {
55255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55256       };
55257     } catch (std::exception& e) {
55258       {
55259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55260       };
55261     } catch (...) {
55262       {
55263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55264       };
55265     }
55266   }
55267 }
55268
55269
55270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
55271   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55272   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55273
55274   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55275   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55276   {
55277     try {
55278       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
55279     } catch (std::out_of_range& e) {
55280       {
55281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55282       };
55283     } catch (std::exception& e) {
55284       {
55285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55286       };
55287     } catch (...) {
55288       {
55289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55290       };
55291     }
55292   }
55293 }
55294
55295
55296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55297   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55298   Dali::Application *arg2 = 0 ;
55299   void *arg3 = (void *) 0 ;
55300
55301   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55302   arg2 = (Dali::Application *)jarg2;
55303   if (!arg2) {
55304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55305     return ;
55306   }
55307   arg3 = jarg3;
55308   {
55309     try {
55310       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
55311     } catch (std::out_of_range& e) {
55312       {
55313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55314       };
55315     } catch (std::exception& e) {
55316       {
55317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55318       };
55319     } catch (...) {
55320       {
55321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55322       };
55323     }
55324   }
55325 }
55326
55327
55328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
55329   void * jresult ;
55330   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
55331
55332   {
55333     try {
55334       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
55335     } catch (std::out_of_range& e) {
55336       {
55337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55338       };
55339     } catch (std::exception& e) {
55340       {
55341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55342       };
55343     } catch (...) {
55344       {
55345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55346       };
55347     }
55348   }
55349   jresult = (void *)result;
55350   return jresult;
55351 }
55352
55353
55354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
55355   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55356
55357   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55358   {
55359     try {
55360       delete arg1;
55361     } catch (std::out_of_range& e) {
55362       {
55363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55364       };
55365     } catch (std::exception& e) {
55366       {
55367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55368       };
55369     } catch (...) {
55370       {
55371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55372       };
55373     }
55374   }
55375 }
55376
55377
55378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55379   unsigned int jresult ;
55380   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55381   bool result;
55382
55383   arg1 = (Dali::Signal< bool () > *)jarg1;
55384   {
55385     try {
55386       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55387     } catch (std::out_of_range& e) {
55388       {
55389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55390       };
55391     } catch (std::exception& e) {
55392       {
55393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55394       };
55395     } catch (...) {
55396       {
55397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55398       };
55399     }
55400   }
55401   jresult = result;
55402   return jresult;
55403 }
55404
55405
55406 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55407   unsigned long jresult ;
55408   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55409   std::size_t result;
55410
55411   arg1 = (Dali::Signal< bool () > *)jarg1;
55412   {
55413     try {
55414       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55415     } catch (std::out_of_range& e) {
55416       {
55417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55418       };
55419     } catch (std::exception& e) {
55420       {
55421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55422       };
55423     } catch (...) {
55424       {
55425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55426       };
55427     }
55428   }
55429   jresult = (unsigned long)result;
55430   return jresult;
55431 }
55432
55433
55434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55435   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55436   bool (*arg2)() = (bool (*)()) 0 ;
55437
55438   arg1 = (Dali::Signal< bool () > *)jarg1;
55439   arg2 = (bool (*)())jarg2;
55440   {
55441     try {
55442       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55443     } catch (std::out_of_range& e) {
55444       {
55445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55446       };
55447     } catch (std::exception& e) {
55448       {
55449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55450       };
55451     } catch (...) {
55452       {
55453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55454       };
55455     }
55456   }
55457 }
55458
55459
55460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55461   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55462   bool (*arg2)() = (bool (*)()) 0 ;
55463
55464   arg1 = (Dali::Signal< bool () > *)jarg1;
55465   arg2 = (bool (*)())jarg2;
55466   {
55467     try {
55468       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55469     } catch (std::out_of_range& e) {
55470       {
55471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55472       };
55473     } catch (std::exception& e) {
55474       {
55475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55476       };
55477     } catch (...) {
55478       {
55479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55480       };
55481     }
55482   }
55483 }
55484
55485
55486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55487   unsigned int jresult ;
55488   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55489   bool result;
55490
55491   arg1 = (Dali::Signal< bool () > *)jarg1;
55492   {
55493     try {
55494       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55495     } catch (std::out_of_range& e) {
55496       {
55497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55498       };
55499     } catch (std::exception& e) {
55500       {
55501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55502       };
55503     } catch (...) {
55504       {
55505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55506       };
55507     }
55508   }
55509   jresult = result;
55510   return jresult;
55511 }
55512
55513
55514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55515   void * jresult ;
55516   Dali::Signal< bool () > *result = 0 ;
55517
55518   {
55519     try {
55520       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55521     } catch (std::out_of_range& e) {
55522       {
55523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55524       };
55525     } catch (std::exception& e) {
55526       {
55527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55528       };
55529     } catch (...) {
55530       {
55531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55532       };
55533     }
55534   }
55535   jresult = (void *)result;
55536   return jresult;
55537 }
55538
55539
55540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55541   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55542
55543   arg1 = (Dali::Signal< bool () > *)jarg1;
55544   {
55545     try {
55546       delete arg1;
55547     } catch (std::out_of_range& e) {
55548       {
55549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55550       };
55551     } catch (std::exception& e) {
55552       {
55553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55554       };
55555     } catch (...) {
55556       {
55557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55558       };
55559     }
55560   }
55561 }
55562
55563
55564
55565
55566
55567 //manual merge 2017-03-31
55568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
55569   unsigned int jresult ;
55570   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55571   bool result;
55572
55573   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55574   {
55575     try {
55576       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
55577     } catch (std::out_of_range& e) {
55578       {
55579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55580       };
55581     } catch (std::exception& e) {
55582       {
55583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55584       };
55585     } catch (...) {
55586       {
55587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55588       };
55589     }
55590   }
55591   jresult = result;
55592   return jresult;
55593 }
55594
55595
55596 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
55597   unsigned long jresult ;
55598   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55599   std::size_t result;
55600
55601   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55602   {
55603     try {
55604       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
55605     } catch (std::out_of_range& e) {
55606       {
55607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55608       };
55609     } catch (std::exception& e) {
55610       {
55611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55612       };
55613     } catch (...) {
55614       {
55615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55616       };
55617     }
55618   }
55619   jresult = (unsigned long)result;
55620   return jresult;
55621 }
55622
55623
55624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
55625   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55626   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55627
55628   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55629   arg2 = (void (*)(bool))jarg2;
55630   {
55631     try {
55632       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
55633     } catch (std::out_of_range& e) {
55634       {
55635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55636       };
55637     } catch (std::exception& e) {
55638       {
55639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55640       };
55641     } catch (...) {
55642       {
55643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55644       };
55645     }
55646   }
55647 }
55648
55649
55650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
55651   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55652   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55653
55654   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55655   arg2 = (void (*)(bool))jarg2;
55656   {
55657     try {
55658       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
55659     } catch (std::out_of_range& e) {
55660       {
55661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55662       };
55663     } catch (std::exception& e) {
55664       {
55665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55666       };
55667     } catch (...) {
55668       {
55669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55670       };
55671     }
55672   }
55673 }
55674
55675
55676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
55677   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55678   bool arg2 ;
55679
55680   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55681   arg2 = jarg2 ? true : false;
55682   {
55683     try {
55684       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
55685     } catch (std::out_of_range& e) {
55686       {
55687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55688       };
55689     } catch (std::exception& e) {
55690       {
55691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55692       };
55693     } catch (...) {
55694       {
55695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55696       };
55697     }
55698   }
55699 }
55700
55701
55702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
55703   void * jresult ;
55704   Dali::Signal< void (bool) > *result = 0 ;
55705
55706   {
55707     try {
55708       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
55709     } catch (std::out_of_range& e) {
55710       {
55711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55712       };
55713     } catch (std::exception& e) {
55714       {
55715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55716       };
55717     } catch (...) {
55718       {
55719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55720       };
55721     }
55722   }
55723   jresult = (void *)result;
55724   return jresult;
55725 }
55726
55727
55728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
55729   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55730
55731   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55732   {
55733     try {
55734       delete arg1;
55735     } catch (std::out_of_range& e) {
55736       {
55737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55738       };
55739     } catch (std::exception& e) {
55740       {
55741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55742       };
55743     } catch (...) {
55744       {
55745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55746       };
55747     }
55748   }
55749 }
55750
55751
55752
55753
55754
55755
55756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55757   int jresult ;
55758   int result;
55759
55760   {
55761     try {
55762       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55763     } catch (std::out_of_range& e) {
55764       {
55765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55766       };
55767     } catch (std::exception& e) {
55768       {
55769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55770       };
55771     } catch (...) {
55772       {
55773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55774       };
55775     }
55776   }
55777   jresult = (int)result;
55778   return jresult;
55779 }
55780
55781
55782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55783   int jresult ;
55784   int result;
55785
55786   {
55787     try {
55788       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55789     } catch (std::out_of_range& e) {
55790       {
55791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55792       };
55793     } catch (std::exception& e) {
55794       {
55795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55796       };
55797     } catch (...) {
55798       {
55799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55800       };
55801     }
55802   }
55803   jresult = (int)result;
55804   return jresult;
55805 }
55806
55807
55808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55809   int jresult ;
55810   int result;
55811
55812   {
55813     try {
55814       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55815     } catch (std::out_of_range& e) {
55816       {
55817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55818       };
55819     } catch (std::exception& e) {
55820       {
55821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55822       };
55823     } catch (...) {
55824       {
55825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55826       };
55827     }
55828   }
55829   jresult = (int)result;
55830   return jresult;
55831 }
55832
55833
55834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55835   int jresult ;
55836   int result;
55837
55838   {
55839     try {
55840       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55841     } catch (std::out_of_range& e) {
55842       {
55843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55844       };
55845     } catch (std::exception& e) {
55846       {
55847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55848       };
55849     } catch (...) {
55850       {
55851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55852       };
55853     }
55854   }
55855   jresult = (int)result;
55856   return jresult;
55857 }
55858
55859
55860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55861   int jresult ;
55862   int result;
55863
55864   {
55865     try {
55866       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55867     } catch (std::out_of_range& e) {
55868       {
55869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55870       };
55871     } catch (std::exception& e) {
55872       {
55873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55874       };
55875     } catch (...) {
55876       {
55877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55878       };
55879     }
55880   }
55881   jresult = (int)result;
55882   return jresult;
55883 }
55884
55885
55886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55887   int jresult ;
55888   int result;
55889
55890   {
55891     try {
55892       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55893     } catch (std::out_of_range& e) {
55894       {
55895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55896       };
55897     } catch (std::exception& e) {
55898       {
55899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55900       };
55901     } catch (...) {
55902       {
55903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55904       };
55905     }
55906   }
55907   jresult = (int)result;
55908   return jresult;
55909 }
55910
55911
55912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55913   int jresult ;
55914   int result;
55915
55916   {
55917     try {
55918       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55919     } catch (std::out_of_range& e) {
55920       {
55921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55922       };
55923     } catch (std::exception& e) {
55924       {
55925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55926       };
55927     } catch (...) {
55928       {
55929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55930       };
55931     }
55932   }
55933   jresult = (int)result;
55934   return jresult;
55935 }
55936
55937
55938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55939   int jresult ;
55940   int result;
55941
55942   {
55943     try {
55944       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55945     } catch (std::out_of_range& e) {
55946       {
55947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55948       };
55949     } catch (std::exception& e) {
55950       {
55951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55952       };
55953     } catch (...) {
55954       {
55955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55956       };
55957     }
55958   }
55959   jresult = (int)result;
55960   return jresult;
55961 }
55962
55963
55964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55965   int jresult ;
55966   int result;
55967
55968   {
55969     try {
55970       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55971     } catch (std::out_of_range& e) {
55972       {
55973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55974       };
55975     } catch (std::exception& e) {
55976       {
55977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55978       };
55979     } catch (...) {
55980       {
55981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55982       };
55983     }
55984   }
55985   jresult = (int)result;
55986   return jresult;
55987 }
55988
55989
55990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55991   int jresult ;
55992   int result;
55993
55994   {
55995     try {
55996       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55997     } catch (std::out_of_range& e) {
55998       {
55999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56000       };
56001     } catch (std::exception& e) {
56002       {
56003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56004       };
56005     } catch (...) {
56006       {
56007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56008       };
56009     }
56010   }
56011   jresult = (int)result;
56012   return jresult;
56013 }
56014
56015
56016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
56017   int jresult ;
56018   int result;
56019
56020   {
56021     try {
56022       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
56023     } catch (std::out_of_range& e) {
56024       {
56025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56026       };
56027     } catch (std::exception& e) {
56028       {
56029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56030       };
56031     } catch (...) {
56032       {
56033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56034       };
56035     }
56036   }
56037   jresult = (int)result;
56038   return jresult;
56039 }
56040
56041
56042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
56043   int jresult ;
56044   int result;
56045
56046   {
56047     try {
56048       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
56049     } catch (std::out_of_range& e) {
56050       {
56051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56052       };
56053     } catch (std::exception& e) {
56054       {
56055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56056       };
56057     } catch (...) {
56058       {
56059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56060       };
56061     }
56062   }
56063   jresult = (int)result;
56064   return jresult;
56065 }
56066
56067
56068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
56069   int jresult ;
56070   int result;
56071
56072   {
56073     try {
56074       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
56075     } catch (std::out_of_range& e) {
56076       {
56077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56078       };
56079     } catch (std::exception& e) {
56080       {
56081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56082       };
56083     } catch (...) {
56084       {
56085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56086       };
56087     }
56088   }
56089   jresult = (int)result;
56090   return jresult;
56091 }
56092
56093
56094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
56095   int jresult ;
56096   int result;
56097
56098   {
56099     try {
56100       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
56101     } catch (std::out_of_range& e) {
56102       {
56103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56104       };
56105     } catch (std::exception& e) {
56106       {
56107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56108       };
56109     } catch (...) {
56110       {
56111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56112       };
56113     }
56114   }
56115   jresult = (int)result;
56116   return jresult;
56117 }
56118
56119
56120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
56121   int jresult ;
56122   int result;
56123
56124   {
56125     try {
56126       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
56127     } catch (std::out_of_range& e) {
56128       {
56129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56130       };
56131     } catch (std::exception& e) {
56132       {
56133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56134       };
56135     } catch (...) {
56136       {
56137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56138       };
56139     }
56140   }
56141   jresult = (int)result;
56142   return jresult;
56143 }
56144
56145
56146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
56147   int jresult ;
56148   int result;
56149
56150   {
56151     try {
56152       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
56153     } catch (std::out_of_range& e) {
56154       {
56155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56156       };
56157     } catch (std::exception& e) {
56158       {
56159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56160       };
56161     } catch (...) {
56162       {
56163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56164       };
56165     }
56166   }
56167   jresult = (int)result;
56168   return jresult;
56169 }
56170
56171
56172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
56173   int jresult ;
56174   int result;
56175
56176   {
56177     try {
56178       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
56179     } catch (std::out_of_range& e) {
56180       {
56181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56182       };
56183     } catch (std::exception& e) {
56184       {
56185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56186       };
56187     } catch (...) {
56188       {
56189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56190       };
56191     }
56192   }
56193   jresult = (int)result;
56194   return jresult;
56195 }
56196
56197
56198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
56199   int jresult ;
56200   int result;
56201
56202   {
56203     try {
56204       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
56205     } catch (std::out_of_range& e) {
56206       {
56207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56208       };
56209     } catch (std::exception& e) {
56210       {
56211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56212       };
56213     } catch (...) {
56214       {
56215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56216       };
56217     }
56218   }
56219   jresult = (int)result;
56220   return jresult;
56221 }
56222
56223
56224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
56225   int jresult ;
56226   int result;
56227
56228   {
56229     try {
56230       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
56231     } catch (std::out_of_range& e) {
56232       {
56233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56234       };
56235     } catch (std::exception& e) {
56236       {
56237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56238       };
56239     } catch (...) {
56240       {
56241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56242       };
56243     }
56244   }
56245   jresult = (int)result;
56246   return jresult;
56247 }
56248
56249
56250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
56251   int jresult ;
56252   int result;
56253
56254   {
56255     try {
56256       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
56257     } catch (std::out_of_range& e) {
56258       {
56259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56260       };
56261     } catch (std::exception& e) {
56262       {
56263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56264       };
56265     } catch (...) {
56266       {
56267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56268       };
56269     }
56270   }
56271   jresult = (int)result;
56272   return jresult;
56273 }
56274
56275
56276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56277   int jresult ;
56278   int result;
56279
56280   {
56281     try {
56282       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56283     } catch (std::out_of_range& e) {
56284       {
56285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56286       };
56287     } catch (std::exception& e) {
56288       {
56289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56290       };
56291     } catch (...) {
56292       {
56293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56294       };
56295     }
56296   }
56297   jresult = (int)result;
56298   return jresult;
56299 }
56300
56301
56302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56303   int jresult ;
56304   int result;
56305
56306   {
56307     try {
56308       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56309     } catch (std::out_of_range& e) {
56310       {
56311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56312       };
56313     } catch (std::exception& e) {
56314       {
56315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56316       };
56317     } catch (...) {
56318       {
56319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56320       };
56321     }
56322   }
56323   jresult = (int)result;
56324   return jresult;
56325 }
56326
56327
56328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56329   int jresult ;
56330   int result;
56331
56332   {
56333     try {
56334       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56335     } catch (std::out_of_range& e) {
56336       {
56337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56338       };
56339     } catch (std::exception& e) {
56340       {
56341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56342       };
56343     } catch (...) {
56344       {
56345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56346       };
56347     }
56348   }
56349   jresult = (int)result;
56350   return jresult;
56351 }
56352
56353
56354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56355   int jresult ;
56356   int result;
56357
56358   {
56359     try {
56360       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56361     } catch (std::out_of_range& e) {
56362       {
56363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56364       };
56365     } catch (std::exception& e) {
56366       {
56367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56368       };
56369     } catch (...) {
56370       {
56371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56372       };
56373     }
56374   }
56375   jresult = (int)result;
56376   return jresult;
56377 }
56378
56379
56380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56381   int jresult ;
56382   int result;
56383
56384   {
56385     try {
56386       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56387     } catch (std::out_of_range& e) {
56388       {
56389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56390       };
56391     } catch (std::exception& e) {
56392       {
56393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56394       };
56395     } catch (...) {
56396       {
56397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56398       };
56399     }
56400   }
56401   jresult = (int)result;
56402   return jresult;
56403 }
56404
56405
56406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56407   int jresult ;
56408   int result;
56409
56410   {
56411     try {
56412       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56413     } catch (std::out_of_range& e) {
56414       {
56415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56416       };
56417     } catch (std::exception& e) {
56418       {
56419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56420       };
56421     } catch (...) {
56422       {
56423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56424       };
56425     }
56426   }
56427   jresult = (int)result;
56428   return jresult;
56429 }
56430
56431
56432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56433   int jresult ;
56434   int result;
56435
56436   {
56437     try {
56438       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56439     } catch (std::out_of_range& e) {
56440       {
56441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56442       };
56443     } catch (std::exception& e) {
56444       {
56445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56446       };
56447     } catch (...) {
56448       {
56449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56450       };
56451     }
56452   }
56453   jresult = (int)result;
56454   return jresult;
56455 }
56456
56457
56458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56459   int jresult ;
56460   int result;
56461
56462   {
56463     try {
56464       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56465     } catch (std::out_of_range& e) {
56466       {
56467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56468       };
56469     } catch (std::exception& e) {
56470       {
56471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56472       };
56473     } catch (...) {
56474       {
56475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56476       };
56477     }
56478   }
56479   jresult = (int)result;
56480   return jresult;
56481 }
56482
56483
56484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56485   int jresult ;
56486   int result;
56487
56488   {
56489     try {
56490       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56491     } catch (std::out_of_range& e) {
56492       {
56493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56494       };
56495     } catch (std::exception& e) {
56496       {
56497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56498       };
56499     } catch (...) {
56500       {
56501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56502       };
56503     }
56504   }
56505   jresult = (int)result;
56506   return jresult;
56507 }
56508
56509
56510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56511   int jresult ;
56512   int result;
56513
56514   {
56515     try {
56516       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56517     } catch (std::out_of_range& e) {
56518       {
56519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56520       };
56521     } catch (std::exception& e) {
56522       {
56523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56524       };
56525     } catch (...) {
56526       {
56527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56528       };
56529     }
56530   }
56531   jresult = (int)result;
56532   return jresult;
56533 }
56534
56535
56536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56537   int jresult ;
56538   int result;
56539
56540   {
56541     try {
56542       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56543     } catch (std::out_of_range& e) {
56544       {
56545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56546       };
56547     } catch (std::exception& e) {
56548       {
56549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56550       };
56551     } catch (...) {
56552       {
56553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56554       };
56555     }
56556   }
56557   jresult = (int)result;
56558   return jresult;
56559 }
56560
56561
56562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56563   int jresult ;
56564   int result;
56565
56566   {
56567     try {
56568       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56569     } catch (std::out_of_range& e) {
56570       {
56571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56572       };
56573     } catch (std::exception& e) {
56574       {
56575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56576       };
56577     } catch (...) {
56578       {
56579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56580       };
56581     }
56582   }
56583   jresult = (int)result;
56584   return jresult;
56585 }
56586
56587
56588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56589   int jresult ;
56590   int result;
56591
56592   {
56593     try {
56594       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56595     } catch (std::out_of_range& e) {
56596       {
56597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56598       };
56599     } catch (std::exception& e) {
56600       {
56601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56602       };
56603     } catch (...) {
56604       {
56605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56606       };
56607     }
56608   }
56609   jresult = (int)result;
56610   return jresult;
56611 }
56612
56613
56614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56615   int jresult ;
56616   int result;
56617
56618   {
56619     try {
56620       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56621     } catch (std::out_of_range& e) {
56622       {
56623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56624       };
56625     } catch (std::exception& e) {
56626       {
56627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56628       };
56629     } catch (...) {
56630       {
56631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56632       };
56633     }
56634   }
56635   jresult = (int)result;
56636   return jresult;
56637 }
56638
56639
56640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56641   int jresult ;
56642   int result;
56643
56644   {
56645     try {
56646       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56647     } catch (std::out_of_range& e) {
56648       {
56649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56650       };
56651     } catch (std::exception& e) {
56652       {
56653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56654       };
56655     } catch (...) {
56656       {
56657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56658       };
56659     }
56660   }
56661   jresult = (int)result;
56662   return jresult;
56663 }
56664
56665
56666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56667   int jresult ;
56668   int result;
56669
56670   {
56671     try {
56672       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56673     } catch (std::out_of_range& e) {
56674       {
56675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56676       };
56677     } catch (std::exception& e) {
56678       {
56679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56680       };
56681     } catch (...) {
56682       {
56683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56684       };
56685     }
56686   }
56687   jresult = (int)result;
56688   return jresult;
56689 }
56690
56691
56692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56693   int jresult ;
56694   int result;
56695
56696   {
56697     try {
56698       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56699     } catch (std::out_of_range& e) {
56700       {
56701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56702       };
56703     } catch (std::exception& e) {
56704       {
56705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56706       };
56707     } catch (...) {
56708       {
56709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56710       };
56711     }
56712   }
56713   jresult = (int)result;
56714   return jresult;
56715 }
56716
56717
56718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56719   int jresult ;
56720   int result;
56721
56722   {
56723     try {
56724       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56725     } catch (std::out_of_range& e) {
56726       {
56727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56728       };
56729     } catch (std::exception& e) {
56730       {
56731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56732       };
56733     } catch (...) {
56734       {
56735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56736       };
56737     }
56738   }
56739   jresult = (int)result;
56740   return jresult;
56741 }
56742
56743
56744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56745   int jresult ;
56746   int result;
56747
56748   {
56749     try {
56750       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56751     } catch (std::out_of_range& e) {
56752       {
56753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56754       };
56755     } catch (std::exception& e) {
56756       {
56757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56758       };
56759     } catch (...) {
56760       {
56761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56762       };
56763     }
56764   }
56765   jresult = (int)result;
56766   return jresult;
56767 }
56768
56769
56770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56771   int jresult ;
56772   int result;
56773
56774   {
56775     try {
56776       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56777     } catch (std::out_of_range& e) {
56778       {
56779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56780       };
56781     } catch (std::exception& e) {
56782       {
56783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56784       };
56785     } catch (...) {
56786       {
56787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56788       };
56789     }
56790   }
56791   jresult = (int)result;
56792   return jresult;
56793 }
56794
56795
56796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56797   int jresult ;
56798   int result;
56799
56800   {
56801     try {
56802       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56803     } catch (std::out_of_range& e) {
56804       {
56805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56806       };
56807     } catch (std::exception& e) {
56808       {
56809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56810       };
56811     } catch (...) {
56812       {
56813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56814       };
56815     }
56816   }
56817   jresult = (int)result;
56818   return jresult;
56819 }
56820
56821
56822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56823   int jresult ;
56824   int result;
56825
56826   {
56827     try {
56828       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56829     } catch (std::out_of_range& e) {
56830       {
56831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56832       };
56833     } catch (std::exception& e) {
56834       {
56835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56836       };
56837     } catch (...) {
56838       {
56839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56840       };
56841     }
56842   }
56843   jresult = (int)result;
56844   return jresult;
56845 }
56846
56847
56848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56849   int jresult ;
56850   int result;
56851
56852   {
56853     try {
56854       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56855     } catch (std::out_of_range& e) {
56856       {
56857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56858       };
56859     } catch (std::exception& e) {
56860       {
56861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56862       };
56863     } catch (...) {
56864       {
56865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56866       };
56867     }
56868   }
56869   jresult = (int)result;
56870   return jresult;
56871 }
56872
56873
56874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56875   int jresult ;
56876   int result;
56877
56878   {
56879     try {
56880       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56881     } catch (std::out_of_range& e) {
56882       {
56883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56884       };
56885     } catch (std::exception& e) {
56886       {
56887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56888       };
56889     } catch (...) {
56890       {
56891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56892       };
56893     }
56894   }
56895   jresult = (int)result;
56896   return jresult;
56897 }
56898
56899
56900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56901   int jresult ;
56902   int result;
56903
56904   {
56905     try {
56906       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56907     } catch (std::out_of_range& e) {
56908       {
56909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56910       };
56911     } catch (std::exception& e) {
56912       {
56913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56914       };
56915     } catch (...) {
56916       {
56917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56918       };
56919     }
56920   }
56921   jresult = (int)result;
56922   return jresult;
56923 }
56924
56925
56926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56927   int jresult ;
56928   int result;
56929
56930   {
56931     try {
56932       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56933     } catch (std::out_of_range& e) {
56934       {
56935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56936       };
56937     } catch (std::exception& e) {
56938       {
56939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56940       };
56941     } catch (...) {
56942       {
56943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56944       };
56945     }
56946   }
56947   jresult = (int)result;
56948   return jresult;
56949 }
56950
56951
56952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56953   int jresult ;
56954   int result;
56955
56956   {
56957     try {
56958       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
56959     } catch (std::out_of_range& e) {
56960       {
56961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56962       };
56963     } catch (std::exception& e) {
56964       {
56965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56966       };
56967     } catch (...) {
56968       {
56969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56970       };
56971     }
56972   }
56973   jresult = (int)result;
56974   return jresult;
56975 }
56976
56977
56978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
56979   int jresult ;
56980   int result;
56981
56982   {
56983     try {
56984       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
56985     } catch (std::out_of_range& e) {
56986       {
56987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56988       };
56989     } catch (std::exception& e) {
56990       {
56991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56992       };
56993     } catch (...) {
56994       {
56995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56996       };
56997     }
56998   }
56999   jresult = (int)result;
57000   return jresult;
57001 }
57002
57003
57004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57005   int jresult ;
57006   int result;
57007
57008   {
57009     try {
57010       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57011     } catch (std::out_of_range& e) {
57012       {
57013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57014       };
57015     } catch (std::exception& e) {
57016       {
57017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57018       };
57019     } catch (...) {
57020       {
57021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57022       };
57023     }
57024   }
57025   jresult = (int)result;
57026   return jresult;
57027 }
57028
57029
57030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57031   int jresult ;
57032   int result;
57033
57034   {
57035     try {
57036       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57037     } catch (std::out_of_range& e) {
57038       {
57039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57040       };
57041     } catch (std::exception& e) {
57042       {
57043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57044       };
57045     } catch (...) {
57046       {
57047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57048       };
57049     }
57050   }
57051   jresult = (int)result;
57052   return jresult;
57053 }
57054
57055
57056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57057   int jresult ;
57058   int result;
57059
57060   {
57061     try {
57062       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57063     } catch (std::out_of_range& e) {
57064       {
57065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57066       };
57067     } catch (std::exception& e) {
57068       {
57069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57070       };
57071     } catch (...) {
57072       {
57073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57074       };
57075     }
57076   }
57077   jresult = (int)result;
57078   return jresult;
57079 }
57080
57081
57082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57083   int jresult ;
57084   int result;
57085
57086   {
57087     try {
57088       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57089     } catch (std::out_of_range& e) {
57090       {
57091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57092       };
57093     } catch (std::exception& e) {
57094       {
57095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57096       };
57097     } catch (...) {
57098       {
57099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57100       };
57101     }
57102   }
57103   jresult = (int)result;
57104   return jresult;
57105 }
57106
57107
57108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57109   int jresult ;
57110   int result;
57111
57112   {
57113     try {
57114       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57115     } catch (std::out_of_range& e) {
57116       {
57117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57118       };
57119     } catch (std::exception& e) {
57120       {
57121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57122       };
57123     } catch (...) {
57124       {
57125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57126       };
57127     }
57128   }
57129   jresult = (int)result;
57130   return jresult;
57131 }
57132
57133
57134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57135   int jresult ;
57136   int result;
57137
57138   {
57139     try {
57140       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57141     } catch (std::out_of_range& e) {
57142       {
57143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57144       };
57145     } catch (std::exception& e) {
57146       {
57147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57148       };
57149     } catch (...) {
57150       {
57151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57152       };
57153     }
57154   }
57155   jresult = (int)result;
57156   return jresult;
57157 }
57158
57159
57160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57161   int jresult ;
57162   int result;
57163
57164   {
57165     try {
57166       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57167     } catch (std::out_of_range& e) {
57168       {
57169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57170       };
57171     } catch (std::exception& e) {
57172       {
57173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57174       };
57175     } catch (...) {
57176       {
57177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57178       };
57179     }
57180   }
57181   jresult = (int)result;
57182   return jresult;
57183 }
57184
57185
57186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57187   int jresult ;
57188   int result;
57189
57190   {
57191     try {
57192       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57193     } catch (std::out_of_range& e) {
57194       {
57195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57196       };
57197     } catch (std::exception& e) {
57198       {
57199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57200       };
57201     } catch (...) {
57202       {
57203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57204       };
57205     }
57206   }
57207   jresult = (int)result;
57208   return jresult;
57209 }
57210
57211
57212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57213   int jresult ;
57214   int result;
57215
57216   {
57217     try {
57218       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57219     } catch (std::out_of_range& e) {
57220       {
57221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57222       };
57223     } catch (std::exception& e) {
57224       {
57225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57226       };
57227     } catch (...) {
57228       {
57229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57230       };
57231     }
57232   }
57233   jresult = (int)result;
57234   return jresult;
57235 }
57236
57237
57238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57239   void * jresult ;
57240   Dali::Toolkit::Builder *result = 0 ;
57241
57242   {
57243     try {
57244       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57245     } catch (std::out_of_range& e) {
57246       {
57247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57248       };
57249     } catch (std::exception& e) {
57250       {
57251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57252       };
57253     } catch (...) {
57254       {
57255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57256       };
57257     }
57258   }
57259   jresult = (void *)result;
57260   return jresult;
57261 }
57262
57263
57264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57265   void * jresult ;
57266   Dali::Toolkit::Builder result;
57267
57268   {
57269     try {
57270       result = Dali::Toolkit::Builder::New();
57271     } catch (std::out_of_range& e) {
57272       {
57273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57274       };
57275     } catch (std::exception& e) {
57276       {
57277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57278       };
57279     } catch (...) {
57280       {
57281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57282       };
57283     }
57284   }
57285   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57286   return jresult;
57287 }
57288
57289
57290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57291   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57292
57293   arg1 = (Dali::Toolkit::Builder *)jarg1;
57294   {
57295     try {
57296       delete arg1;
57297     } catch (std::out_of_range& e) {
57298       {
57299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57300       };
57301     } catch (std::exception& e) {
57302       {
57303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57304       };
57305     } catch (...) {
57306       {
57307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57308       };
57309     }
57310   }
57311 }
57312
57313
57314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57315   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57316   std::string *arg2 = 0 ;
57317   Dali::Toolkit::Builder::UIFormat arg3 ;
57318
57319   arg1 = (Dali::Toolkit::Builder *)jarg1;
57320   if (!jarg2) {
57321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57322     return ;
57323   }
57324   std::string arg2_str(jarg2);
57325   arg2 = &arg2_str;
57326   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57327   {
57328     try {
57329       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57330     } catch (std::out_of_range& e) {
57331       {
57332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57333       };
57334     } catch (std::exception& e) {
57335       {
57336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57337       };
57338     } catch (...) {
57339       {
57340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57341       };
57342     }
57343   }
57344
57345   //argout typemap for const std::string&
57346
57347 }
57348
57349
57350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57351   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57352   std::string *arg2 = 0 ;
57353
57354   arg1 = (Dali::Toolkit::Builder *)jarg1;
57355   if (!jarg2) {
57356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57357     return ;
57358   }
57359   std::string arg2_str(jarg2);
57360   arg2 = &arg2_str;
57361   {
57362     try {
57363       (arg1)->LoadFromString((std::string const &)*arg2);
57364     } catch (std::out_of_range& e) {
57365       {
57366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57367       };
57368     } catch (std::exception& e) {
57369       {
57370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57371       };
57372     } catch (...) {
57373       {
57374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57375       };
57376     }
57377   }
57378
57379   //argout typemap for const std::string&
57380
57381 }
57382
57383
57384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57385   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57386   Dali::Property::Map *arg2 = 0 ;
57387
57388   arg1 = (Dali::Toolkit::Builder *)jarg1;
57389   arg2 = (Dali::Property::Map *)jarg2;
57390   if (!arg2) {
57391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57392     return ;
57393   }
57394   {
57395     try {
57396       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57397     } catch (std::out_of_range& e) {
57398       {
57399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57400       };
57401     } catch (std::exception& e) {
57402       {
57403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57404       };
57405     } catch (...) {
57406       {
57407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57408       };
57409     }
57410   }
57411 }
57412
57413
57414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57415   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57416   std::string *arg2 = 0 ;
57417   Dali::Property::Value *arg3 = 0 ;
57418
57419   arg1 = (Dali::Toolkit::Builder *)jarg1;
57420   if (!jarg2) {
57421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57422     return ;
57423   }
57424   std::string arg2_str(jarg2);
57425   arg2 = &arg2_str;
57426   arg3 = (Dali::Property::Value *)jarg3;
57427   if (!arg3) {
57428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57429     return ;
57430   }
57431   {
57432     try {
57433       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57434     } catch (std::out_of_range& e) {
57435       {
57436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57437       };
57438     } catch (std::exception& e) {
57439       {
57440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57441       };
57442     } catch (...) {
57443       {
57444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57445       };
57446     }
57447   }
57448
57449   //argout typemap for const std::string&
57450
57451 }
57452
57453
57454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57455   void * jresult ;
57456   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57457   Dali::Property::Map *result = 0 ;
57458
57459   arg1 = (Dali::Toolkit::Builder *)jarg1;
57460   {
57461     try {
57462       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57463     } catch (std::out_of_range& e) {
57464       {
57465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57466       };
57467     } catch (std::exception& e) {
57468       {
57469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57470       };
57471     } catch (...) {
57472       {
57473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57474       };
57475     }
57476   }
57477   jresult = (void *)result;
57478   return jresult;
57479 }
57480
57481
57482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57483   void * jresult ;
57484   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57485   std::string *arg2 = 0 ;
57486   Dali::Property::Value *result = 0 ;
57487
57488   arg1 = (Dali::Toolkit::Builder *)jarg1;
57489   if (!jarg2) {
57490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57491     return 0;
57492   }
57493   std::string arg2_str(jarg2);
57494   arg2 = &arg2_str;
57495   {
57496     try {
57497       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57498     } catch (std::out_of_range& e) {
57499       {
57500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57501       };
57502     } catch (std::exception& e) {
57503       {
57504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57505       };
57506     } catch (...) {
57507       {
57508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57509       };
57510     }
57511   }
57512   jresult = (void *)result;
57513
57514   //argout typemap for const std::string&
57515
57516   return jresult;
57517 }
57518
57519
57520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57521   void * jresult ;
57522   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57523   std::string *arg2 = 0 ;
57524   Dali::Animation result;
57525
57526   arg1 = (Dali::Toolkit::Builder *)jarg1;
57527   if (!jarg2) {
57528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57529     return 0;
57530   }
57531   std::string arg2_str(jarg2);
57532   arg2 = &arg2_str;
57533   {
57534     try {
57535       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57536     } catch (std::out_of_range& e) {
57537       {
57538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57539       };
57540     } catch (std::exception& e) {
57541       {
57542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57543       };
57544     } catch (...) {
57545       {
57546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57547       };
57548     }
57549   }
57550   jresult = new Dali::Animation((const Dali::Animation &)result);
57551
57552   //argout typemap for const std::string&
57553
57554   return jresult;
57555 }
57556
57557
57558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57559   void * jresult ;
57560   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57561   std::string *arg2 = 0 ;
57562   Dali::Property::Map *arg3 = 0 ;
57563   Dali::Animation result;
57564
57565   arg1 = (Dali::Toolkit::Builder *)jarg1;
57566   if (!jarg2) {
57567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57568     return 0;
57569   }
57570   std::string arg2_str(jarg2);
57571   arg2 = &arg2_str;
57572   arg3 = (Dali::Property::Map *)jarg3;
57573   if (!arg3) {
57574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57575     return 0;
57576   }
57577   {
57578     try {
57579       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57580     } catch (std::out_of_range& e) {
57581       {
57582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57583       };
57584     } catch (std::exception& e) {
57585       {
57586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57587       };
57588     } catch (...) {
57589       {
57590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57591       };
57592     }
57593   }
57594   jresult = new Dali::Animation((const Dali::Animation &)result);
57595
57596   //argout typemap for const std::string&
57597
57598   return jresult;
57599 }
57600
57601
57602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57603   void * jresult ;
57604   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57605   std::string *arg2 = 0 ;
57606   Dali::Actor arg3 ;
57607   Dali::Actor *argp3 ;
57608   Dali::Animation result;
57609
57610   arg1 = (Dali::Toolkit::Builder *)jarg1;
57611   if (!jarg2) {
57612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57613     return 0;
57614   }
57615   std::string arg2_str(jarg2);
57616   arg2 = &arg2_str;
57617   argp3 = (Dali::Actor *)jarg3;
57618   if (!argp3) {
57619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57620     return 0;
57621   }
57622   arg3 = *argp3;
57623   {
57624     try {
57625       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57626     } catch (std::out_of_range& e) {
57627       {
57628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57629       };
57630     } catch (std::exception& e) {
57631       {
57632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57633       };
57634     } catch (...) {
57635       {
57636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57637       };
57638     }
57639   }
57640   jresult = new Dali::Animation((const Dali::Animation &)result);
57641
57642   //argout typemap for const std::string&
57643
57644   return jresult;
57645 }
57646
57647
57648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57649   void * jresult ;
57650   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57651   std::string *arg2 = 0 ;
57652   Dali::Property::Map *arg3 = 0 ;
57653   Dali::Actor arg4 ;
57654   Dali::Actor *argp4 ;
57655   Dali::Animation result;
57656
57657   arg1 = (Dali::Toolkit::Builder *)jarg1;
57658   if (!jarg2) {
57659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57660     return 0;
57661   }
57662   std::string arg2_str(jarg2);
57663   arg2 = &arg2_str;
57664   arg3 = (Dali::Property::Map *)jarg3;
57665   if (!arg3) {
57666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57667     return 0;
57668   }
57669   argp4 = (Dali::Actor *)jarg4;
57670   if (!argp4) {
57671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57672     return 0;
57673   }
57674   arg4 = *argp4;
57675   {
57676     try {
57677       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57678     } catch (std::out_of_range& e) {
57679       {
57680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57681       };
57682     } catch (std::exception& e) {
57683       {
57684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57685       };
57686     } catch (...) {
57687       {
57688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57689       };
57690     }
57691   }
57692   jresult = new Dali::Animation((const Dali::Animation &)result);
57693
57694   //argout typemap for const std::string&
57695
57696   return jresult;
57697 }
57698
57699
57700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57701   void * jresult ;
57702   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57703   std::string *arg2 = 0 ;
57704   Dali::BaseHandle result;
57705
57706   arg1 = (Dali::Toolkit::Builder *)jarg1;
57707   if (!jarg2) {
57708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57709     return 0;
57710   }
57711   std::string arg2_str(jarg2);
57712   arg2 = &arg2_str;
57713   {
57714     try {
57715       result = (arg1)->Create((std::string const &)*arg2);
57716     } catch (std::out_of_range& e) {
57717       {
57718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57719       };
57720     } catch (std::exception& e) {
57721       {
57722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57723       };
57724     } catch (...) {
57725       {
57726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57727       };
57728     }
57729   }
57730   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57731
57732   //argout typemap for const std::string&
57733
57734   return jresult;
57735 }
57736
57737
57738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57739   void * jresult ;
57740   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57741   std::string *arg2 = 0 ;
57742   Dali::Property::Map *arg3 = 0 ;
57743   Dali::BaseHandle result;
57744
57745   arg1 = (Dali::Toolkit::Builder *)jarg1;
57746   if (!jarg2) {
57747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57748     return 0;
57749   }
57750   std::string arg2_str(jarg2);
57751   arg2 = &arg2_str;
57752   arg3 = (Dali::Property::Map *)jarg3;
57753   if (!arg3) {
57754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57755     return 0;
57756   }
57757   {
57758     try {
57759       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57760     } catch (std::out_of_range& e) {
57761       {
57762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57763       };
57764     } catch (std::exception& e) {
57765       {
57766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57767       };
57768     } catch (...) {
57769       {
57770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57771       };
57772     }
57773   }
57774   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57775
57776   //argout typemap for const std::string&
57777
57778   return jresult;
57779 }
57780
57781
57782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57783   void * jresult ;
57784   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57785   std::string *arg2 = 0 ;
57786   Dali::BaseHandle result;
57787
57788   arg1 = (Dali::Toolkit::Builder *)jarg1;
57789   if (!jarg2) {
57790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57791     return 0;
57792   }
57793   std::string arg2_str(jarg2);
57794   arg2 = &arg2_str;
57795   {
57796     try {
57797       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57798     } catch (std::out_of_range& e) {
57799       {
57800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57801       };
57802     } catch (std::exception& e) {
57803       {
57804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57805       };
57806     } catch (...) {
57807       {
57808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57809       };
57810     }
57811   }
57812   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57813
57814   //argout typemap for const std::string&
57815
57816   return jresult;
57817 }
57818
57819
57820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57821   unsigned int jresult ;
57822   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57823   std::string *arg2 = 0 ;
57824   Dali::Handle *arg3 = 0 ;
57825   bool result;
57826
57827   arg1 = (Dali::Toolkit::Builder *)jarg1;
57828   if (!jarg2) {
57829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57830     return 0;
57831   }
57832   std::string arg2_str(jarg2);
57833   arg2 = &arg2_str;
57834   arg3 = (Dali::Handle *)jarg3;
57835   if (!arg3) {
57836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57837     return 0;
57838   }
57839   {
57840     try {
57841       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
57842     } catch (std::out_of_range& e) {
57843       {
57844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57845       };
57846     } catch (std::exception& e) {
57847       {
57848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57849       };
57850     } catch (...) {
57851       {
57852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57853       };
57854     }
57855   }
57856   jresult = result;
57857
57858   //argout typemap for const std::string&
57859
57860   return jresult;
57861 }
57862
57863
57864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
57865   unsigned int jresult ;
57866   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57867   Dali::Handle *arg2 = 0 ;
57868   std::string *arg3 = 0 ;
57869   bool result;
57870
57871   arg1 = (Dali::Toolkit::Builder *)jarg1;
57872   arg2 = (Dali::Handle *)jarg2;
57873   if (!arg2) {
57874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57875     return 0;
57876   }
57877   if (!jarg3) {
57878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57879     return 0;
57880   }
57881   std::string arg3_str(jarg3);
57882   arg3 = &arg3_str;
57883   {
57884     try {
57885       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
57886     } catch (std::out_of_range& e) {
57887       {
57888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57889       };
57890     } catch (std::exception& e) {
57891       {
57892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57893       };
57894     } catch (...) {
57895       {
57896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57897       };
57898     }
57899   }
57900   jresult = result;
57901
57902   //argout typemap for const std::string&
57903
57904   return jresult;
57905 }
57906
57907
57908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
57909   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57910   Dali::Actor arg2 ;
57911   Dali::Actor *argp2 ;
57912
57913   arg1 = (Dali::Toolkit::Builder *)jarg1;
57914   argp2 = (Dali::Actor *)jarg2;
57915   if (!argp2) {
57916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57917     return ;
57918   }
57919   arg2 = *argp2;
57920   {
57921     try {
57922       (arg1)->AddActors(arg2);
57923     } catch (std::out_of_range& e) {
57924       {
57925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57926       };
57927     } catch (std::exception& e) {
57928       {
57929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57930       };
57931     } catch (...) {
57932       {
57933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57934       };
57935     }
57936   }
57937 }
57938
57939
57940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57941   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57942   std::string *arg2 = 0 ;
57943   Dali::Actor arg3 ;
57944   Dali::Actor *argp3 ;
57945
57946   arg1 = (Dali::Toolkit::Builder *)jarg1;
57947   if (!jarg2) {
57948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57949     return ;
57950   }
57951   std::string arg2_str(jarg2);
57952   arg2 = &arg2_str;
57953   argp3 = (Dali::Actor *)jarg3;
57954   if (!argp3) {
57955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57956     return ;
57957   }
57958   arg3 = *argp3;
57959   {
57960     try {
57961       (arg1)->AddActors((std::string const &)*arg2,arg3);
57962     } catch (std::out_of_range& e) {
57963       {
57964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57965       };
57966     } catch (std::exception& e) {
57967       {
57968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57969       };
57970     } catch (...) {
57971       {
57972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57973       };
57974     }
57975   }
57976
57977   //argout typemap for const std::string&
57978
57979 }
57980
57981
57982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
57983   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57984   std::string *arg2 = 0 ;
57985
57986   arg1 = (Dali::Toolkit::Builder *)jarg1;
57987   if (!jarg2) {
57988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57989     return ;
57990   }
57991   std::string arg2_str(jarg2);
57992   arg2 = &arg2_str;
57993   {
57994     try {
57995       (arg1)->CreateRenderTask((std::string const &)*arg2);
57996     } catch (std::out_of_range& e) {
57997       {
57998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57999       };
58000     } catch (std::exception& e) {
58001       {
58002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58003       };
58004     } catch (...) {
58005       {
58006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58007       };
58008     }
58009   }
58010
58011   //argout typemap for const std::string&
58012
58013 }
58014
58015
58016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
58017   void * jresult ;
58018   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58019   std::string *arg2 = 0 ;
58020   Dali::FrameBufferImage result;
58021
58022   arg1 = (Dali::Toolkit::Builder *)jarg1;
58023   if (!jarg2) {
58024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58025     return 0;
58026   }
58027   std::string arg2_str(jarg2);
58028   arg2 = &arg2_str;
58029   {
58030     try {
58031       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
58032     } catch (std::out_of_range& e) {
58033       {
58034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58035       };
58036     } catch (std::exception& e) {
58037       {
58038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58039       };
58040     } catch (...) {
58041       {
58042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58043       };
58044     }
58045   }
58046   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
58047
58048   //argout typemap for const std::string&
58049
58050   return jresult;
58051 }
58052
58053
58054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58055   void * jresult ;
58056   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58057   std::string *arg2 = 0 ;
58058   Dali::Path result;
58059
58060   arg1 = (Dali::Toolkit::Builder *)jarg1;
58061   if (!jarg2) {
58062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58063     return 0;
58064   }
58065   std::string arg2_str(jarg2);
58066   arg2 = &arg2_str;
58067   {
58068     try {
58069       result = (arg1)->GetPath((std::string const &)*arg2);
58070     } catch (std::out_of_range& e) {
58071       {
58072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58073       };
58074     } catch (std::exception& e) {
58075       {
58076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58077       };
58078     } catch (...) {
58079       {
58080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58081       };
58082     }
58083   }
58084   jresult = new Dali::Path((const Dali::Path &)result);
58085
58086   //argout typemap for const std::string&
58087
58088   return jresult;
58089 }
58090
58091
58092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58093   void * jresult ;
58094   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58095   std::string *arg2 = 0 ;
58096   Dali::PathConstrainer result;
58097
58098   arg1 = (Dali::Toolkit::Builder *)jarg1;
58099   if (!jarg2) {
58100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58101     return 0;
58102   }
58103   std::string arg2_str(jarg2);
58104   arg2 = &arg2_str;
58105   {
58106     try {
58107       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58108     } catch (std::out_of_range& e) {
58109       {
58110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58111       };
58112     } catch (std::exception& e) {
58113       {
58114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58115       };
58116     } catch (...) {
58117       {
58118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58119       };
58120     }
58121   }
58122   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58123
58124   //argout typemap for const std::string&
58125
58126   return jresult;
58127 }
58128
58129
58130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58131   void * jresult ;
58132   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58133   std::string *arg2 = 0 ;
58134   Dali::LinearConstrainer result;
58135
58136   arg1 = (Dali::Toolkit::Builder *)jarg1;
58137   if (!jarg2) {
58138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58139     return 0;
58140   }
58141   std::string arg2_str(jarg2);
58142   arg2 = &arg2_str;
58143   {
58144     try {
58145       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58146     } catch (std::out_of_range& e) {
58147       {
58148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58149       };
58150     } catch (std::exception& e) {
58151       {
58152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58153       };
58154     } catch (...) {
58155       {
58156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58157       };
58158     }
58159   }
58160   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58161
58162   //argout typemap for const std::string&
58163
58164   return jresult;
58165 }
58166
58167
58168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58169   void * jresult ;
58170   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58171   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58172
58173   arg1 = (Dali::Toolkit::Builder *)jarg1;
58174   {
58175     try {
58176       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58177     } catch (std::out_of_range& e) {
58178       {
58179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58180       };
58181     } catch (std::exception& e) {
58182       {
58183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58184       };
58185     } catch (...) {
58186       {
58187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58188       };
58189     }
58190   }
58191   jresult = (void *)result;
58192   return jresult;
58193 }
58194
58195
58196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58197   void * jresult ;
58198   Dali::Toolkit::TransitionData *result = 0 ;
58199
58200   {
58201     try {
58202       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58203     } catch (std::out_of_range& e) {
58204       {
58205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58206       };
58207     } catch (std::exception& e) {
58208       {
58209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58210       };
58211     } catch (...) {
58212       {
58213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58214       };
58215     }
58216   }
58217   jresult = (void *)result;
58218   return jresult;
58219 }
58220
58221
58222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58223   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58224
58225   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58226   {
58227     try {
58228       delete arg1;
58229     } catch (std::out_of_range& e) {
58230       {
58231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58232       };
58233     } catch (std::exception& e) {
58234       {
58235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58236       };
58237     } catch (...) {
58238       {
58239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58240       };
58241     }
58242   }
58243 }
58244
58245
58246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58247   void * jresult ;
58248   Dali::Property::Map *arg1 = 0 ;
58249   Dali::Toolkit::TransitionData result;
58250
58251   arg1 = (Dali::Property::Map *)jarg1;
58252   if (!arg1) {
58253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58254     return 0;
58255   }
58256   {
58257     try {
58258       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58259     } catch (std::out_of_range& e) {
58260       {
58261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58262       };
58263     } catch (std::exception& e) {
58264       {
58265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58266       };
58267     } catch (...) {
58268       {
58269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58270       };
58271     }
58272   }
58273   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58274   return jresult;
58275 }
58276
58277
58278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58279   void * jresult ;
58280   Dali::Property::Array *arg1 = 0 ;
58281   Dali::Toolkit::TransitionData result;
58282
58283   arg1 = (Dali::Property::Array *)jarg1;
58284   if (!arg1) {
58285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58286     return 0;
58287   }
58288   {
58289     try {
58290       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58291     } catch (std::out_of_range& e) {
58292       {
58293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58294       };
58295     } catch (std::exception& e) {
58296       {
58297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58298       };
58299     } catch (...) {
58300       {
58301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58302       };
58303     }
58304   }
58305   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58306   return jresult;
58307 }
58308
58309
58310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58311   void * jresult ;
58312   Dali::BaseHandle arg1 ;
58313   Dali::BaseHandle *argp1 ;
58314   Dali::Toolkit::TransitionData result;
58315
58316   argp1 = (Dali::BaseHandle *)jarg1;
58317   if (!argp1) {
58318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58319     return 0;
58320   }
58321   arg1 = *argp1;
58322   {
58323     try {
58324       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58325     } catch (std::out_of_range& e) {
58326       {
58327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58328       };
58329     } catch (std::exception& e) {
58330       {
58331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58332       };
58333     } catch (...) {
58334       {
58335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58336       };
58337     }
58338   }
58339   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58340   return jresult;
58341 }
58342
58343
58344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58345   void * jresult ;
58346   Dali::Toolkit::TransitionData *arg1 = 0 ;
58347   Dali::Toolkit::TransitionData *result = 0 ;
58348
58349   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58350   if (!arg1) {
58351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58352     return 0;
58353   }
58354   {
58355     try {
58356       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58357     } catch (std::out_of_range& e) {
58358       {
58359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58360       };
58361     } catch (std::exception& e) {
58362       {
58363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58364       };
58365     } catch (...) {
58366       {
58367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58368       };
58369     }
58370   }
58371   jresult = (void *)result;
58372   return jresult;
58373 }
58374
58375
58376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58377   void * jresult ;
58378   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58379   Dali::Toolkit::TransitionData *arg2 = 0 ;
58380   Dali::Toolkit::TransitionData *result = 0 ;
58381
58382   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58383   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58384   if (!arg2) {
58385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58386     return 0;
58387   }
58388   {
58389     try {
58390       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58391     } catch (std::out_of_range& e) {
58392       {
58393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58394       };
58395     } catch (std::exception& e) {
58396       {
58397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58398       };
58399     } catch (...) {
58400       {
58401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58402       };
58403     }
58404   }
58405   jresult = (void *)result;
58406   return jresult;
58407 }
58408
58409
58410 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58411   unsigned long jresult ;
58412   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58413   size_t result;
58414
58415   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58416   {
58417     try {
58418       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58419     } catch (std::out_of_range& e) {
58420       {
58421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58422       };
58423     } catch (std::exception& e) {
58424       {
58425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58426       };
58427     } catch (...) {
58428       {
58429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58430       };
58431     }
58432   }
58433   jresult = (unsigned long)result;
58434   return jresult;
58435 }
58436
58437
58438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58439   void * jresult ;
58440   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58441   size_t arg2 ;
58442   Dali::Property::Map result;
58443
58444   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58445   arg2 = (size_t)jarg2;
58446   {
58447     try {
58448       result = (arg1)->GetAnimatorAt(arg2);
58449     } catch (std::out_of_range& e) {
58450       {
58451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58452       };
58453     } catch (std::exception& e) {
58454       {
58455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58456       };
58457     } catch (...) {
58458       {
58459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58460       };
58461     }
58462   }
58463   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58464   return jresult;
58465 }
58466
58467
58468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
58469   void * jresult ;
58470   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
58471   Dali::Toolkit::TransitionData *result = 0 ;
58472
58473   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
58474   {
58475     try {
58476       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
58477     } catch (std::out_of_range& e) {
58478       {
58479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58480       };
58481     } catch (std::exception& e) {
58482       {
58483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58484       };
58485     } catch (...) {
58486       {
58487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58488       };
58489     }
58490   }
58491   jresult = (void *)result;
58492   return jresult;
58493 }
58494
58495
58496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58497   int jresult ;
58498   int result;
58499
58500   {
58501     try {
58502       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58503     } catch (std::out_of_range& e) {
58504       {
58505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58506       };
58507     } catch (std::exception& e) {
58508       {
58509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58510       };
58511     } catch (...) {
58512       {
58513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58514       };
58515     }
58516   }
58517   jresult = (int)result;
58518   return jresult;
58519 }
58520
58521
58522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58523   int jresult ;
58524   int result;
58525
58526   {
58527     try {
58528       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58529     } catch (std::out_of_range& e) {
58530       {
58531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58532       };
58533     } catch (std::exception& e) {
58534       {
58535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58536       };
58537     } catch (...) {
58538       {
58539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58540       };
58541     }
58542   }
58543   jresult = (int)result;
58544   return jresult;
58545 }
58546
58547
58548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58549   int jresult ;
58550   int result;
58551
58552   {
58553     try {
58554       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58555     } catch (std::out_of_range& e) {
58556       {
58557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58558       };
58559     } catch (std::exception& e) {
58560       {
58561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58562       };
58563     } catch (...) {
58564       {
58565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58566       };
58567     }
58568   }
58569   jresult = (int)result;
58570   return jresult;
58571 }
58572
58573
58574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58575   int jresult ;
58576   int result;
58577
58578   {
58579     try {
58580       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58581     } catch (std::out_of_range& e) {
58582       {
58583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58584       };
58585     } catch (std::exception& e) {
58586       {
58587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58588       };
58589     } catch (...) {
58590       {
58591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58592       };
58593     }
58594   }
58595   jresult = (int)result;
58596   return jresult;
58597 }
58598
58599
58600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58601   int jresult ;
58602   int result;
58603
58604   {
58605     try {
58606       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58607     } catch (std::out_of_range& e) {
58608       {
58609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58610       };
58611     } catch (std::exception& e) {
58612       {
58613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58614       };
58615     } catch (...) {
58616       {
58617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58618       };
58619     }
58620   }
58621   jresult = (int)result;
58622   return jresult;
58623 }
58624
58625
58626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58627   int jresult ;
58628   int result;
58629
58630   {
58631     try {
58632       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58633     } catch (std::out_of_range& e) {
58634       {
58635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58636       };
58637     } catch (std::exception& e) {
58638       {
58639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58640       };
58641     } catch (...) {
58642       {
58643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58644       };
58645     }
58646   }
58647   jresult = (int)result;
58648   return jresult;
58649 }
58650
58651
58652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58653   int jresult ;
58654   int result;
58655
58656   {
58657     try {
58658       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58659     } catch (std::out_of_range& e) {
58660       {
58661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58662       };
58663     } catch (std::exception& e) {
58664       {
58665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58666       };
58667     } catch (...) {
58668       {
58669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58670       };
58671     }
58672   }
58673   jresult = (int)result;
58674   return jresult;
58675 }
58676
58677
58678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58679   int jresult ;
58680   int result;
58681
58682   {
58683     try {
58684       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58685     } catch (std::out_of_range& e) {
58686       {
58687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58688       };
58689     } catch (std::exception& e) {
58690       {
58691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58692       };
58693     } catch (...) {
58694       {
58695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58696       };
58697     }
58698   }
58699   jresult = (int)result;
58700   return jresult;
58701 }
58702
58703
58704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58705   int jresult ;
58706   int result;
58707
58708   {
58709     try {
58710       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58711     } catch (std::out_of_range& e) {
58712       {
58713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58714       };
58715     } catch (std::exception& e) {
58716       {
58717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58718       };
58719     } catch (...) {
58720       {
58721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58722       };
58723     }
58724   }
58725   jresult = (int)result;
58726   return jresult;
58727 }
58728
58729
58730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58731   int jresult ;
58732   int result;
58733
58734   {
58735     try {
58736       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58737     } catch (std::out_of_range& e) {
58738       {
58739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58740       };
58741     } catch (std::exception& e) {
58742       {
58743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58744       };
58745     } catch (...) {
58746       {
58747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58748       };
58749     }
58750   }
58751   jresult = (int)result;
58752   return jresult;
58753 }
58754
58755
58756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58757   int jresult ;
58758   int result;
58759
58760   {
58761     try {
58762       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
58763     } catch (std::out_of_range& e) {
58764       {
58765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58766       };
58767     } catch (std::exception& e) {
58768       {
58769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58770       };
58771     } catch (...) {
58772       {
58773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58774       };
58775     }
58776   }
58777   jresult = (int)result;
58778   return jresult;
58779 }
58780
58781
58782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
58783   int jresult ;
58784   int result;
58785
58786   {
58787     try {
58788       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
58789     } catch (std::out_of_range& e) {
58790       {
58791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58792       };
58793     } catch (std::exception& e) {
58794       {
58795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58796       };
58797     } catch (...) {
58798       {
58799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58800       };
58801     }
58802   }
58803   jresult = (int)result;
58804   return jresult;
58805 }
58806
58807
58808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
58809   int jresult ;
58810   int result;
58811
58812   {
58813     try {
58814       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
58815     } catch (std::out_of_range& e) {
58816       {
58817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58818       };
58819     } catch (std::exception& e) {
58820       {
58821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58822       };
58823     } catch (...) {
58824       {
58825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58826       };
58827     }
58828   }
58829   jresult = (int)result;
58830   return jresult;
58831 }
58832
58833
58834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
58835   int jresult ;
58836   int result;
58837
58838   {
58839     try {
58840       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
58841     } catch (std::out_of_range& e) {
58842       {
58843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58844       };
58845     } catch (std::exception& e) {
58846       {
58847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58848       };
58849     } catch (...) {
58850       {
58851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58852       };
58853     }
58854   }
58855   jresult = (int)result;
58856   return jresult;
58857 }
58858
58859
58860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
58861   void * jresult ;
58862   Dali::Toolkit::Control result;
58863
58864   {
58865     try {
58866       result = Dali::Toolkit::Internal::Control::New();
58867     } catch (std::out_of_range& e) {
58868       {
58869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58870       };
58871     } catch (std::exception& e) {
58872       {
58873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58874       };
58875     } catch (...) {
58876       {
58877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58878       };
58879     }
58880   }
58881   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58882   return jresult;
58883 }
58884
58885
58886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
58887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58888   std::string *arg2 = 0 ;
58889
58890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58891   if (!jarg2) {
58892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58893     return ;
58894   }
58895   std::string arg2_str(jarg2);
58896   arg2 = &arg2_str;
58897   {
58898     try {
58899       (arg1)->SetStyleName((std::string const &)*arg2);
58900     } catch (std::out_of_range& e) {
58901       {
58902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58903       };
58904     } catch (std::exception& e) {
58905       {
58906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58907       };
58908     } catch (...) {
58909       {
58910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58911       };
58912     }
58913   }
58914
58915   //argout typemap for const std::string&
58916
58917 }
58918
58919
58920 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
58921   char * jresult ;
58922   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58923   std::string *result = 0 ;
58924
58925   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58926   {
58927     try {
58928       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
58929     } catch (std::out_of_range& e) {
58930       {
58931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58932       };
58933     } catch (std::exception& e) {
58934       {
58935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58936       };
58937     } catch (...) {
58938       {
58939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58940       };
58941     }
58942   }
58943   jresult = SWIG_csharp_string_callback(result->c_str());
58944   return jresult;
58945 }
58946
58947
58948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
58949   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58950   Dali::Vector4 *arg2 = 0 ;
58951
58952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58953   arg2 = (Dali::Vector4 *)jarg2;
58954   if (!arg2) {
58955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58956     return ;
58957   }
58958   {
58959     try {
58960       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58961     } catch (std::out_of_range& e) {
58962       {
58963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58964       };
58965     } catch (std::exception& e) {
58966       {
58967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58968       };
58969     } catch (...) {
58970       {
58971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58972       };
58973     }
58974   }
58975 }
58976
58977
58978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
58979   void * jresult ;
58980   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58981   Dali::Vector4 result;
58982
58983   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58984   {
58985     try {
58986       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
58987     } catch (std::out_of_range& e) {
58988       {
58989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58990       };
58991     } catch (std::exception& e) {
58992       {
58993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58994       };
58995     } catch (...) {
58996       {
58997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58998       };
58999     }
59000   }
59001   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59002   return jresult;
59003 }
59004
59005
59006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
59007   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59008   Dali::Image arg2 ;
59009   Dali::Image *argp2 ;
59010
59011   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59012   argp2 = (Dali::Image *)jarg2;
59013   if (!argp2) {
59014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
59015     return ;
59016   }
59017   arg2 = *argp2;
59018   {
59019     try {
59020       (arg1)->SetBackgroundImage(arg2);
59021     } catch (std::out_of_range& e) {
59022       {
59023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59024       };
59025     } catch (std::exception& e) {
59026       {
59027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59028       };
59029     } catch (...) {
59030       {
59031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59032       };
59033     }
59034   }
59035 }
59036
59037
59038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59039   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59040   Dali::Property::Map *arg2 = 0 ;
59041
59042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59043   arg2 = (Dali::Property::Map *)jarg2;
59044   if (!arg2) {
59045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59046     return ;
59047   }
59048   {
59049     try {
59050       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59051     } catch (std::out_of_range& e) {
59052       {
59053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59054       };
59055     } catch (std::exception& e) {
59056       {
59057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59058       };
59059     } catch (...) {
59060       {
59061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59062       };
59063     }
59064   }
59065 }
59066
59067
59068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59070
59071   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59072   {
59073     try {
59074       (arg1)->ClearBackground();
59075     } catch (std::out_of_range& e) {
59076       {
59077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59078       };
59079     } catch (std::exception& e) {
59080       {
59081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59082       };
59083     } catch (...) {
59084       {
59085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59086       };
59087     }
59088   }
59089 }
59090
59091
59092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59093   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59094   Dali::Gesture::Type arg2 ;
59095
59096   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59097   arg2 = (Dali::Gesture::Type)jarg2;
59098   {
59099     try {
59100       (arg1)->EnableGestureDetection(arg2);
59101     } catch (std::out_of_range& e) {
59102       {
59103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59104       };
59105     } catch (std::exception& e) {
59106       {
59107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59108       };
59109     } catch (...) {
59110       {
59111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59112       };
59113     }
59114   }
59115 }
59116
59117
59118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59119   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59120   Dali::Gesture::Type arg2 ;
59121
59122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59123   arg2 = (Dali::Gesture::Type)jarg2;
59124   {
59125     try {
59126       (arg1)->DisableGestureDetection(arg2);
59127     } catch (std::out_of_range& e) {
59128       {
59129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59130       };
59131     } catch (std::exception& e) {
59132       {
59133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59134       };
59135     } catch (...) {
59136       {
59137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59138       };
59139     }
59140   }
59141 }
59142
59143
59144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59145   void * jresult ;
59146   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59147   Dali::PinchGestureDetector result;
59148
59149   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59150   {
59151     try {
59152       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59153     } catch (std::out_of_range& e) {
59154       {
59155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59156       };
59157     } catch (std::exception& e) {
59158       {
59159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59160       };
59161     } catch (...) {
59162       {
59163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59164       };
59165     }
59166   }
59167   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59168   return jresult;
59169 }
59170
59171
59172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59173   void * jresult ;
59174   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59175   Dali::PanGestureDetector result;
59176
59177   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59178   {
59179     try {
59180       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59181     } catch (std::out_of_range& e) {
59182       {
59183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59184       };
59185     } catch (std::exception& e) {
59186       {
59187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59188       };
59189     } catch (...) {
59190       {
59191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59192       };
59193     }
59194   }
59195   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59196   return jresult;
59197 }
59198
59199
59200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59201   void * jresult ;
59202   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59203   Dali::TapGestureDetector result;
59204
59205   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59206   {
59207     try {
59208       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59209     } catch (std::out_of_range& e) {
59210       {
59211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59212       };
59213     } catch (std::exception& e) {
59214       {
59215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59216       };
59217     } catch (...) {
59218       {
59219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59220       };
59221     }
59222   }
59223   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59224   return jresult;
59225 }
59226
59227
59228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59229   void * jresult ;
59230   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59231   Dali::LongPressGestureDetector result;
59232
59233   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59234   {
59235     try {
59236       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59237     } catch (std::out_of_range& e) {
59238       {
59239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59240       };
59241     } catch (std::exception& e) {
59242       {
59243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59244       };
59245     } catch (...) {
59246       {
59247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59248       };
59249     }
59250   }
59251   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59252   return jresult;
59253 }
59254
59255
59256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59257   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59258   bool arg2 ;
59259
59260   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59261   arg2 = jarg2 ? true : false;
59262   {
59263     try {
59264       (arg1)->SetKeyboardNavigationSupport(arg2);
59265     } catch (std::out_of_range& e) {
59266       {
59267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59268       };
59269     } catch (std::exception& e) {
59270       {
59271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59272       };
59273     } catch (...) {
59274       {
59275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59276       };
59277     }
59278   }
59279 }
59280
59281
59282 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59283   unsigned int jresult ;
59284   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59285   bool result;
59286
59287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59288   {
59289     try {
59290       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59291     } catch (std::out_of_range& e) {
59292       {
59293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59294       };
59295     } catch (std::exception& e) {
59296       {
59297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59298       };
59299     } catch (...) {
59300       {
59301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59302       };
59303     }
59304   }
59305   jresult = result;
59306   return jresult;
59307 }
59308
59309
59310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59311   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59312
59313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59314   {
59315     try {
59316       (arg1)->SetKeyInputFocus();
59317     } catch (std::out_of_range& e) {
59318       {
59319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59320       };
59321     } catch (std::exception& e) {
59322       {
59323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59324       };
59325     } catch (...) {
59326       {
59327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59328       };
59329     }
59330   }
59331 }
59332
59333
59334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59335   unsigned int jresult ;
59336   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59337   bool result;
59338
59339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59340   {
59341     try {
59342       result = (bool)(arg1)->HasKeyInputFocus();
59343     } catch (std::out_of_range& e) {
59344       {
59345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59346       };
59347     } catch (std::exception& e) {
59348       {
59349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59350       };
59351     } catch (...) {
59352       {
59353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59354       };
59355     }
59356   }
59357   jresult = result;
59358   return jresult;
59359 }
59360
59361
59362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59363   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59364
59365   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59366   {
59367     try {
59368       (arg1)->ClearKeyInputFocus();
59369     } catch (std::out_of_range& e) {
59370       {
59371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59372       };
59373     } catch (std::exception& e) {
59374       {
59375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59376       };
59377     } catch (...) {
59378       {
59379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59380       };
59381     }
59382   }
59383 }
59384
59385
59386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59387   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59388   bool arg2 ;
59389
59390   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59391   arg2 = jarg2 ? true : false;
59392   {
59393     try {
59394       (arg1)->SetAsKeyboardFocusGroup(arg2);
59395     } catch (std::out_of_range& e) {
59396       {
59397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59398       };
59399     } catch (std::exception& e) {
59400       {
59401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59402       };
59403     } catch (...) {
59404       {
59405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59406       };
59407     }
59408   }
59409 }
59410
59411
59412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59413   unsigned int jresult ;
59414   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59415   bool result;
59416
59417   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59418   {
59419     try {
59420       result = (bool)(arg1)->IsKeyboardFocusGroup();
59421     } catch (std::out_of_range& e) {
59422       {
59423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59424       };
59425     } catch (std::exception& e) {
59426       {
59427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59428       };
59429     } catch (...) {
59430       {
59431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59432       };
59433     }
59434   }
59435   jresult = result;
59436   return jresult;
59437 }
59438
59439
59440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
59441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59442
59443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59444   {
59445     try {
59446       (arg1)->AccessibilityActivate();
59447     } catch (std::out_of_range& e) {
59448       {
59449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59450       };
59451     } catch (std::exception& e) {
59452       {
59453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59454       };
59455     } catch (...) {
59456       {
59457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59458       };
59459     }
59460   }
59461 }
59462
59463
59464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
59465   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59466
59467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59468   {
59469     try {
59470       (arg1)->KeyboardEnter();
59471     } catch (std::out_of_range& e) {
59472       {
59473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59474       };
59475     } catch (std::exception& e) {
59476       {
59477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59478       };
59479     } catch (...) {
59480       {
59481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59482       };
59483     }
59484   }
59485 }
59486
59487
59488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59489   void * jresult ;
59490   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59491   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59492
59493   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59494   {
59495     try {
59496       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59497     } catch (std::out_of_range& e) {
59498       {
59499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59500       };
59501     } catch (std::exception& e) {
59502       {
59503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59504       };
59505     } catch (...) {
59506       {
59507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59508       };
59509     }
59510   }
59511   jresult = (void *)result;
59512   return jresult;
59513 }
59514
59515
59516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59517   void * jresult ;
59518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59519   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59520
59521   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59522   {
59523     try {
59524       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59525     } catch (std::out_of_range& e) {
59526       {
59527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59528       };
59529     } catch (std::exception& e) {
59530       {
59531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59532       };
59533     } catch (...) {
59534       {
59535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59536       };
59537     }
59538   }
59539   jresult = (void *)result;
59540   return jresult;
59541 }
59542
59543
59544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59545   void * jresult ;
59546   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59547   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59548
59549   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59550   {
59551     try {
59552       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59553     } catch (std::out_of_range& e) {
59554       {
59555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59556       };
59557     } catch (std::exception& e) {
59558       {
59559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59560       };
59561     } catch (...) {
59562       {
59563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59564       };
59565     }
59566   }
59567   jresult = (void *)result;
59568   return jresult;
59569 }
59570
59571
59572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
59573   unsigned int jresult ;
59574   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59575   Dali::KeyEvent *arg2 = 0 ;
59576   bool result;
59577
59578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59579   arg2 = (Dali::KeyEvent *)jarg2;
59580   if (!arg2) {
59581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59582     return 0;
59583   }
59584   {
59585     try {
59586       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
59587     } catch (std::out_of_range& e) {
59588       {
59589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59590       };
59591     } catch (std::exception& e) {
59592       {
59593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59594       };
59595     } catch (...) {
59596       {
59597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59598       };
59599     }
59600   }
59601   jresult = result;
59602   return jresult;
59603 }
59604
59605
59606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
59607   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59608   int arg2 ;
59609   SwigDirector_ViewImpl *darg = 0;
59610
59611   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59612   arg2 = (int)jarg2;
59613   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59614   {
59615     try {
59616       (darg)->OnStageConnection(arg2);
59617     } catch (std::out_of_range& e) {
59618       {
59619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59620       };
59621     } catch (std::exception& e) {
59622       {
59623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59624       };
59625     } catch (...) {
59626       {
59627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59628       };
59629     }
59630   }
59631 }
59632
59633
59634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59635   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59636   int arg2 ;
59637   SwigDirector_ViewImpl *darg = 0;
59638
59639   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59640   arg2 = (int)jarg2;
59641   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59642   {
59643     try {
59644       (darg)->OnStageConnectionSwigPublic(arg2);
59645     } catch (std::out_of_range& e) {
59646       {
59647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59648       };
59649     } catch (std::exception& e) {
59650       {
59651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59652       };
59653     } catch (...) {
59654       {
59655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59656       };
59657     }
59658   }
59659 }
59660
59661
59662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
59663   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59664   SwigDirector_ViewImpl *darg = 0;
59665
59666   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59667   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59668   {
59669     try {
59670       (darg)->OnStageDisconnection();
59671     } catch (std::out_of_range& e) {
59672       {
59673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59674       };
59675     } catch (std::exception& e) {
59676       {
59677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59678       };
59679     } catch (...) {
59680       {
59681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59682       };
59683     }
59684   }
59685 }
59686
59687
59688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
59689   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59690   SwigDirector_ViewImpl *darg = 0;
59691
59692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59693   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59694   {
59695     try {
59696       (darg)->OnStageDisconnectionSwigPublic();
59697     } catch (std::out_of_range& e) {
59698       {
59699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59700       };
59701     } catch (std::exception& e) {
59702       {
59703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59704       };
59705     } catch (...) {
59706       {
59707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59708       };
59709     }
59710   }
59711 }
59712
59713
59714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59716   Dali::Actor *arg2 = 0 ;
59717   SwigDirector_ViewImpl *darg = 0;
59718
59719   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59720   arg2 = (Dali::Actor *)jarg2;
59721   if (!arg2) {
59722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59723     return ;
59724   }
59725   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59726   {
59727     try {
59728       (darg)->OnChildAdd(*arg2);
59729     } catch (std::out_of_range& e) {
59730       {
59731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59732       };
59733     } catch (std::exception& e) {
59734       {
59735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59736       };
59737     } catch (...) {
59738       {
59739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59740       };
59741     }
59742   }
59743 }
59744
59745
59746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59747   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59748   Dali::Actor *arg2 = 0 ;
59749   SwigDirector_ViewImpl *darg = 0;
59750
59751   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59752   arg2 = (Dali::Actor *)jarg2;
59753   if (!arg2) {
59754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59755     return ;
59756   }
59757   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59758   {
59759     try {
59760       (darg)->OnChildAddSwigPublic(*arg2);
59761     } catch (std::out_of_range& e) {
59762       {
59763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59764       };
59765     } catch (std::exception& e) {
59766       {
59767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59768       };
59769     } catch (...) {
59770       {
59771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59772       };
59773     }
59774   }
59775 }
59776
59777
59778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
59779   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59780   Dali::Actor *arg2 = 0 ;
59781   SwigDirector_ViewImpl *darg = 0;
59782
59783   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59784   arg2 = (Dali::Actor *)jarg2;
59785   if (!arg2) {
59786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59787     return ;
59788   }
59789   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59790   {
59791     try {
59792       (darg)->OnChildRemove(*arg2);
59793     } catch (std::out_of_range& e) {
59794       {
59795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59796       };
59797     } catch (std::exception& e) {
59798       {
59799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59800       };
59801     } catch (...) {
59802       {
59803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59804       };
59805     }
59806   }
59807 }
59808
59809
59810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59811   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59812   Dali::Actor *arg2 = 0 ;
59813   SwigDirector_ViewImpl *darg = 0;
59814
59815   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59816   arg2 = (Dali::Actor *)jarg2;
59817   if (!arg2) {
59818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59819     return ;
59820   }
59821   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59822   {
59823     try {
59824       (darg)->OnChildRemoveSwigPublic(*arg2);
59825     } catch (std::out_of_range& e) {
59826       {
59827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59828       };
59829     } catch (std::exception& e) {
59830       {
59831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59832       };
59833     } catch (...) {
59834       {
59835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59836       };
59837     }
59838   }
59839 }
59840
59841
59842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
59843   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59844   Dali::Property::Index arg2 ;
59845   Dali::Property::Value arg3 ;
59846   Dali::Property::Value *argp3 ;
59847   SwigDirector_ViewImpl *darg = 0;
59848
59849   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59850   arg2 = (Dali::Property::Index)jarg2;
59851   argp3 = (Dali::Property::Value *)jarg3;
59852   if (!argp3) {
59853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59854     return ;
59855   }
59856   arg3 = *argp3;
59857   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59858   {
59859     try {
59860       (darg)->OnPropertySet(arg2,arg3);
59861     } catch (std::out_of_range& e) {
59862       {
59863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59864       };
59865     } catch (std::exception& e) {
59866       {
59867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59868       };
59869     } catch (...) {
59870       {
59871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59872       };
59873     }
59874   }
59875 }
59876
59877
59878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
59879   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59880   Dali::Property::Index arg2 ;
59881   Dali::Property::Value arg3 ;
59882   Dali::Property::Value *argp3 ;
59883   SwigDirector_ViewImpl *darg = 0;
59884
59885   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59886   arg2 = (Dali::Property::Index)jarg2;
59887   argp3 = (Dali::Property::Value *)jarg3;
59888   if (!argp3) {
59889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59890     return ;
59891   }
59892   arg3 = *argp3;
59893   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59894   {
59895     try {
59896       (darg)->OnPropertySetSwigPublic(arg2,arg3);
59897     } catch (std::out_of_range& e) {
59898       {
59899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59900       };
59901     } catch (std::exception& e) {
59902       {
59903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59904       };
59905     } catch (...) {
59906       {
59907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59908       };
59909     }
59910   }
59911 }
59912
59913
59914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
59915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59916   Dali::Vector3 *arg2 = 0 ;
59917   SwigDirector_ViewImpl *darg = 0;
59918
59919   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59920   arg2 = (Dali::Vector3 *)jarg2;
59921   if (!arg2) {
59922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59923     return ;
59924   }
59925   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59926   {
59927     try {
59928       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
59929     } catch (std::out_of_range& e) {
59930       {
59931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59932       };
59933     } catch (std::exception& e) {
59934       {
59935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59936       };
59937     } catch (...) {
59938       {
59939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59940       };
59941     }
59942   }
59943 }
59944
59945
59946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59947   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59948   Dali::Vector3 *arg2 = 0 ;
59949   SwigDirector_ViewImpl *darg = 0;
59950
59951   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59952   arg2 = (Dali::Vector3 *)jarg2;
59953   if (!arg2) {
59954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59955     return ;
59956   }
59957   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59958   {
59959     try {
59960       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
59961     } catch (std::out_of_range& e) {
59962       {
59963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59964       };
59965     } catch (std::exception& e) {
59966       {
59967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59968       };
59969     } catch (...) {
59970       {
59971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59972       };
59973     }
59974   }
59975 }
59976
59977
59978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
59979   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59980   Dali::Animation *arg2 = 0 ;
59981   Dali::Vector3 *arg3 = 0 ;
59982   SwigDirector_ViewImpl *darg = 0;
59983
59984   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59985   arg2 = (Dali::Animation *)jarg2;
59986   if (!arg2) {
59987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
59988     return ;
59989   }
59990   arg3 = (Dali::Vector3 *)jarg3;
59991   if (!arg3) {
59992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59993     return ;
59994   }
59995   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59996   {
59997     try {
59998       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
59999     } catch (std::out_of_range& e) {
60000       {
60001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60002       };
60003     } catch (std::exception& e) {
60004       {
60005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60006       };
60007     } catch (...) {
60008       {
60009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60010       };
60011     }
60012   }
60013 }
60014
60015
60016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60017   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60018   Dali::Animation *arg2 = 0 ;
60019   Dali::Vector3 *arg3 = 0 ;
60020   SwigDirector_ViewImpl *darg = 0;
60021
60022   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60023   arg2 = (Dali::Animation *)jarg2;
60024   if (!arg2) {
60025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60026     return ;
60027   }
60028   arg3 = (Dali::Vector3 *)jarg3;
60029   if (!arg3) {
60030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60031     return ;
60032   }
60033   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60034   {
60035     try {
60036       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60037     } catch (std::out_of_range& e) {
60038       {
60039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60040       };
60041     } catch (std::exception& e) {
60042       {
60043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60044       };
60045     } catch (...) {
60046       {
60047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60048       };
60049     }
60050   }
60051 }
60052
60053
60054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60055   unsigned int jresult ;
60056   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60057   Dali::TouchEvent *arg2 = 0 ;
60058   SwigDirector_ViewImpl *darg = 0;
60059   bool result;
60060
60061   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60062   arg2 = (Dali::TouchEvent *)jarg2;
60063   if (!arg2) {
60064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60065     return 0;
60066   }
60067   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60068   {
60069     try {
60070       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60071     } catch (std::out_of_range& e) {
60072       {
60073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60074       };
60075     } catch (std::exception& e) {
60076       {
60077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60078       };
60079     } catch (...) {
60080       {
60081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60082       };
60083     }
60084   }
60085   jresult = result;
60086   return jresult;
60087 }
60088
60089
60090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60091   unsigned int jresult ;
60092   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60093   Dali::TouchEvent *arg2 = 0 ;
60094   SwigDirector_ViewImpl *darg = 0;
60095   bool result;
60096
60097   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60098   arg2 = (Dali::TouchEvent *)jarg2;
60099   if (!arg2) {
60100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60101     return 0;
60102   }
60103   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60104   {
60105     try {
60106       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60107     } catch (std::out_of_range& e) {
60108       {
60109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60110       };
60111     } catch (std::exception& e) {
60112       {
60113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60114       };
60115     } catch (...) {
60116       {
60117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60118       };
60119     }
60120   }
60121   jresult = result;
60122   return jresult;
60123 }
60124
60125
60126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60127   unsigned int jresult ;
60128   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60129   Dali::HoverEvent *arg2 = 0 ;
60130   SwigDirector_ViewImpl *darg = 0;
60131   bool result;
60132
60133   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60134   arg2 = (Dali::HoverEvent *)jarg2;
60135   if (!arg2) {
60136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60137     return 0;
60138   }
60139   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60140   {
60141     try {
60142       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60143     } catch (std::out_of_range& e) {
60144       {
60145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60146       };
60147     } catch (std::exception& e) {
60148       {
60149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60150       };
60151     } catch (...) {
60152       {
60153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60154       };
60155     }
60156   }
60157   jresult = result;
60158   return jresult;
60159 }
60160
60161
60162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60163   unsigned int jresult ;
60164   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60165   Dali::HoverEvent *arg2 = 0 ;
60166   SwigDirector_ViewImpl *darg = 0;
60167   bool result;
60168
60169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60170   arg2 = (Dali::HoverEvent *)jarg2;
60171   if (!arg2) {
60172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60173     return 0;
60174   }
60175   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60176   {
60177     try {
60178       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60179     } catch (std::out_of_range& e) {
60180       {
60181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60182       };
60183     } catch (std::exception& e) {
60184       {
60185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60186       };
60187     } catch (...) {
60188       {
60189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60190       };
60191     }
60192   }
60193   jresult = result;
60194   return jresult;
60195 }
60196
60197
60198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60199   unsigned int jresult ;
60200   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60201   Dali::KeyEvent *arg2 = 0 ;
60202   SwigDirector_ViewImpl *darg = 0;
60203   bool result;
60204
60205   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60206   arg2 = (Dali::KeyEvent *)jarg2;
60207   if (!arg2) {
60208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60209     return 0;
60210   }
60211   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60212   {
60213     try {
60214       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60215     } catch (std::out_of_range& e) {
60216       {
60217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60218       };
60219     } catch (std::exception& e) {
60220       {
60221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60222       };
60223     } catch (...) {
60224       {
60225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60226       };
60227     }
60228   }
60229   jresult = result;
60230   return jresult;
60231 }
60232
60233
60234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60235   unsigned int jresult ;
60236   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60237   Dali::KeyEvent *arg2 = 0 ;
60238   SwigDirector_ViewImpl *darg = 0;
60239   bool result;
60240
60241   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60242   arg2 = (Dali::KeyEvent *)jarg2;
60243   if (!arg2) {
60244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60245     return 0;
60246   }
60247   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60248   {
60249     try {
60250       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60251     } catch (std::out_of_range& e) {
60252       {
60253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60254       };
60255     } catch (std::exception& e) {
60256       {
60257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60258       };
60259     } catch (...) {
60260       {
60261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60262       };
60263     }
60264   }
60265   jresult = result;
60266   return jresult;
60267 }
60268
60269
60270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60271   unsigned int jresult ;
60272   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60273   Dali::WheelEvent *arg2 = 0 ;
60274   SwigDirector_ViewImpl *darg = 0;
60275   bool result;
60276
60277   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60278   arg2 = (Dali::WheelEvent *)jarg2;
60279   if (!arg2) {
60280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60281     return 0;
60282   }
60283   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60284   {
60285     try {
60286       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60287     } catch (std::out_of_range& e) {
60288       {
60289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60290       };
60291     } catch (std::exception& e) {
60292       {
60293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60294       };
60295     } catch (...) {
60296       {
60297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60298       };
60299     }
60300   }
60301   jresult = result;
60302   return jresult;
60303 }
60304
60305
60306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60307   unsigned int jresult ;
60308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60309   Dali::WheelEvent *arg2 = 0 ;
60310   SwigDirector_ViewImpl *darg = 0;
60311   bool result;
60312
60313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60314   arg2 = (Dali::WheelEvent *)jarg2;
60315   if (!arg2) {
60316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60317     return 0;
60318   }
60319   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60320   {
60321     try {
60322       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60323     } catch (std::out_of_range& e) {
60324       {
60325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60326       };
60327     } catch (std::exception& e) {
60328       {
60329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60330       };
60331     } catch (...) {
60332       {
60333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60334       };
60335     }
60336   }
60337   jresult = result;
60338   return jresult;
60339 }
60340
60341
60342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60343   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60344   Dali::Vector2 *arg2 = 0 ;
60345   Dali::RelayoutContainer *arg3 = 0 ;
60346   SwigDirector_ViewImpl *darg = 0;
60347
60348   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60349   arg2 = (Dali::Vector2 *)jarg2;
60350   if (!arg2) {
60351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60352     return ;
60353   }
60354   arg3 = (Dali::RelayoutContainer *)jarg3;
60355   if (!arg3) {
60356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60357     return ;
60358   }
60359   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60360   {
60361     try {
60362       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60363     } catch (std::out_of_range& e) {
60364       {
60365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60366       };
60367     } catch (std::exception& e) {
60368       {
60369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60370       };
60371     } catch (...) {
60372       {
60373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60374       };
60375     }
60376   }
60377 }
60378
60379
60380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60381   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60382   Dali::Vector2 *arg2 = 0 ;
60383   Dali::RelayoutContainer *arg3 = 0 ;
60384   SwigDirector_ViewImpl *darg = 0;
60385
60386   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60387   arg2 = (Dali::Vector2 *)jarg2;
60388   if (!arg2) {
60389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60390     return ;
60391   }
60392   arg3 = (Dali::RelayoutContainer *)jarg3;
60393   if (!arg3) {
60394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60395     return ;
60396   }
60397   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60398   {
60399     try {
60400       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60401     } catch (std::out_of_range& e) {
60402       {
60403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60404       };
60405     } catch (std::exception& e) {
60406       {
60407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60408       };
60409     } catch (...) {
60410       {
60411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60412       };
60413     }
60414   }
60415 }
60416
60417
60418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60419   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60420   Dali::ResizePolicy::Type arg2 ;
60421   Dali::Dimension::Type arg3 ;
60422   SwigDirector_ViewImpl *darg = 0;
60423
60424   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60425   arg2 = (Dali::ResizePolicy::Type)jarg2;
60426   arg3 = (Dali::Dimension::Type)jarg3;
60427   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60428   {
60429     try {
60430       (darg)->OnSetResizePolicy(arg2,arg3);
60431     } catch (std::out_of_range& e) {
60432       {
60433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60434       };
60435     } catch (std::exception& e) {
60436       {
60437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60438       };
60439     } catch (...) {
60440       {
60441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60442       };
60443     }
60444   }
60445 }
60446
60447
60448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60449   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60450   Dali::ResizePolicy::Type arg2 ;
60451   Dali::Dimension::Type arg3 ;
60452   SwigDirector_ViewImpl *darg = 0;
60453
60454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60455   arg2 = (Dali::ResizePolicy::Type)jarg2;
60456   arg3 = (Dali::Dimension::Type)jarg3;
60457   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60458   {
60459     try {
60460       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60461     } catch (std::out_of_range& e) {
60462       {
60463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60464       };
60465     } catch (std::exception& e) {
60466       {
60467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60468       };
60469     } catch (...) {
60470       {
60471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60472       };
60473     }
60474   }
60475 }
60476
60477
60478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60479   void * jresult ;
60480   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60481   SwigDirector_ViewImpl *darg = 0;
60482   Dali::Vector3 result;
60483
60484   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60485   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60486   {
60487     try {
60488       result = (darg)->GetNaturalSize();
60489     } catch (std::out_of_range& e) {
60490       {
60491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60492       };
60493     } catch (std::exception& e) {
60494       {
60495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60496       };
60497     } catch (...) {
60498       {
60499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60500       };
60501     }
60502   }
60503   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60504   return jresult;
60505 }
60506
60507
60508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60509   void * jresult ;
60510   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60511   SwigDirector_ViewImpl *darg = 0;
60512   Dali::Vector3 result;
60513
60514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60515   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60516   {
60517     try {
60518       result = (darg)->GetNaturalSizeSwigPublic();
60519     } catch (std::out_of_range& e) {
60520       {
60521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60522       };
60523     } catch (std::exception& e) {
60524       {
60525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60526       };
60527     } catch (...) {
60528       {
60529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60530       };
60531     }
60532   }
60533   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60534   return jresult;
60535 }
60536
60537
60538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60539   float jresult ;
60540   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60541   Dali::Actor *arg2 = 0 ;
60542   Dali::Dimension::Type arg3 ;
60543   SwigDirector_ViewImpl *darg = 0;
60544   float result;
60545
60546   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60547   arg2 = (Dali::Actor *)jarg2;
60548   if (!arg2) {
60549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60550     return 0;
60551   }
60552   arg3 = (Dali::Dimension::Type)jarg3;
60553   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60554   {
60555     try {
60556       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
60557     } catch (std::out_of_range& e) {
60558       {
60559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60560       };
60561     } catch (std::exception& e) {
60562       {
60563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60564       };
60565     } catch (...) {
60566       {
60567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60568       };
60569     }
60570   }
60571   jresult = result;
60572   return jresult;
60573 }
60574
60575
60576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60577   float jresult ;
60578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60579   Dali::Actor *arg2 = 0 ;
60580   Dali::Dimension::Type arg3 ;
60581   SwigDirector_ViewImpl *darg = 0;
60582   float result;
60583
60584   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60585   arg2 = (Dali::Actor *)jarg2;
60586   if (!arg2) {
60587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60588     return 0;
60589   }
60590   arg3 = (Dali::Dimension::Type)jarg3;
60591   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60592   {
60593     try {
60594       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
60595     } catch (std::out_of_range& e) {
60596       {
60597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60598       };
60599     } catch (std::exception& e) {
60600       {
60601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60602       };
60603     } catch (...) {
60604       {
60605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60606       };
60607     }
60608   }
60609   jresult = result;
60610   return jresult;
60611 }
60612
60613
60614 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
60615   float jresult ;
60616   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60617   float arg2 ;
60618   SwigDirector_ViewImpl *darg = 0;
60619   float result;
60620
60621   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60622   arg2 = (float)jarg2;
60623   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60624   {
60625     try {
60626       result = (float)(darg)->GetHeightForWidth(arg2);
60627     } catch (std::out_of_range& e) {
60628       {
60629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60630       };
60631     } catch (std::exception& e) {
60632       {
60633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60634       };
60635     } catch (...) {
60636       {
60637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60638       };
60639     }
60640   }
60641   jresult = result;
60642   return jresult;
60643 }
60644
60645
60646 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
60647   float jresult ;
60648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60649   float arg2 ;
60650   SwigDirector_ViewImpl *darg = 0;
60651   float result;
60652
60653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60654   arg2 = (float)jarg2;
60655   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60656   {
60657     try {
60658       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
60659     } catch (std::out_of_range& e) {
60660       {
60661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60662       };
60663     } catch (std::exception& e) {
60664       {
60665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60666       };
60667     } catch (...) {
60668       {
60669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60670       };
60671     }
60672   }
60673   jresult = result;
60674   return jresult;
60675 }
60676
60677
60678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
60679   float jresult ;
60680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60681   float arg2 ;
60682   SwigDirector_ViewImpl *darg = 0;
60683   float result;
60684
60685   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60686   arg2 = (float)jarg2;
60687   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60688   {
60689     try {
60690       result = (float)(darg)->GetWidthForHeight(arg2);
60691     } catch (std::out_of_range& e) {
60692       {
60693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60694       };
60695     } catch (std::exception& e) {
60696       {
60697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60698       };
60699     } catch (...) {
60700       {
60701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60702       };
60703     }
60704   }
60705   jresult = result;
60706   return jresult;
60707 }
60708
60709
60710 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
60711   float jresult ;
60712   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60713   float arg2 ;
60714   SwigDirector_ViewImpl *darg = 0;
60715   float result;
60716
60717   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60718   arg2 = (float)jarg2;
60719   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60720   {
60721     try {
60722       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
60723     } catch (std::out_of_range& e) {
60724       {
60725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60726       };
60727     } catch (std::exception& e) {
60728       {
60729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60730       };
60731     } catch (...) {
60732       {
60733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60734       };
60735     }
60736   }
60737   jresult = result;
60738   return jresult;
60739 }
60740
60741
60742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
60743   unsigned int jresult ;
60744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60745   Dali::Dimension::Type arg2 ;
60746   SwigDirector_ViewImpl *darg = 0;
60747   bool result;
60748
60749   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60750   arg2 = (Dali::Dimension::Type)jarg2;
60751   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60752   {
60753     try {
60754       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
60755     } catch (std::out_of_range& e) {
60756       {
60757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60758       };
60759     } catch (std::exception& e) {
60760       {
60761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60762       };
60763     } catch (...) {
60764       {
60765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60766       };
60767     }
60768   }
60769   jresult = result;
60770   return jresult;
60771 }
60772
60773
60774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
60775   unsigned int jresult ;
60776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60777   Dali::Dimension::Type arg2 ;
60778   SwigDirector_ViewImpl *darg = 0;
60779   bool result;
60780
60781   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60782   arg2 = (Dali::Dimension::Type)jarg2;
60783   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60784   {
60785     try {
60786       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
60787     } catch (std::out_of_range& e) {
60788       {
60789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60790       };
60791     } catch (std::exception& e) {
60792       {
60793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60794       };
60795     } catch (...) {
60796       {
60797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60798       };
60799     }
60800   }
60801   jresult = result;
60802   return jresult;
60803 }
60804
60805
60806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
60807   unsigned int jresult ;
60808   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60809   SwigDirector_ViewImpl *darg = 0;
60810   bool result;
60811
60812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60813   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60814   {
60815     try {
60816       result = (bool)(darg)->RelayoutDependentOnChildren();
60817     } catch (std::out_of_range& e) {
60818       {
60819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60820       };
60821     } catch (std::exception& e) {
60822       {
60823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60824       };
60825     } catch (...) {
60826       {
60827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60828       };
60829     }
60830   }
60831   jresult = result;
60832   return jresult;
60833 }
60834
60835
60836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
60837   unsigned int jresult ;
60838   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60839   SwigDirector_ViewImpl *darg = 0;
60840   bool result;
60841
60842   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60843   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60844   {
60845     try {
60846       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
60847     } catch (std::out_of_range& e) {
60848       {
60849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60850       };
60851     } catch (std::exception& e) {
60852       {
60853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60854       };
60855     } catch (...) {
60856       {
60857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60858       };
60859     }
60860   }
60861   jresult = result;
60862   return jresult;
60863 }
60864
60865
60866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
60867   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60868   Dali::Dimension::Type arg2 ;
60869   SwigDirector_ViewImpl *darg = 0;
60870
60871   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60872   arg2 = (Dali::Dimension::Type)jarg2;
60873   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60874   {
60875     try {
60876       (darg)->OnCalculateRelayoutSize(arg2);
60877     } catch (std::out_of_range& e) {
60878       {
60879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60880       };
60881     } catch (std::exception& e) {
60882       {
60883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60884       };
60885     } catch (...) {
60886       {
60887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60888       };
60889     }
60890   }
60891 }
60892
60893
60894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
60895   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60896   Dali::Dimension::Type arg2 ;
60897   SwigDirector_ViewImpl *darg = 0;
60898
60899   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60900   arg2 = (Dali::Dimension::Type)jarg2;
60901   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60902   {
60903     try {
60904       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
60905     } catch (std::out_of_range& e) {
60906       {
60907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60908       };
60909     } catch (std::exception& e) {
60910       {
60911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60912       };
60913     } catch (...) {
60914       {
60915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60916       };
60917     }
60918   }
60919 }
60920
60921
60922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
60923   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60924   float arg2 ;
60925   Dali::Dimension::Type arg3 ;
60926   SwigDirector_ViewImpl *darg = 0;
60927
60928   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60929   arg2 = (float)jarg2;
60930   arg3 = (Dali::Dimension::Type)jarg3;
60931   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60932   {
60933     try {
60934       (darg)->OnLayoutNegotiated(arg2,arg3);
60935     } catch (std::out_of_range& e) {
60936       {
60937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60938       };
60939     } catch (std::exception& e) {
60940       {
60941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60942       };
60943     } catch (...) {
60944       {
60945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60946       };
60947     }
60948   }
60949 }
60950
60951
60952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
60953   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60954   float arg2 ;
60955   Dali::Dimension::Type arg3 ;
60956   SwigDirector_ViewImpl *darg = 0;
60957
60958   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60959   arg2 = (float)jarg2;
60960   arg3 = (Dali::Dimension::Type)jarg3;
60961   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60962   {
60963     try {
60964       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
60965     } catch (std::out_of_range& e) {
60966       {
60967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60968       };
60969     } catch (std::exception& e) {
60970       {
60971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60972       };
60973     } catch (...) {
60974       {
60975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60976       };
60977     }
60978   }
60979 }
60980
60981
60982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
60983   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60984
60985   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60986   {
60987     try {
60988       (arg1)->OnInitialize();
60989     } catch (std::out_of_range& e) {
60990       {
60991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60992       };
60993     } catch (std::exception& e) {
60994       {
60995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60996       };
60997     } catch (...) {
60998       {
60999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61000       };
61001     }
61002   }
61003 }
61004
61005
61006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61007   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61008
61009   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61010   {
61011     try {
61012       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61013     } catch (std::out_of_range& e) {
61014       {
61015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61016       };
61017     } catch (std::exception& e) {
61018       {
61019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61020       };
61021     } catch (...) {
61022       {
61023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61024       };
61025     }
61026   }
61027 }
61028
61029
61030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
61031   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61032   Dali::Actor *arg2 = 0 ;
61033
61034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61035   arg2 = (Dali::Actor *)jarg2;
61036   if (!arg2) {
61037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61038     return ;
61039   }
61040   {
61041     try {
61042       (arg1)->OnControlChildAdd(*arg2);
61043     } catch (std::out_of_range& e) {
61044       {
61045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61046       };
61047     } catch (std::exception& e) {
61048       {
61049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61050       };
61051     } catch (...) {
61052       {
61053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61054       };
61055     }
61056   }
61057 }
61058
61059
61060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61061   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61062   Dali::Actor *arg2 = 0 ;
61063
61064   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61065   arg2 = (Dali::Actor *)jarg2;
61066   if (!arg2) {
61067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61068     return ;
61069   }
61070   {
61071     try {
61072       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
61073     } catch (std::out_of_range& e) {
61074       {
61075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61076       };
61077     } catch (std::exception& e) {
61078       {
61079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61080       };
61081     } catch (...) {
61082       {
61083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61084       };
61085     }
61086   }
61087 }
61088
61089
61090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
61091   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61092   Dali::Actor *arg2 = 0 ;
61093
61094   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61095   arg2 = (Dali::Actor *)jarg2;
61096   if (!arg2) {
61097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61098     return ;
61099   }
61100   {
61101     try {
61102       (arg1)->OnControlChildRemove(*arg2);
61103     } catch (std::out_of_range& e) {
61104       {
61105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61106       };
61107     } catch (std::exception& e) {
61108       {
61109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61110       };
61111     } catch (...) {
61112       {
61113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61114       };
61115     }
61116   }
61117 }
61118
61119
61120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61121   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61122   Dali::Actor *arg2 = 0 ;
61123
61124   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61125   arg2 = (Dali::Actor *)jarg2;
61126   if (!arg2) {
61127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61128     return ;
61129   }
61130   {
61131     try {
61132       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
61133     } catch (std::out_of_range& e) {
61134       {
61135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61136       };
61137     } catch (std::exception& e) {
61138       {
61139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61140       };
61141     } catch (...) {
61142       {
61143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61144       };
61145     }
61146   }
61147 }
61148
61149
61150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61152   Dali::Toolkit::StyleManager arg2 ;
61153   Dali::StyleChange::Type arg3 ;
61154   Dali::Toolkit::StyleManager *argp2 ;
61155
61156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61157   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61158   if (!argp2) {
61159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61160     return ;
61161   }
61162   arg2 = *argp2;
61163   arg3 = (Dali::StyleChange::Type)jarg3;
61164   {
61165     try {
61166       (arg1)->OnStyleChange(arg2,arg3);
61167     } catch (std::out_of_range& e) {
61168       {
61169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61170       };
61171     } catch (std::exception& e) {
61172       {
61173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61174       };
61175     } catch (...) {
61176       {
61177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61178       };
61179     }
61180   }
61181 }
61182
61183
61184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61185   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61186   Dali::Toolkit::StyleManager arg2 ;
61187   Dali::StyleChange::Type arg3 ;
61188   Dali::Toolkit::StyleManager *argp2 ;
61189
61190   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61191   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61192   if (!argp2) {
61193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61194     return ;
61195   }
61196   arg2 = *argp2;
61197   arg3 = (Dali::StyleChange::Type)jarg3;
61198   {
61199     try {
61200       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61201     } catch (std::out_of_range& e) {
61202       {
61203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61204       };
61205     } catch (std::exception& e) {
61206       {
61207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61208       };
61209     } catch (...) {
61210       {
61211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61212       };
61213     }
61214   }
61215 }
61216
61217
61218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61219   unsigned int jresult ;
61220   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61221   bool result;
61222
61223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61224   {
61225     try {
61226       result = (bool)(arg1)->OnAccessibilityActivated();
61227     } catch (std::out_of_range& e) {
61228       {
61229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61230       };
61231     } catch (std::exception& e) {
61232       {
61233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61234       };
61235     } catch (...) {
61236       {
61237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61238       };
61239     }
61240   }
61241   jresult = result;
61242   return jresult;
61243 }
61244
61245
61246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61247   unsigned int jresult ;
61248   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61249   bool result;
61250
61251   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61252   {
61253     try {
61254       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61255     } catch (std::out_of_range& e) {
61256       {
61257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61258       };
61259     } catch (std::exception& e) {
61260       {
61261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61262       };
61263     } catch (...) {
61264       {
61265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61266       };
61267     }
61268   }
61269   jresult = result;
61270   return jresult;
61271 }
61272
61273
61274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61275   unsigned int jresult ;
61276   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61277   Dali::PanGesture arg2 ;
61278   Dali::PanGesture *argp2 ;
61279   bool result;
61280
61281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61282   argp2 = (Dali::PanGesture *)jarg2;
61283   if (!argp2) {
61284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61285     return 0;
61286   }
61287   arg2 = *argp2;
61288   {
61289     try {
61290       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61291     } catch (std::out_of_range& e) {
61292       {
61293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61294       };
61295     } catch (std::exception& e) {
61296       {
61297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61298       };
61299     } catch (...) {
61300       {
61301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61302       };
61303     }
61304   }
61305   jresult = result;
61306   return jresult;
61307 }
61308
61309
61310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61311   unsigned int jresult ;
61312   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61313   Dali::PanGesture arg2 ;
61314   Dali::PanGesture *argp2 ;
61315   bool result;
61316
61317   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61318   argp2 = (Dali::PanGesture *)jarg2;
61319   if (!argp2) {
61320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61321     return 0;
61322   }
61323   arg2 = *argp2;
61324   {
61325     try {
61326       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61327     } catch (std::out_of_range& e) {
61328       {
61329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61330       };
61331     } catch (std::exception& e) {
61332       {
61333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61334       };
61335     } catch (...) {
61336       {
61337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61338       };
61339     }
61340   }
61341   jresult = result;
61342   return jresult;
61343 }
61344
61345
61346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
61347   unsigned int jresult ;
61348   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61349   Dali::TouchEvent *arg2 = 0 ;
61350   bool result;
61351
61352   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61353   arg2 = (Dali::TouchEvent *)jarg2;
61354   if (!arg2) {
61355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61356     return 0;
61357   }
61358   {
61359     try {
61360       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61361     } catch (std::out_of_range& e) {
61362       {
61363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61364       };
61365     } catch (std::exception& e) {
61366       {
61367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61368       };
61369     } catch (...) {
61370       {
61371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61372       };
61373     }
61374   }
61375   jresult = result;
61376   return jresult;
61377 }
61378
61379
61380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61381   unsigned int jresult ;
61382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61383   Dali::TouchEvent *arg2 = 0 ;
61384   bool result;
61385
61386   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61387   arg2 = (Dali::TouchEvent *)jarg2;
61388   if (!arg2) {
61389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61390     return 0;
61391   }
61392   {
61393     try {
61394       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61395     } catch (std::out_of_range& e) {
61396       {
61397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61398       };
61399     } catch (std::exception& e) {
61400       {
61401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61402       };
61403     } catch (...) {
61404       {
61405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61406       };
61407     }
61408   }
61409   jresult = result;
61410   return jresult;
61411 }
61412
61413
61414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61415   unsigned int jresult ;
61416   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61417   bool arg2 ;
61418   bool result;
61419
61420   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61421   arg2 = jarg2 ? true : false;
61422   {
61423     try {
61424       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61425     } catch (std::out_of_range& e) {
61426       {
61427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61428       };
61429     } catch (std::exception& e) {
61430       {
61431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61432       };
61433     } catch (...) {
61434       {
61435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61436       };
61437     }
61438   }
61439   jresult = result;
61440   return jresult;
61441 }
61442
61443
61444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61445   unsigned int jresult ;
61446   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61447   bool arg2 ;
61448   bool result;
61449
61450   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61451   arg2 = jarg2 ? true : false;
61452   {
61453     try {
61454       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61455     } catch (std::out_of_range& e) {
61456       {
61457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61458       };
61459     } catch (std::exception& e) {
61460       {
61461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61462       };
61463     } catch (...) {
61464       {
61465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61466       };
61467     }
61468   }
61469   jresult = result;
61470   return jresult;
61471 }
61472
61473
61474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61475   unsigned int jresult ;
61476   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61477   bool result;
61478
61479   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61480   {
61481     try {
61482       result = (bool)(arg1)->OnAccessibilityZoom();
61483     } catch (std::out_of_range& e) {
61484       {
61485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61486       };
61487     } catch (std::exception& e) {
61488       {
61489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61490       };
61491     } catch (...) {
61492       {
61493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61494       };
61495     }
61496   }
61497   jresult = result;
61498   return jresult;
61499 }
61500
61501
61502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61503   unsigned int jresult ;
61504   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61505   bool result;
61506
61507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61508   {
61509     try {
61510       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61511     } catch (std::out_of_range& e) {
61512       {
61513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61514       };
61515     } catch (std::exception& e) {
61516       {
61517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61518       };
61519     } catch (...) {
61520       {
61521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61522       };
61523     }
61524   }
61525   jresult = result;
61526   return jresult;
61527 }
61528
61529
61530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61531   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61532
61533   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61534   {
61535     try {
61536       (arg1)->OnKeyInputFocusGained();
61537     } catch (std::out_of_range& e) {
61538       {
61539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61540       };
61541     } catch (std::exception& e) {
61542       {
61543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61544       };
61545     } catch (...) {
61546       {
61547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61548       };
61549     }
61550   }
61551 }
61552
61553
61554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
61555   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61556
61557   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61558   {
61559     try {
61560       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
61561     } catch (std::out_of_range& e) {
61562       {
61563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61564       };
61565     } catch (std::exception& e) {
61566       {
61567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61568       };
61569     } catch (...) {
61570       {
61571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61572       };
61573     }
61574   }
61575 }
61576
61577
61578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
61579   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61580
61581   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61582   {
61583     try {
61584       (arg1)->OnKeyInputFocusLost();
61585     } catch (std::out_of_range& e) {
61586       {
61587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61588       };
61589     } catch (std::exception& e) {
61590       {
61591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61592       };
61593     } catch (...) {
61594       {
61595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61596       };
61597     }
61598   }
61599 }
61600
61601
61602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
61603   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61604
61605   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61606   {
61607     try {
61608       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
61609     } catch (std::out_of_range& e) {
61610       {
61611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61612       };
61613     } catch (std::exception& e) {
61614       {
61615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61616       };
61617     } catch (...) {
61618       {
61619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61620       };
61621     }
61622   }
61623 }
61624
61625
61626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61627   void * jresult ;
61628   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61629   Dali::Actor arg2 ;
61630   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61631   bool arg4 ;
61632   Dali::Actor *argp2 ;
61633   Dali::Actor result;
61634
61635   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61636   argp2 = (Dali::Actor *)jarg2;
61637   if (!argp2) {
61638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61639     return 0;
61640   }
61641   arg2 = *argp2;
61642   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61643   arg4 = jarg4 ? true : false;
61644   {
61645     try {
61646       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61647     } catch (std::out_of_range& e) {
61648       {
61649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61650       };
61651     } catch (std::exception& e) {
61652       {
61653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61654       };
61655     } catch (...) {
61656       {
61657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61658       };
61659     }
61660   }
61661   jresult = new Dali::Actor((const Dali::Actor &)result);
61662   return jresult;
61663 }
61664
61665
61666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61667   void * jresult ;
61668   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61669   Dali::Actor arg2 ;
61670   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61671   bool arg4 ;
61672   Dali::Actor *argp2 ;
61673   Dali::Actor result;
61674
61675   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61676   argp2 = (Dali::Actor *)jarg2;
61677   if (!argp2) {
61678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61679     return 0;
61680   }
61681   arg2 = *argp2;
61682   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61683   arg4 = jarg4 ? true : false;
61684   {
61685     try {
61686       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61687     } catch (std::out_of_range& e) {
61688       {
61689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61690       };
61691     } catch (std::exception& e) {
61692       {
61693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61694       };
61695     } catch (...) {
61696       {
61697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61698       };
61699     }
61700   }
61701   jresult = new Dali::Actor((const Dali::Actor &)result);
61702   return jresult;
61703 }
61704
61705
61706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
61707   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61708   Dali::Actor arg2 ;
61709   Dali::Actor *argp2 ;
61710
61711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61712   argp2 = (Dali::Actor *)jarg2;
61713   if (!argp2) {
61714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61715     return ;
61716   }
61717   arg2 = *argp2;
61718   {
61719     try {
61720       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
61721     } catch (std::out_of_range& e) {
61722       {
61723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61724       };
61725     } catch (std::exception& e) {
61726       {
61727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61728       };
61729     } catch (...) {
61730       {
61731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61732       };
61733     }
61734   }
61735 }
61736
61737
61738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61739   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61740   Dali::Actor arg2 ;
61741   Dali::Actor *argp2 ;
61742
61743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61744   argp2 = (Dali::Actor *)jarg2;
61745   if (!argp2) {
61746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61747     return ;
61748   }
61749   arg2 = *argp2;
61750   {
61751     try {
61752       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
61753     } catch (std::out_of_range& e) {
61754       {
61755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61756       };
61757     } catch (std::exception& e) {
61758       {
61759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61760       };
61761     } catch (...) {
61762       {
61763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61764       };
61765     }
61766   }
61767 }
61768
61769
61770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
61771   unsigned int jresult ;
61772   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61773   bool result;
61774
61775   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61776   {
61777     try {
61778       result = (bool)(arg1)->OnKeyboardEnter();
61779     } catch (std::out_of_range& e) {
61780       {
61781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61782       };
61783     } catch (std::exception& e) {
61784       {
61785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61786       };
61787     } catch (...) {
61788       {
61789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61790       };
61791     }
61792   }
61793   jresult = result;
61794   return jresult;
61795 }
61796
61797
61798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
61799   unsigned int jresult ;
61800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61801   bool result;
61802
61803   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61804   {
61805     try {
61806       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
61807     } catch (std::out_of_range& e) {
61808       {
61809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61810       };
61811     } catch (std::exception& e) {
61812       {
61813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61814       };
61815     } catch (...) {
61816       {
61817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61818       };
61819     }
61820   }
61821   jresult = result;
61822   return jresult;
61823 }
61824
61825
61826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
61827   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61828   Dali::PinchGesture *arg2 = 0 ;
61829
61830   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61831   arg2 = (Dali::PinchGesture *)jarg2;
61832   if (!arg2) {
61833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61834     return ;
61835   }
61836   {
61837     try {
61838       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
61839     } catch (std::out_of_range& e) {
61840       {
61841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61842       };
61843     } catch (std::exception& e) {
61844       {
61845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61846       };
61847     } catch (...) {
61848       {
61849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61850       };
61851     }
61852   }
61853 }
61854
61855
61856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61857   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61858   Dali::PinchGesture *arg2 = 0 ;
61859
61860   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61861   arg2 = (Dali::PinchGesture *)jarg2;
61862   if (!arg2) {
61863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61864     return ;
61865   }
61866   {
61867     try {
61868       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
61869     } catch (std::out_of_range& e) {
61870       {
61871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61872       };
61873     } catch (std::exception& e) {
61874       {
61875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61876       };
61877     } catch (...) {
61878       {
61879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61880       };
61881     }
61882   }
61883 }
61884
61885
61886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
61887   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61888   Dali::PanGesture *arg2 = 0 ;
61889
61890   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61891   arg2 = (Dali::PanGesture *)jarg2;
61892   if (!arg2) {
61893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61894     return ;
61895   }
61896   {
61897     try {
61898       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
61899     } catch (std::out_of_range& e) {
61900       {
61901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61902       };
61903     } catch (std::exception& e) {
61904       {
61905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61906       };
61907     } catch (...) {
61908       {
61909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61910       };
61911     }
61912   }
61913 }
61914
61915
61916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61917   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61918   Dali::PanGesture *arg2 = 0 ;
61919
61920   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61921   arg2 = (Dali::PanGesture *)jarg2;
61922   if (!arg2) {
61923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61924     return ;
61925   }
61926   {
61927     try {
61928       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
61929     } catch (std::out_of_range& e) {
61930       {
61931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61932       };
61933     } catch (std::exception& e) {
61934       {
61935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61936       };
61937     } catch (...) {
61938       {
61939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61940       };
61941     }
61942   }
61943 }
61944
61945
61946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
61947   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61948   Dali::TapGesture *arg2 = 0 ;
61949
61950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61951   arg2 = (Dali::TapGesture *)jarg2;
61952   if (!arg2) {
61953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
61954     return ;
61955   }
61956   {
61957     try {
61958       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
61959     } catch (std::out_of_range& e) {
61960       {
61961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61962       };
61963     } catch (std::exception& e) {
61964       {
61965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61966       };
61967     } catch (...) {
61968       {
61969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61970       };
61971     }
61972   }
61973 }
61974
61975
61976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61977   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61978   Dali::TapGesture *arg2 = 0 ;
61979
61980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61981   arg2 = (Dali::TapGesture *)jarg2;
61982   if (!arg2) {
61983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
61984     return ;
61985   }
61986   {
61987     try {
61988       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
61989     } catch (std::out_of_range& e) {
61990       {
61991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61992       };
61993     } catch (std::exception& e) {
61994       {
61995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61996       };
61997     } catch (...) {
61998       {
61999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62000       };
62001     }
62002   }
62003 }
62004
62005
62006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62007   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62008   Dali::LongPressGesture *arg2 = 0 ;
62009
62010   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62011   arg2 = (Dali::LongPressGesture *)jarg2;
62012   if (!arg2) {
62013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62014     return ;
62015   }
62016   {
62017     try {
62018       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62019     } catch (std::out_of_range& e) {
62020       {
62021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62022       };
62023     } catch (std::exception& e) {
62024       {
62025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62026       };
62027     } catch (...) {
62028       {
62029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62030       };
62031     }
62032   }
62033 }
62034
62035
62036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62037   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62038   Dali::LongPressGesture *arg2 = 0 ;
62039
62040   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62041   arg2 = (Dali::LongPressGesture *)jarg2;
62042   if (!arg2) {
62043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62044     return ;
62045   }
62046   {
62047     try {
62048       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62049     } catch (std::out_of_range& e) {
62050       {
62051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62052       };
62053     } catch (std::exception& e) {
62054       {
62055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62056       };
62057     } catch (...) {
62058       {
62059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62060       };
62061     }
62062   }
62063 }
62064
62065
62066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62068   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62069   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62070
62071   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62072   arg2 = (Dali::SlotObserver *)jarg2;
62073   arg3 = (Dali::CallbackBase *)jarg3;
62074   {
62075     try {
62076       (arg1)->SignalConnected(arg2,arg3);
62077     } catch (std::out_of_range& e) {
62078       {
62079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62080       };
62081     } catch (std::exception& e) {
62082       {
62083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62084       };
62085     } catch (...) {
62086       {
62087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62088       };
62089     }
62090   }
62091 }
62092
62093
62094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62095   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62096   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62097   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62098
62099   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62100   arg2 = (Dali::SlotObserver *)jarg2;
62101   arg3 = (Dali::CallbackBase *)jarg3;
62102   {
62103     try {
62104       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62105     } catch (std::out_of_range& e) {
62106       {
62107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62108       };
62109     } catch (std::exception& e) {
62110       {
62111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62112       };
62113     } catch (...) {
62114       {
62115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62116       };
62117     }
62118   }
62119 }
62120
62121
62122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62123   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62124   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62125   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62126
62127   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62128   arg2 = (Dali::SlotObserver *)jarg2;
62129   arg3 = (Dali::CallbackBase *)jarg3;
62130   {
62131     try {
62132       (arg1)->SignalDisconnected(arg2,arg3);
62133     } catch (std::out_of_range& e) {
62134       {
62135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62136       };
62137     } catch (std::exception& e) {
62138       {
62139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62140       };
62141     } catch (...) {
62142       {
62143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62144       };
62145     }
62146   }
62147 }
62148
62149
62150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62151   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62152   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62153   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62154
62155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62156   arg2 = (Dali::SlotObserver *)jarg2;
62157   arg3 = (Dali::CallbackBase *)jarg3;
62158   {
62159     try {
62160       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62161     } catch (std::out_of_range& e) {
62162       {
62163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62164       };
62165     } catch (std::exception& e) {
62166       {
62167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62168       };
62169     } catch (...) {
62170       {
62171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62172       };
62173     }
62174   }
62175 }
62176
62177
62178 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) {
62179   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62180   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62181   if (director) {
62182     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);
62183   }
62184 }
62185
62186
62187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62188   void * jresult ;
62189   Dali::Toolkit::Control *arg1 = 0 ;
62190   Dali::Toolkit::Internal::Control *result = 0 ;
62191
62192   arg1 = (Dali::Toolkit::Control *)jarg1;
62193   if (!arg1) {
62194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62195     return 0;
62196   }
62197   {
62198     try {
62199       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62200     } catch (std::out_of_range& e) {
62201       {
62202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62203       };
62204     } catch (std::exception& e) {
62205       {
62206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62207       };
62208     } catch (...) {
62209       {
62210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62211       };
62212     }
62213   }
62214   jresult = (void *)result;
62215   return jresult;
62216 }
62217
62218
62219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62220   int jresult ;
62221   int result;
62222
62223   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62224   jresult = (int)result;
62225   return jresult;
62226 }
62227
62228
62229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
62230   int jresult ;
62231   int result;
62232
62233   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
62234   jresult = (int)result;
62235   return jresult;
62236 }
62237
62238
62239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
62240   int jresult ;
62241   int result;
62242
62243   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
62244   jresult = (int)result;
62245   return jresult;
62246 }
62247
62248
62249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62250   int jresult ;
62251   int result;
62252
62253   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62254   jresult = (int)result;
62255   return jresult;
62256 }
62257
62258
62259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62260   int jresult ;
62261   int result;
62262
62263   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62264   jresult = (int)result;
62265   return jresult;
62266 }
62267
62268
62269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62270   void * jresult ;
62271   Dali::Toolkit::Control::Property *result = 0 ;
62272
62273   {
62274     try {
62275       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62276     } catch (std::out_of_range& e) {
62277       {
62278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62279       };
62280     } catch (std::exception& e) {
62281       {
62282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62283       };
62284     } catch (...) {
62285       {
62286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62287       };
62288     }
62289   }
62290   jresult = (void *)result;
62291   return jresult;
62292 }
62293
62294
62295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62296   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62297
62298   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62299   {
62300     try {
62301       delete arg1;
62302     } catch (std::out_of_range& e) {
62303       {
62304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62305       };
62306     } catch (std::exception& e) {
62307       {
62308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62309       };
62310     } catch (...) {
62311       {
62312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62313       };
62314     }
62315   }
62316 }
62317
62318
62319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62320   void * jresult ;
62321   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62322
62323   {
62324     try {
62325       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62326     } catch (std::out_of_range& e) {
62327       {
62328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62329       };
62330     } catch (std::exception& e) {
62331       {
62332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62333       };
62334     } catch (...) {
62335       {
62336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62337       };
62338     }
62339   }
62340   jresult = (void *)result;
62341   return jresult;
62342 }
62343
62344
62345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62346   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62347
62348   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62349   {
62350     try {
62351       delete arg1;
62352     } catch (std::out_of_range& e) {
62353       {
62354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62355       };
62356     } catch (std::exception& e) {
62357       {
62358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62359       };
62360     } catch (...) {
62361       {
62362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62363       };
62364     }
62365   }
62366 }
62367
62368
62369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62370   void * jresult ;
62371   Dali::Toolkit::Control result;
62372
62373   {
62374     try {
62375       result = Dali::Toolkit::Control::New();
62376     } catch (std::out_of_range& e) {
62377       {
62378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62379       };
62380     } catch (std::exception& e) {
62381       {
62382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62383       };
62384     } catch (...) {
62385       {
62386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62387       };
62388     }
62389   }
62390   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62391   return jresult;
62392 }
62393
62394
62395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
62396   void * jresult ;
62397   Dali::Toolkit::Control *result = 0 ;
62398
62399   {
62400     try {
62401       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
62402     } catch (std::out_of_range& e) {
62403       {
62404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62405       };
62406     } catch (std::exception& e) {
62407       {
62408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62409       };
62410     } catch (...) {
62411       {
62412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62413       };
62414     }
62415   }
62416   jresult = (void *)result;
62417   return jresult;
62418 }
62419
62420
62421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
62422   void * jresult ;
62423   Dali::Toolkit::Control *arg1 = 0 ;
62424   Dali::Toolkit::Control *result = 0 ;
62425
62426   arg1 = (Dali::Toolkit::Control *)jarg1;
62427   if (!arg1) {
62428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62429     return 0;
62430   }
62431   {
62432     try {
62433       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
62434     } catch (std::out_of_range& e) {
62435       {
62436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62437       };
62438     } catch (std::exception& e) {
62439       {
62440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62441       };
62442     } catch (...) {
62443       {
62444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62445       };
62446     }
62447   }
62448   jresult = (void *)result;
62449   return jresult;
62450 }
62451
62452
62453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
62454   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62455
62456   arg1 = (Dali::Toolkit::Control *)jarg1;
62457   {
62458     try {
62459       delete arg1;
62460     } catch (std::out_of_range& e) {
62461       {
62462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62463       };
62464     } catch (std::exception& e) {
62465       {
62466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62467       };
62468     } catch (...) {
62469       {
62470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62471       };
62472     }
62473   }
62474 }
62475
62476
62477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
62478   void * jresult ;
62479   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62480   Dali::Toolkit::Control *arg2 = 0 ;
62481   Dali::Toolkit::Control *result = 0 ;
62482
62483   arg1 = (Dali::Toolkit::Control *)jarg1;
62484   arg2 = (Dali::Toolkit::Control *)jarg2;
62485   if (!arg2) {
62486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62487     return 0;
62488   }
62489   {
62490     try {
62491       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
62492     } catch (std::out_of_range& e) {
62493       {
62494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62495       };
62496     } catch (std::exception& e) {
62497       {
62498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62499       };
62500     } catch (...) {
62501       {
62502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62503       };
62504     }
62505   }
62506   jresult = (void *)result;
62507   return jresult;
62508 }
62509
62510
62511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
62512   void * jresult ;
62513   Dali::BaseHandle arg1 ;
62514   Dali::BaseHandle *argp1 ;
62515   Dali::Toolkit::Control result;
62516
62517   argp1 = (Dali::BaseHandle *)jarg1;
62518   if (!argp1) {
62519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62520     return 0;
62521   }
62522   arg1 = *argp1;
62523   {
62524     try {
62525       result = Dali::Toolkit::Control::DownCast(arg1);
62526     } catch (std::out_of_range& e) {
62527       {
62528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62529       };
62530     } catch (std::exception& e) {
62531       {
62532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62533       };
62534     } catch (...) {
62535       {
62536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62537       };
62538     }
62539   }
62540   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62541   return jresult;
62542 }
62543
62544
62545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
62546   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62547
62548   arg1 = (Dali::Toolkit::Control *)jarg1;
62549   {
62550     try {
62551       (arg1)->SetKeyInputFocus();
62552     } catch (std::out_of_range& e) {
62553       {
62554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62555       };
62556     } catch (std::exception& e) {
62557       {
62558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62559       };
62560     } catch (...) {
62561       {
62562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62563       };
62564     }
62565   }
62566 }
62567
62568
62569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
62570   unsigned int jresult ;
62571   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62572   bool result;
62573
62574   arg1 = (Dali::Toolkit::Control *)jarg1;
62575   {
62576     try {
62577       result = (bool)(arg1)->HasKeyInputFocus();
62578     } catch (std::out_of_range& e) {
62579       {
62580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62581       };
62582     } catch (std::exception& e) {
62583       {
62584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62585       };
62586     } catch (...) {
62587       {
62588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62589       };
62590     }
62591   }
62592   jresult = result;
62593   return jresult;
62594 }
62595
62596
62597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
62598   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62599
62600   arg1 = (Dali::Toolkit::Control *)jarg1;
62601   {
62602     try {
62603       (arg1)->ClearKeyInputFocus();
62604     } catch (std::out_of_range& e) {
62605       {
62606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62607       };
62608     } catch (std::exception& e) {
62609       {
62610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62611       };
62612     } catch (...) {
62613       {
62614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62615       };
62616     }
62617   }
62618 }
62619
62620
62621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
62622   void * jresult ;
62623   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62624   Dali::PinchGestureDetector result;
62625
62626   arg1 = (Dali::Toolkit::Control *)jarg1;
62627   {
62628     try {
62629       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
62630     } catch (std::out_of_range& e) {
62631       {
62632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62633       };
62634     } catch (std::exception& e) {
62635       {
62636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62637       };
62638     } catch (...) {
62639       {
62640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62641       };
62642     }
62643   }
62644   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
62645   return jresult;
62646 }
62647
62648
62649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
62650   void * jresult ;
62651   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62652   Dali::PanGestureDetector result;
62653
62654   arg1 = (Dali::Toolkit::Control *)jarg1;
62655   {
62656     try {
62657       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
62658     } catch (std::out_of_range& e) {
62659       {
62660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62661       };
62662     } catch (std::exception& e) {
62663       {
62664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62665       };
62666     } catch (...) {
62667       {
62668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62669       };
62670     }
62671   }
62672   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
62673   return jresult;
62674 }
62675
62676
62677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
62678   void * jresult ;
62679   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62680   Dali::TapGestureDetector result;
62681
62682   arg1 = (Dali::Toolkit::Control *)jarg1;
62683   {
62684     try {
62685       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
62686     } catch (std::out_of_range& e) {
62687       {
62688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62689       };
62690     } catch (std::exception& e) {
62691       {
62692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62693       };
62694     } catch (...) {
62695       {
62696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62697       };
62698     }
62699   }
62700   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
62701   return jresult;
62702 }
62703
62704
62705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
62706   void * jresult ;
62707   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62708   Dali::LongPressGestureDetector result;
62709
62710   arg1 = (Dali::Toolkit::Control *)jarg1;
62711   {
62712     try {
62713       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
62714     } catch (std::out_of_range& e) {
62715       {
62716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62717       };
62718     } catch (std::exception& e) {
62719       {
62720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62721       };
62722     } catch (...) {
62723       {
62724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62725       };
62726     }
62727   }
62728   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
62729   return jresult;
62730 }
62731
62732
62733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
62734   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62735   std::string *arg2 = 0 ;
62736
62737   arg1 = (Dali::Toolkit::Control *)jarg1;
62738   if (!jarg2) {
62739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62740     return ;
62741   }
62742   std::string arg2_str(jarg2);
62743   arg2 = &arg2_str;
62744   {
62745     try {
62746       (arg1)->SetStyleName((std::string const &)*arg2);
62747     } catch (std::out_of_range& e) {
62748       {
62749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62750       };
62751     } catch (std::exception& e) {
62752       {
62753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62754       };
62755     } catch (...) {
62756       {
62757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62758       };
62759     }
62760   }
62761
62762   //argout typemap for const std::string&
62763
62764 }
62765
62766
62767 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
62768   char * jresult ;
62769   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62770   std::string *result = 0 ;
62771
62772   arg1 = (Dali::Toolkit::Control *)jarg1;
62773   {
62774     try {
62775       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
62776     } catch (std::out_of_range& e) {
62777       {
62778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62779       };
62780     } catch (std::exception& e) {
62781       {
62782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62783       };
62784     } catch (...) {
62785       {
62786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62787       };
62788     }
62789   }
62790   jresult = SWIG_csharp_string_callback(result->c_str());
62791   return jresult;
62792 }
62793
62794
62795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
62796   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62797   Dali::Vector4 *arg2 = 0 ;
62798
62799   arg1 = (Dali::Toolkit::Control *)jarg1;
62800   arg2 = (Dali::Vector4 *)jarg2;
62801   if (!arg2) {
62802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
62803     return ;
62804   }
62805   {
62806     try {
62807       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
62808     } catch (std::out_of_range& e) {
62809       {
62810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62811       };
62812     } catch (std::exception& e) {
62813       {
62814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62815       };
62816     } catch (...) {
62817       {
62818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62819       };
62820     }
62821   }
62822 }
62823
62824
62825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
62826   void * jresult ;
62827   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62828   Dali::Vector4 result;
62829
62830   arg1 = (Dali::Toolkit::Control *)jarg1;
62831   {
62832     try {
62833       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
62834     } catch (std::out_of_range& e) {
62835       {
62836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62837       };
62838     } catch (std::exception& e) {
62839       {
62840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62841       };
62842     } catch (...) {
62843       {
62844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62845       };
62846     }
62847   }
62848   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
62849   return jresult;
62850 }
62851
62852
62853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
62854   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62855   Dali::Image arg2 ;
62856   Dali::Image *argp2 ;
62857
62858   arg1 = (Dali::Toolkit::Control *)jarg1;
62859   argp2 = (Dali::Image *)jarg2;
62860   if (!argp2) {
62861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62862     return ;
62863   }
62864   arg2 = *argp2;
62865   {
62866     try {
62867       (arg1)->SetBackgroundImage(arg2);
62868     } catch (std::out_of_range& e) {
62869       {
62870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62871       };
62872     } catch (std::exception& e) {
62873       {
62874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62875       };
62876     } catch (...) {
62877       {
62878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62879       };
62880     }
62881   }
62882 }
62883
62884
62885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
62886   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62887
62888   arg1 = (Dali::Toolkit::Control *)jarg1;
62889   {
62890     try {
62891       (arg1)->ClearBackground();
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_View_KeyEventSignal(void * jarg1) {
62910   void * jresult ;
62911   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62912   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
62913
62914   arg1 = (Dali::Toolkit::Control *)jarg1;
62915   {
62916     try {
62917       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
62918     } catch (std::out_of_range& e) {
62919       {
62920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62921       };
62922     } catch (std::exception& e) {
62923       {
62924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62925       };
62926     } catch (...) {
62927       {
62928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62929       };
62930     }
62931   }
62932   jresult = (void *)result;
62933   return jresult;
62934 }
62935
62936
62937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
62938   void * jresult ;
62939   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62940   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62941
62942   arg1 = (Dali::Toolkit::Control *)jarg1;
62943   {
62944     try {
62945       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
62946     } catch (std::out_of_range& e) {
62947       {
62948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62949       };
62950     } catch (std::exception& e) {
62951       {
62952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62953       };
62954     } catch (...) {
62955       {
62956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62957       };
62958     }
62959   }
62960   jresult = (void *)result;
62961   return jresult;
62962 }
62963
62964
62965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
62966   void * jresult ;
62967   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62968   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62969
62970   arg1 = (Dali::Toolkit::Control *)jarg1;
62971   {
62972     try {
62973       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
62974     } catch (std::out_of_range& e) {
62975       {
62976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62977       };
62978     } catch (std::exception& e) {
62979       {
62980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62981       };
62982     } catch (...) {
62983       {
62984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62985       };
62986     }
62987   }
62988   jresult = (void *)result;
62989   return jresult;
62990 }
62991
62992
62993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
62994   void * jresult ;
62995   Dali::Toolkit::Internal::Control *arg1 = 0 ;
62996   Dali::Toolkit::Control *result = 0 ;
62997
62998   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62999   if (!arg1) {
63000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63001     return 0;
63002   }
63003   {
63004     try {
63005       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63006     } catch (std::out_of_range& e) {
63007       {
63008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63009       };
63010     } catch (std::exception& e) {
63011       {
63012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63013       };
63014     } catch (...) {
63015       {
63016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63017       };
63018     }
63019   }
63020   jresult = (void *)result;
63021   return jresult;
63022 }
63023
63024
63025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63026   void * jresult ;
63027   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63028
63029   {
63030     try {
63031       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63032     } catch (std::out_of_range& e) {
63033       {
63034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63035       };
63036     } catch (std::exception& e) {
63037       {
63038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63039       };
63040     } catch (...) {
63041       {
63042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63043       };
63044     }
63045   }
63046   jresult = (void *)result;
63047   return jresult;
63048 }
63049
63050
63051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63052   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63053
63054   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63055   {
63056     try {
63057       delete arg1;
63058     } catch (std::out_of_range& e) {
63059       {
63060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63061       };
63062     } catch (std::exception& e) {
63063       {
63064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63065       };
63066     } catch (...) {
63067       {
63068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63069       };
63070     }
63071   }
63072 }
63073
63074
63075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63076   void * jresult ;
63077   Dali::Toolkit::KeyInputFocusManager result;
63078
63079   {
63080     try {
63081       result = Dali::Toolkit::KeyInputFocusManager::Get();
63082     } catch (std::out_of_range& e) {
63083       {
63084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63085       };
63086     } catch (std::exception& e) {
63087       {
63088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63089       };
63090     } catch (...) {
63091       {
63092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63093       };
63094     }
63095   }
63096   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63097   return jresult;
63098 }
63099
63100
63101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63102   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63103   Dali::Toolkit::Control arg2 ;
63104   Dali::Toolkit::Control *argp2 ;
63105
63106   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63107   argp2 = (Dali::Toolkit::Control *)jarg2;
63108   if (!argp2) {
63109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63110     return ;
63111   }
63112   arg2 = *argp2;
63113   {
63114     try {
63115       (arg1)->SetFocus(arg2);
63116     } catch (std::out_of_range& e) {
63117       {
63118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63119       };
63120     } catch (std::exception& e) {
63121       {
63122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63123       };
63124     } catch (...) {
63125       {
63126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63127       };
63128     }
63129   }
63130 }
63131
63132
63133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63134   void * jresult ;
63135   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63136   Dali::Toolkit::Control result;
63137
63138   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63139   {
63140     try {
63141       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63142     } catch (std::out_of_range& e) {
63143       {
63144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63145       };
63146     } catch (std::exception& e) {
63147       {
63148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63149       };
63150     } catch (...) {
63151       {
63152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63153       };
63154     }
63155   }
63156   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63157   return jresult;
63158 }
63159
63160
63161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
63162   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63163   Dali::Toolkit::Control arg2 ;
63164   Dali::Toolkit::Control *argp2 ;
63165
63166   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63167   argp2 = (Dali::Toolkit::Control *)jarg2;
63168   if (!argp2) {
63169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63170     return ;
63171   }
63172   arg2 = *argp2;
63173   {
63174     try {
63175       (arg1)->RemoveFocus(arg2);
63176     } catch (std::out_of_range& e) {
63177       {
63178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63179       };
63180     } catch (std::exception& e) {
63181       {
63182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63183       };
63184     } catch (...) {
63185       {
63186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63187       };
63188     }
63189   }
63190 }
63191
63192
63193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
63194   void * jresult ;
63195   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63196   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
63197
63198   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63199   {
63200     try {
63201       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
63202     } catch (std::out_of_range& e) {
63203       {
63204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63205       };
63206     } catch (std::exception& e) {
63207       {
63208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63209       };
63210     } catch (...) {
63211       {
63212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63213       };
63214     }
63215   }
63216   jresult = (void *)result;
63217   return jresult;
63218 }
63219
63220
63221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
63222   void * jresult ;
63223   Dali::Toolkit::Alignment::Padding *result = 0 ;
63224
63225   {
63226     try {
63227       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
63228     } catch (std::out_of_range& e) {
63229       {
63230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63231       };
63232     } catch (std::exception& e) {
63233       {
63234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63235       };
63236     } catch (...) {
63237       {
63238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63239       };
63240     }
63241   }
63242   jresult = (void *)result;
63243   return jresult;
63244 }
63245
63246
63247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
63248   void * jresult ;
63249   float arg1 ;
63250   float arg2 ;
63251   float arg3 ;
63252   float arg4 ;
63253   Dali::Toolkit::Alignment::Padding *result = 0 ;
63254
63255   arg1 = (float)jarg1;
63256   arg2 = (float)jarg2;
63257   arg3 = (float)jarg3;
63258   arg4 = (float)jarg4;
63259   {
63260     try {
63261       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
63262     } catch (std::out_of_range& e) {
63263       {
63264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63265       };
63266     } catch (std::exception& e) {
63267       {
63268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63269       };
63270     } catch (...) {
63271       {
63272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63273       };
63274     }
63275   }
63276   jresult = (void *)result;
63277   return jresult;
63278 }
63279
63280
63281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
63282   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63283   float arg2 ;
63284
63285   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63286   arg2 = (float)jarg2;
63287   if (arg1) (arg1)->left = arg2;
63288 }
63289
63290
63291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
63292   float jresult ;
63293   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63294   float result;
63295
63296   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63297   result = (float) ((arg1)->left);
63298   jresult = result;
63299   return jresult;
63300 }
63301
63302
63303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
63304   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63305   float arg2 ;
63306
63307   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63308   arg2 = (float)jarg2;
63309   if (arg1) (arg1)->right = arg2;
63310 }
63311
63312
63313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
63314   float jresult ;
63315   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63316   float result;
63317
63318   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63319   result = (float) ((arg1)->right);
63320   jresult = result;
63321   return jresult;
63322 }
63323
63324
63325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
63326   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63327   float arg2 ;
63328
63329   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63330   arg2 = (float)jarg2;
63331   if (arg1) (arg1)->top = arg2;
63332 }
63333
63334
63335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
63336   float jresult ;
63337   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63338   float result;
63339
63340   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63341   result = (float) ((arg1)->top);
63342   jresult = result;
63343   return jresult;
63344 }
63345
63346
63347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
63348   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63349   float arg2 ;
63350
63351   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63352   arg2 = (float)jarg2;
63353   if (arg1) (arg1)->bottom = arg2;
63354 }
63355
63356
63357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
63358   float jresult ;
63359   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63360   float result;
63361
63362   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63363   result = (float) ((arg1)->bottom);
63364   jresult = result;
63365   return jresult;
63366 }
63367
63368
63369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
63370   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63371
63372   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63373   {
63374     try {
63375       delete arg1;
63376     } catch (std::out_of_range& e) {
63377       {
63378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63379       };
63380     } catch (std::exception& e) {
63381       {
63382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63383       };
63384     } catch (...) {
63385       {
63386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63387       };
63388     }
63389   }
63390 }
63391
63392
63393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
63394   void * jresult ;
63395   Dali::Toolkit::Alignment *result = 0 ;
63396
63397   {
63398     try {
63399       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
63400     } catch (std::out_of_range& e) {
63401       {
63402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63403       };
63404     } catch (std::exception& e) {
63405       {
63406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63407       };
63408     } catch (...) {
63409       {
63410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63411       };
63412     }
63413   }
63414   jresult = (void *)result;
63415   return jresult;
63416 }
63417
63418
63419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
63420   void * jresult ;
63421   Dali::Toolkit::Alignment::Type arg1 ;
63422   Dali::Toolkit::Alignment::Type arg2 ;
63423   Dali::Toolkit::Alignment result;
63424
63425   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63426   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63427   {
63428     try {
63429       result = Dali::Toolkit::Alignment::New(arg1,arg2);
63430     } catch (std::out_of_range& e) {
63431       {
63432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63433       };
63434     } catch (std::exception& e) {
63435       {
63436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63437       };
63438     } catch (...) {
63439       {
63440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63441       };
63442     }
63443   }
63444   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63445   return jresult;
63446 }
63447
63448
63449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
63450   void * jresult ;
63451   Dali::Toolkit::Alignment::Type arg1 ;
63452   Dali::Toolkit::Alignment result;
63453
63454   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63455   {
63456     try {
63457       result = Dali::Toolkit::Alignment::New(arg1);
63458     } catch (std::out_of_range& e) {
63459       {
63460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63461       };
63462     } catch (std::exception& e) {
63463       {
63464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63465       };
63466     } catch (...) {
63467       {
63468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63469       };
63470     }
63471   }
63472   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63473   return jresult;
63474 }
63475
63476
63477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
63478   void * jresult ;
63479   Dali::Toolkit::Alignment result;
63480
63481   {
63482     try {
63483       result = Dali::Toolkit::Alignment::New();
63484     } catch (std::out_of_range& e) {
63485       {
63486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63487       };
63488     } catch (std::exception& e) {
63489       {
63490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63491       };
63492     } catch (...) {
63493       {
63494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63495       };
63496     }
63497   }
63498   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63499   return jresult;
63500 }
63501
63502
63503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
63504   void * jresult ;
63505   Dali::Toolkit::Alignment *arg1 = 0 ;
63506   Dali::Toolkit::Alignment *result = 0 ;
63507
63508   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63509   if (!arg1) {
63510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63511     return 0;
63512   }
63513   {
63514     try {
63515       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
63516     } catch (std::out_of_range& e) {
63517       {
63518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63519       };
63520     } catch (std::exception& e) {
63521       {
63522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63523       };
63524     } catch (...) {
63525       {
63526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63527       };
63528     }
63529   }
63530   jresult = (void *)result;
63531   return jresult;
63532 }
63533
63534
63535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
63536   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63537
63538   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63539   {
63540     try {
63541       delete arg1;
63542     } catch (std::out_of_range& e) {
63543       {
63544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63545       };
63546     } catch (std::exception& e) {
63547       {
63548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63549       };
63550     } catch (...) {
63551       {
63552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63553       };
63554     }
63555   }
63556 }
63557
63558
63559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
63560   void * jresult ;
63561   Dali::BaseHandle arg1 ;
63562   Dali::BaseHandle *argp1 ;
63563   Dali::Toolkit::Alignment result;
63564
63565   argp1 = (Dali::BaseHandle *)jarg1;
63566   if (!argp1) {
63567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63568     return 0;
63569   }
63570   arg1 = *argp1;
63571   {
63572     try {
63573       result = Dali::Toolkit::Alignment::DownCast(arg1);
63574     } catch (std::out_of_range& e) {
63575       {
63576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63577       };
63578     } catch (std::exception& e) {
63579       {
63580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63581       };
63582     } catch (...) {
63583       {
63584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63585       };
63586     }
63587   }
63588   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63589   return jresult;
63590 }
63591
63592
63593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
63594   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63595   Dali::Toolkit::Alignment::Type arg2 ;
63596
63597   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63598   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63599   {
63600     try {
63601       (arg1)->SetAlignmentType(arg2);
63602     } catch (std::out_of_range& e) {
63603       {
63604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63605       };
63606     } catch (std::exception& e) {
63607       {
63608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63609       };
63610     } catch (...) {
63611       {
63612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63613       };
63614     }
63615   }
63616 }
63617
63618
63619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
63620   int jresult ;
63621   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63622   Dali::Toolkit::Alignment::Type result;
63623
63624   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63625   {
63626     try {
63627       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
63628     } catch (std::out_of_range& e) {
63629       {
63630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63631       };
63632     } catch (std::exception& e) {
63633       {
63634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63635       };
63636     } catch (...) {
63637       {
63638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63639       };
63640     }
63641   }
63642   jresult = (int)result;
63643   return jresult;
63644 }
63645
63646
63647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
63648   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63649   Dali::Toolkit::Alignment::Scaling arg2 ;
63650
63651   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63652   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
63653   {
63654     try {
63655       (arg1)->SetScaling(arg2);
63656     } catch (std::out_of_range& e) {
63657       {
63658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63659       };
63660     } catch (std::exception& e) {
63661       {
63662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63663       };
63664     } catch (...) {
63665       {
63666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63667       };
63668     }
63669   }
63670 }
63671
63672
63673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
63674   int jresult ;
63675   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63676   Dali::Toolkit::Alignment::Scaling result;
63677
63678   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63679   {
63680     try {
63681       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
63682     } catch (std::out_of_range& e) {
63683       {
63684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63685       };
63686     } catch (std::exception& e) {
63687       {
63688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63689       };
63690     } catch (...) {
63691       {
63692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63693       };
63694     }
63695   }
63696   jresult = (int)result;
63697   return jresult;
63698 }
63699
63700
63701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
63702   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63703   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
63704
63705   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63706   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
63707   if (!arg2) {
63708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
63709     return ;
63710   }
63711   {
63712     try {
63713       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
63714     } catch (std::out_of_range& e) {
63715       {
63716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63717       };
63718     } catch (std::exception& e) {
63719       {
63720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63721       };
63722     } catch (...) {
63723       {
63724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63725       };
63726     }
63727   }
63728 }
63729
63730
63731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
63732   void * jresult ;
63733   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63734   Dali::Toolkit::Alignment::Padding *result = 0 ;
63735
63736   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63737   {
63738     try {
63739       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
63740     } catch (std::out_of_range& e) {
63741       {
63742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63743       };
63744     } catch (std::exception& e) {
63745       {
63746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63747       };
63748     } catch (...) {
63749       {
63750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63751       };
63752     }
63753   }
63754   jresult = (void *)result;
63755   return jresult;
63756 }
63757
63758
63759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
63760   void * jresult ;
63761   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63762   Dali::Toolkit::Alignment *arg2 = 0 ;
63763   Dali::Toolkit::Alignment *result = 0 ;
63764
63765   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63766   arg2 = (Dali::Toolkit::Alignment *)jarg2;
63767   if (!arg2) {
63768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63769     return 0;
63770   }
63771   {
63772     try {
63773       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
63774     } catch (std::out_of_range& e) {
63775       {
63776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63777       };
63778     } catch (std::exception& e) {
63779       {
63780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63781       };
63782     } catch (...) {
63783       {
63784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63785       };
63786     }
63787   }
63788   jresult = (void *)result;
63789   return jresult;
63790 }
63791
63792
63793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
63794   int jresult ;
63795   int result;
63796
63797   result = (int)Dali::Toolkit::Button::Property::DISABLED;
63798   jresult = (int)result;
63799   return jresult;
63800 }
63801
63802
63803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
63804   int jresult ;
63805   int result;
63806
63807   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
63808   jresult = (int)result;
63809   return jresult;
63810 }
63811
63812
63813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
63814   int jresult ;
63815   int result;
63816
63817   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
63818   jresult = (int)result;
63819   return jresult;
63820 }
63821
63822
63823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
63824   int jresult ;
63825   int result;
63826
63827   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
63828   jresult = (int)result;
63829   return jresult;
63830 }
63831
63832
63833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
63834   int jresult ;
63835   int result;
63836
63837   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
63838   jresult = (int)result;
63839   return jresult;
63840 }
63841
63842
63843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
63844   int jresult ;
63845   int result;
63846
63847   result = (int)Dali::Toolkit::Button::Property::SELECTED;
63848   jresult = (int)result;
63849   return jresult;
63850 }
63851
63852
63853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_STATE_IMAGE_get() {
63854   int jresult ;
63855   int result;
63856
63857   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_STATE_IMAGE;
63858   jresult = (int)result;
63859   return jresult;
63860 }
63861
63862
63863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_STATE_IMAGE_get() {
63864   int jresult ;
63865   int result;
63866
63867   result = (int)Dali::Toolkit::Button::Property::SELECTED_STATE_IMAGE;
63868   jresult = (int)result;
63869   return jresult;
63870 }
63871
63872
63873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_STATE_IMAGE_get() {
63874   int jresult ;
63875   int result;
63876
63877   result = (int)Dali::Toolkit::Button::Property::DISABLED_STATE_IMAGE;
63878   jresult = (int)result;
63879   return jresult;
63880 }
63881
63882
63883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
63884   int jresult ;
63885   int result;
63886
63887   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
63888   jresult = (int)result;
63889   return jresult;
63890 }
63891
63892
63893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
63894   int jresult ;
63895   int result;
63896
63897   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
63898   jresult = (int)result;
63899   return jresult;
63900 }
63901
63902
63903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
63904   int jresult ;
63905   int result;
63906
63907   result = (int)Dali::Toolkit::Button::Property::LABEL;
63908   jresult = (int)result;
63909   return jresult;
63910 }
63911
63912
63913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
63914   int jresult ;
63915   int result;
63916
63917   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
63918   jresult = (int)result;
63919   return jresult;
63920 }
63921
63922
63923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
63924   void * jresult ;
63925   Dali::Toolkit::Button::Property *result = 0 ;
63926
63927   {
63928     try {
63929       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
63930     } catch (std::out_of_range& e) {
63931       {
63932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63933       };
63934     } catch (std::exception& e) {
63935       {
63936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63937       };
63938     } catch (...) {
63939       {
63940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63941       };
63942     }
63943   }
63944   jresult = (void *)result;
63945   return jresult;
63946 }
63947
63948
63949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
63950   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
63951
63952   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
63953   {
63954     try {
63955       delete arg1;
63956     } catch (std::out_of_range& e) {
63957       {
63958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63959       };
63960     } catch (std::exception& e) {
63961       {
63962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63963       };
63964     } catch (...) {
63965       {
63966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63967       };
63968     }
63969   }
63970 }
63971
63972
63973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
63974   void * jresult ;
63975   Dali::Toolkit::Button *result = 0 ;
63976
63977   {
63978     try {
63979       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
63980     } catch (std::out_of_range& e) {
63981       {
63982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63983       };
63984     } catch (std::exception& e) {
63985       {
63986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63987       };
63988     } catch (...) {
63989       {
63990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63991       };
63992     }
63993   }
63994   jresult = (void *)result;
63995   return jresult;
63996 }
63997
63998
63999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
64000   void * jresult ;
64001   Dali::Toolkit::Button *arg1 = 0 ;
64002   Dali::Toolkit::Button *result = 0 ;
64003
64004   arg1 = (Dali::Toolkit::Button *)jarg1;
64005   if (!arg1) {
64006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64007     return 0;
64008   }
64009   {
64010     try {
64011       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64012     } catch (std::out_of_range& e) {
64013       {
64014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64015       };
64016     } catch (std::exception& e) {
64017       {
64018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64019       };
64020     } catch (...) {
64021       {
64022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64023       };
64024     }
64025   }
64026   jresult = (void *)result;
64027   return jresult;
64028 }
64029
64030
64031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
64032   void * jresult ;
64033   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64034   Dali::Toolkit::Button *arg2 = 0 ;
64035   Dali::Toolkit::Button *result = 0 ;
64036
64037   arg1 = (Dali::Toolkit::Button *)jarg1;
64038   arg2 = (Dali::Toolkit::Button *)jarg2;
64039   if (!arg2) {
64040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64041     return 0;
64042   }
64043   {
64044     try {
64045       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64046     } catch (std::out_of_range& e) {
64047       {
64048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64049       };
64050     } catch (std::exception& e) {
64051       {
64052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64053       };
64054     } catch (...) {
64055       {
64056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64057       };
64058     }
64059   }
64060   jresult = (void *)result;
64061   return jresult;
64062 }
64063
64064
64065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
64066   void * jresult ;
64067   Dali::BaseHandle arg1 ;
64068   Dali::BaseHandle *argp1 ;
64069   Dali::Toolkit::Button result;
64070
64071   argp1 = (Dali::BaseHandle *)jarg1;
64072   if (!argp1) {
64073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64074     return 0;
64075   }
64076   arg1 = *argp1;
64077   {
64078     try {
64079       result = Dali::Toolkit::Button::DownCast(arg1);
64080     } catch (std::out_of_range& e) {
64081       {
64082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64083       };
64084     } catch (std::exception& e) {
64085       {
64086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64087       };
64088     } catch (...) {
64089       {
64090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64091       };
64092     }
64093   }
64094   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
64095   return jresult;
64096 }
64097
64098
64099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
64100   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64101
64102   arg1 = (Dali::Toolkit::Button *)jarg1;
64103   {
64104     try {
64105       delete arg1;
64106     } catch (std::out_of_range& e) {
64107       {
64108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64109       };
64110     } catch (std::exception& e) {
64111       {
64112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64113       };
64114     } catch (...) {
64115       {
64116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64117       };
64118     }
64119   }
64120 }
64121
64122
64123 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
64124   unsigned int jresult ;
64125   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64126   bool result;
64127
64128   arg1 = (Dali::Toolkit::Button *)jarg1;
64129   {
64130     try {
64131       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
64132     } catch (std::out_of_range& e) {
64133       {
64134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64135       };
64136     } catch (std::exception& e) {
64137       {
64138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64139       };
64140     } catch (...) {
64141       {
64142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64143       };
64144     }
64145   }
64146   jresult = result;
64147   return jresult;
64148 }
64149
64150
64151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
64152   unsigned int jresult ;
64153   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64154   bool result;
64155
64156   arg1 = (Dali::Toolkit::Button *)jarg1;
64157   {
64158     try {
64159       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
64160     } catch (std::out_of_range& e) {
64161       {
64162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64163       };
64164     } catch (std::exception& e) {
64165       {
64166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64167       };
64168     } catch (...) {
64169       {
64170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64171       };
64172     }
64173   }
64174   jresult = result;
64175   return jresult;
64176 }
64177
64178
64179 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
64180   float jresult ;
64181   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64182   float result;
64183
64184   arg1 = (Dali::Toolkit::Button *)jarg1;
64185   {
64186     try {
64187       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
64188     } catch (std::out_of_range& e) {
64189       {
64190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64191       };
64192     } catch (std::exception& e) {
64193       {
64194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64195       };
64196     } catch (...) {
64197       {
64198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64199       };
64200     }
64201   }
64202   jresult = result;
64203   return jresult;
64204 }
64205
64206
64207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
64208   float jresult ;
64209   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64210   float result;
64211
64212   arg1 = (Dali::Toolkit::Button *)jarg1;
64213   {
64214     try {
64215       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
64216     } catch (std::out_of_range& e) {
64217       {
64218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64219       };
64220     } catch (std::exception& e) {
64221       {
64222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64223       };
64224     } catch (...) {
64225       {
64226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64227       };
64228     }
64229   }
64230   jresult = result;
64231   return jresult;
64232 }
64233
64234
64235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
64236   unsigned int jresult ;
64237   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64238   bool result;
64239
64240   arg1 = (Dali::Toolkit::Button *)jarg1;
64241   {
64242     try {
64243       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
64244     } catch (std::out_of_range& e) {
64245       {
64246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64247       };
64248     } catch (std::exception& e) {
64249       {
64250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64251       };
64252     } catch (...) {
64253       {
64254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64255       };
64256     }
64257   }
64258   jresult = result;
64259   return jresult;
64260 }
64261
64262
64263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
64264   unsigned int jresult ;
64265   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64266   bool result;
64267
64268   arg1 = (Dali::Toolkit::Button *)jarg1;
64269   {
64270     try {
64271       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
64272     } catch (std::out_of_range& e) {
64273       {
64274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64275       };
64276     } catch (std::exception& e) {
64277       {
64278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64279       };
64280     } catch (...) {
64281       {
64282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64283       };
64284     }
64285   }
64286   jresult = result;
64287   return jresult;
64288 }
64289
64290
64291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
64292   float jresult ;
64293   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64294   float result;
64295
64296   arg1 = (Dali::Toolkit::Button *)jarg1;
64297   {
64298     try {
64299       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
64300     } catch (std::out_of_range& e) {
64301       {
64302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64303       };
64304     } catch (std::exception& e) {
64305       {
64306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64307       };
64308     } catch (...) {
64309       {
64310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64311       };
64312     }
64313   }
64314   jresult = result;
64315   return jresult;
64316 }
64317
64318
64319 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
64320   char * jresult ;
64321   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64322   std::string result;
64323
64324   arg1 = (Dali::Toolkit::Button *)jarg1;
64325   {
64326     try {
64327       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
64328     } catch (std::out_of_range& e) {
64329       {
64330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64331       };
64332     } catch (std::exception& e) {
64333       {
64334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64335       };
64336     } catch (...) {
64337       {
64338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64339       };
64340     }
64341   }
64342   jresult = SWIG_csharp_string_callback((&result)->c_str());
64343   return jresult;
64344 }
64345
64346
64347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
64348   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64349   Dali::Actor arg2 ;
64350   Dali::Actor *argp2 ;
64351
64352   arg1 = (Dali::Toolkit::Button *)jarg1;
64353   argp2 = (Dali::Actor *)jarg2;
64354   if (!argp2) {
64355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64356     return ;
64357   }
64358   arg2 = *argp2;
64359   {
64360     try {
64361       (arg1)->SetLabel(arg2);
64362     } catch (std::out_of_range& e) {
64363       {
64364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64365       };
64366     } catch (std::exception& e) {
64367       {
64368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64369       };
64370     } catch (...) {
64371       {
64372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64373       };
64374     }
64375   }
64376 }
64377
64378
64379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
64380   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64381   Dali::Image arg2 ;
64382   Dali::Image *argp2 ;
64383
64384   arg1 = (Dali::Toolkit::Button *)jarg1;
64385   argp2 = (Dali::Image *)jarg2;
64386   if (!argp2) {
64387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64388     return ;
64389   }
64390   arg2 = *argp2;
64391   {
64392     try {
64393       (arg1)->SetButtonImage(arg2);
64394     } catch (std::out_of_range& e) {
64395       {
64396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64397       };
64398     } catch (std::exception& e) {
64399       {
64400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64401       };
64402     } catch (...) {
64403       {
64404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64405       };
64406     }
64407   }
64408 }
64409
64410
64411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
64412   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64413   Dali::Image arg2 ;
64414   Dali::Image *argp2 ;
64415
64416   arg1 = (Dali::Toolkit::Button *)jarg1;
64417   argp2 = (Dali::Image *)jarg2;
64418   if (!argp2) {
64419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64420     return ;
64421   }
64422   arg2 = *argp2;
64423   {
64424     try {
64425       (arg1)->SetSelectedImage(arg2);
64426     } catch (std::out_of_range& e) {
64427       {
64428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64429       };
64430     } catch (std::exception& e) {
64431       {
64432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64433       };
64434     } catch (...) {
64435       {
64436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64437       };
64438     }
64439   }
64440 }
64441
64442
64443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
64444   void * jresult ;
64445   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64446   Dali::Actor result;
64447
64448   arg1 = (Dali::Toolkit::Button *)jarg1;
64449   {
64450     try {
64451       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
64452     } catch (std::out_of_range& e) {
64453       {
64454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64455       };
64456     } catch (std::exception& e) {
64457       {
64458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64459       };
64460     } catch (...) {
64461       {
64462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64463       };
64464     }
64465   }
64466   jresult = new Dali::Actor((const Dali::Actor &)result);
64467   return jresult;
64468 }
64469
64470
64471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
64472   void * jresult ;
64473   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64474   Dali::Actor result;
64475
64476   arg1 = (Dali::Toolkit::Button *)jarg1;
64477   {
64478     try {
64479       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
64480     } catch (std::out_of_range& e) {
64481       {
64482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64483       };
64484     } catch (std::exception& e) {
64485       {
64486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64487       };
64488     } catch (...) {
64489       {
64490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64491       };
64492     }
64493   }
64494   jresult = new Dali::Actor((const Dali::Actor &)result);
64495   return jresult;
64496 }
64497
64498
64499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
64500   void * jresult ;
64501   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64502   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64503
64504   arg1 = (Dali::Toolkit::Button *)jarg1;
64505   {
64506     try {
64507       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
64508     } catch (std::out_of_range& e) {
64509       {
64510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64511       };
64512     } catch (std::exception& e) {
64513       {
64514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64515       };
64516     } catch (...) {
64517       {
64518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64519       };
64520     }
64521   }
64522   jresult = (void *)result;
64523   return jresult;
64524 }
64525
64526
64527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
64528   void * jresult ;
64529   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64530   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64531
64532   arg1 = (Dali::Toolkit::Button *)jarg1;
64533   {
64534     try {
64535       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
64536     } catch (std::out_of_range& e) {
64537       {
64538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64539       };
64540     } catch (std::exception& e) {
64541       {
64542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64543       };
64544     } catch (...) {
64545       {
64546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64547       };
64548     }
64549   }
64550   jresult = (void *)result;
64551   return jresult;
64552 }
64553
64554
64555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
64556   void * jresult ;
64557   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64558   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64559
64560   arg1 = (Dali::Toolkit::Button *)jarg1;
64561   {
64562     try {
64563       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
64564     } catch (std::out_of_range& e) {
64565       {
64566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64567       };
64568     } catch (std::exception& e) {
64569       {
64570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64571       };
64572     } catch (...) {
64573       {
64574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64575       };
64576     }
64577   }
64578   jresult = (void *)result;
64579   return jresult;
64580 }
64581
64582
64583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
64584   void * jresult ;
64585   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64586   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64587
64588   arg1 = (Dali::Toolkit::Button *)jarg1;
64589   {
64590     try {
64591       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
64592     } catch (std::out_of_range& e) {
64593       {
64594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64595       };
64596     } catch (std::exception& e) {
64597       {
64598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64599       };
64600     } catch (...) {
64601       {
64602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64603       };
64604     }
64605   }
64606   jresult = (void *)result;
64607   return jresult;
64608 }
64609
64610
64611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
64612   void * jresult ;
64613   Dali::Toolkit::CheckBoxButton *result = 0 ;
64614
64615   {
64616     try {
64617       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
64618     } catch (std::out_of_range& e) {
64619       {
64620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64621       };
64622     } catch (std::exception& e) {
64623       {
64624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64625       };
64626     } catch (...) {
64627       {
64628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64629       };
64630     }
64631   }
64632   jresult = (void *)result;
64633   return jresult;
64634 }
64635
64636
64637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
64638   void * jresult ;
64639   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
64640   Dali::Toolkit::CheckBoxButton *result = 0 ;
64641
64642   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64643   if (!arg1) {
64644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64645     return 0;
64646   }
64647   {
64648     try {
64649       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
64650     } catch (std::out_of_range& e) {
64651       {
64652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64653       };
64654     } catch (std::exception& e) {
64655       {
64656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64657       };
64658     } catch (...) {
64659       {
64660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64661       };
64662     }
64663   }
64664   jresult = (void *)result;
64665   return jresult;
64666 }
64667
64668
64669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
64670   void * jresult ;
64671   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64672   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
64673   Dali::Toolkit::CheckBoxButton *result = 0 ;
64674
64675   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64676   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
64677   if (!arg2) {
64678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64679     return 0;
64680   }
64681   {
64682     try {
64683       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
64684     } catch (std::out_of_range& e) {
64685       {
64686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64687       };
64688     } catch (std::exception& e) {
64689       {
64690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64691       };
64692     } catch (...) {
64693       {
64694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64695       };
64696     }
64697   }
64698   jresult = (void *)result;
64699   return jresult;
64700 }
64701
64702
64703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
64704   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64705
64706   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64707   {
64708     try {
64709       delete arg1;
64710     } catch (std::out_of_range& e) {
64711       {
64712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64713       };
64714     } catch (std::exception& e) {
64715       {
64716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64717       };
64718     } catch (...) {
64719       {
64720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64721       };
64722     }
64723   }
64724 }
64725
64726
64727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
64728   void * jresult ;
64729   Dali::Toolkit::CheckBoxButton result;
64730
64731   {
64732     try {
64733       result = Dali::Toolkit::CheckBoxButton::New();
64734     } catch (std::out_of_range& e) {
64735       {
64736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64737       };
64738     } catch (std::exception& e) {
64739       {
64740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64741       };
64742     } catch (...) {
64743       {
64744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64745       };
64746     }
64747   }
64748   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64749   return jresult;
64750 }
64751
64752
64753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
64754   void * jresult ;
64755   Dali::BaseHandle arg1 ;
64756   Dali::BaseHandle *argp1 ;
64757   Dali::Toolkit::CheckBoxButton result;
64758
64759   argp1 = (Dali::BaseHandle *)jarg1;
64760   if (!argp1) {
64761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64762     return 0;
64763   }
64764   arg1 = *argp1;
64765   {
64766     try {
64767       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
64768     } catch (std::out_of_range& e) {
64769       {
64770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64771       };
64772     } catch (std::exception& e) {
64773       {
64774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64775       };
64776     } catch (...) {
64777       {
64778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64779       };
64780     }
64781   }
64782   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64783   return jresult;
64784 }
64785
64786
64787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
64788   int jresult ;
64789   int result;
64790
64791   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
64792   jresult = (int)result;
64793   return jresult;
64794 }
64795
64796
64797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
64798   int jresult ;
64799   int result;
64800
64801   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
64802   jresult = (int)result;
64803   return jresult;
64804 }
64805
64806
64807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
64808   int jresult ;
64809   int result;
64810
64811   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
64812   jresult = (int)result;
64813   return jresult;
64814 }
64815
64816
64817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
64818   int jresult ;
64819   int result;
64820
64821   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
64822   jresult = (int)result;
64823   return jresult;
64824 }
64825
64826
64827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
64828   int jresult ;
64829   int result;
64830
64831   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
64832   jresult = (int)result;
64833   return jresult;
64834 }
64835
64836
64837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
64838   void * jresult ;
64839   Dali::Toolkit::PushButton::Property *result = 0 ;
64840
64841   {
64842     try {
64843       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
64844     } catch (std::out_of_range& e) {
64845       {
64846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64847       };
64848     } catch (std::exception& e) {
64849       {
64850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64851       };
64852     } catch (...) {
64853       {
64854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64855       };
64856     }
64857   }
64858   jresult = (void *)result;
64859   return jresult;
64860 }
64861
64862
64863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
64864   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
64865
64866   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
64867   {
64868     try {
64869       delete arg1;
64870     } catch (std::out_of_range& e) {
64871       {
64872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64873       };
64874     } catch (std::exception& e) {
64875       {
64876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64877       };
64878     } catch (...) {
64879       {
64880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64881       };
64882     }
64883   }
64884 }
64885
64886
64887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
64888   void * jresult ;
64889   Dali::Toolkit::PushButton *result = 0 ;
64890
64891   {
64892     try {
64893       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
64894     } catch (std::out_of_range& e) {
64895       {
64896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64897       };
64898     } catch (std::exception& e) {
64899       {
64900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64901       };
64902     } catch (...) {
64903       {
64904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64905       };
64906     }
64907   }
64908   jresult = (void *)result;
64909   return jresult;
64910 }
64911
64912
64913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
64914   void * jresult ;
64915   Dali::Toolkit::PushButton *arg1 = 0 ;
64916   Dali::Toolkit::PushButton *result = 0 ;
64917
64918   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64919   if (!arg1) {
64920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
64921     return 0;
64922   }
64923   {
64924     try {
64925       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
64926     } catch (std::out_of_range& e) {
64927       {
64928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64929       };
64930     } catch (std::exception& e) {
64931       {
64932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64933       };
64934     } catch (...) {
64935       {
64936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64937       };
64938     }
64939   }
64940   jresult = (void *)result;
64941   return jresult;
64942 }
64943
64944
64945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
64946   void * jresult ;
64947   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64948   Dali::Toolkit::PushButton *arg2 = 0 ;
64949   Dali::Toolkit::PushButton *result = 0 ;
64950
64951   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64952   arg2 = (Dali::Toolkit::PushButton *)jarg2;
64953   if (!arg2) {
64954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
64955     return 0;
64956   }
64957   {
64958     try {
64959       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
64960     } catch (std::out_of_range& e) {
64961       {
64962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64963       };
64964     } catch (std::exception& e) {
64965       {
64966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64967       };
64968     } catch (...) {
64969       {
64970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64971       };
64972     }
64973   }
64974   jresult = (void *)result;
64975   return jresult;
64976 }
64977
64978
64979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
64980   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64981
64982   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64983   {
64984     try {
64985       delete arg1;
64986     } catch (std::out_of_range& e) {
64987       {
64988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64989       };
64990     } catch (std::exception& e) {
64991       {
64992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64993       };
64994     } catch (...) {
64995       {
64996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64997       };
64998     }
64999   }
65000 }
65001
65002
65003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65004   void * jresult ;
65005   Dali::Toolkit::PushButton result;
65006
65007   {
65008     try {
65009       result = Dali::Toolkit::PushButton::New();
65010     } catch (std::out_of_range& e) {
65011       {
65012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65013       };
65014     } catch (std::exception& e) {
65015       {
65016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65017       };
65018     } catch (...) {
65019       {
65020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65021       };
65022     }
65023   }
65024   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65025   return jresult;
65026 }
65027
65028
65029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65030   void * jresult ;
65031   Dali::BaseHandle arg1 ;
65032   Dali::BaseHandle *argp1 ;
65033   Dali::Toolkit::PushButton result;
65034
65035   argp1 = (Dali::BaseHandle *)jarg1;
65036   if (!argp1) {
65037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65038     return 0;
65039   }
65040   arg1 = *argp1;
65041   {
65042     try {
65043       result = Dali::Toolkit::PushButton::DownCast(arg1);
65044     } catch (std::out_of_range& e) {
65045       {
65046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65047       };
65048     } catch (std::exception& e) {
65049       {
65050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65051       };
65052     } catch (...) {
65053       {
65054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65055       };
65056     }
65057   }
65058   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65059   return jresult;
65060 }
65061
65062
65063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
65064   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65065   Dali::Image arg2 ;
65066   Dali::Image *argp2 ;
65067
65068   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65069   argp2 = (Dali::Image *)jarg2;
65070   if (!argp2) {
65071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65072     return ;
65073   }
65074   arg2 = *argp2;
65075   {
65076     try {
65077       (arg1)->SetButtonImage(arg2);
65078     } catch (std::out_of_range& e) {
65079       {
65080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65081       };
65082     } catch (std::exception& e) {
65083       {
65084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65085       };
65086     } catch (...) {
65087       {
65088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65089       };
65090     }
65091   }
65092 }
65093
65094
65095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
65096   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65097   Dali::Actor arg2 ;
65098   Dali::Actor *argp2 ;
65099
65100   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65101   argp2 = (Dali::Actor *)jarg2;
65102   if (!argp2) {
65103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65104     return ;
65105   }
65106   arg2 = *argp2;
65107   {
65108     try {
65109       (arg1)->SetButtonImage(arg2);
65110     } catch (std::out_of_range& e) {
65111       {
65112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65113       };
65114     } catch (std::exception& e) {
65115       {
65116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65117       };
65118     } catch (...) {
65119       {
65120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65121       };
65122     }
65123   }
65124 }
65125
65126
65127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
65128   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65129   Dali::Actor arg2 ;
65130   Dali::Actor *argp2 ;
65131
65132   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65133   argp2 = (Dali::Actor *)jarg2;
65134   if (!argp2) {
65135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65136     return ;
65137   }
65138   arg2 = *argp2;
65139   {
65140     try {
65141       (arg1)->SetBackgroundImage(arg2);
65142     } catch (std::out_of_range& e) {
65143       {
65144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65145       };
65146     } catch (std::exception& e) {
65147       {
65148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65149       };
65150     } catch (...) {
65151       {
65152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65153       };
65154     }
65155   }
65156 }
65157
65158
65159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
65160   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65161   Dali::Image arg2 ;
65162   Dali::Image *argp2 ;
65163
65164   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65165   argp2 = (Dali::Image *)jarg2;
65166   if (!argp2) {
65167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65168     return ;
65169   }
65170   arg2 = *argp2;
65171   {
65172     try {
65173       (arg1)->SetSelectedImage(arg2);
65174     } catch (std::out_of_range& e) {
65175       {
65176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65177       };
65178     } catch (std::exception& e) {
65179       {
65180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65181       };
65182     } catch (...) {
65183       {
65184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65185       };
65186     }
65187   }
65188 }
65189
65190
65191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
65192   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65193   Dali::Actor arg2 ;
65194   Dali::Actor *argp2 ;
65195
65196   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65197   argp2 = (Dali::Actor *)jarg2;
65198   if (!argp2) {
65199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65200     return ;
65201   }
65202   arg2 = *argp2;
65203   {
65204     try {
65205       (arg1)->SetSelectedImage(arg2);
65206     } catch (std::out_of_range& e) {
65207       {
65208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65209       };
65210     } catch (std::exception& e) {
65211       {
65212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65213       };
65214     } catch (...) {
65215       {
65216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65217       };
65218     }
65219   }
65220 }
65221
65222
65223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
65224   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65225   Dali::Actor arg2 ;
65226   Dali::Actor *argp2 ;
65227
65228   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65229   argp2 = (Dali::Actor *)jarg2;
65230   if (!argp2) {
65231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65232     return ;
65233   }
65234   arg2 = *argp2;
65235   {
65236     try {
65237       (arg1)->SetSelectedBackgroundImage(arg2);
65238     } catch (std::out_of_range& e) {
65239       {
65240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65241       };
65242     } catch (std::exception& e) {
65243       {
65244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65245       };
65246     } catch (...) {
65247       {
65248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65249       };
65250     }
65251   }
65252 }
65253
65254
65255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
65256   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65257   Dali::Actor arg2 ;
65258   Dali::Actor *argp2 ;
65259
65260   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65261   argp2 = (Dali::Actor *)jarg2;
65262   if (!argp2) {
65263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65264     return ;
65265   }
65266   arg2 = *argp2;
65267   {
65268     try {
65269       (arg1)->SetDisabledBackgroundImage(arg2);
65270     } catch (std::out_of_range& e) {
65271       {
65272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65273       };
65274     } catch (std::exception& e) {
65275       {
65276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65277       };
65278     } catch (...) {
65279       {
65280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65281       };
65282     }
65283   }
65284 }
65285
65286
65287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
65288   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65289   Dali::Actor arg2 ;
65290   Dali::Actor *argp2 ;
65291
65292   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65293   argp2 = (Dali::Actor *)jarg2;
65294   if (!argp2) {
65295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65296     return ;
65297   }
65298   arg2 = *argp2;
65299   {
65300     try {
65301       (arg1)->SetDisabledImage(arg2);
65302     } catch (std::out_of_range& e) {
65303       {
65304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65305       };
65306     } catch (std::exception& e) {
65307       {
65308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65309       };
65310     } catch (...) {
65311       {
65312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65313       };
65314     }
65315   }
65316 }
65317
65318
65319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
65320   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65321   Dali::Actor arg2 ;
65322   Dali::Actor *argp2 ;
65323
65324   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65325   argp2 = (Dali::Actor *)jarg2;
65326   if (!argp2) {
65327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65328     return ;
65329   }
65330   arg2 = *argp2;
65331   {
65332     try {
65333       (arg1)->SetDisabledSelectedImage(arg2);
65334     } catch (std::out_of_range& e) {
65335       {
65336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65337       };
65338     } catch (std::exception& e) {
65339       {
65340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65341       };
65342     } catch (...) {
65343       {
65344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65345       };
65346     }
65347   }
65348 }
65349
65350
65351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65352   void * jresult ;
65353   Dali::Toolkit::RadioButton *result = 0 ;
65354
65355   {
65356     try {
65357       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65358     } catch (std::out_of_range& e) {
65359       {
65360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65361       };
65362     } catch (std::exception& e) {
65363       {
65364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65365       };
65366     } catch (...) {
65367       {
65368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65369       };
65370     }
65371   }
65372   jresult = (void *)result;
65373   return jresult;
65374 }
65375
65376
65377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65378   void * jresult ;
65379   Dali::Toolkit::RadioButton *arg1 = 0 ;
65380   Dali::Toolkit::RadioButton *result = 0 ;
65381
65382   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65383   if (!arg1) {
65384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65385     return 0;
65386   }
65387   {
65388     try {
65389       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65390     } catch (std::out_of_range& e) {
65391       {
65392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65393       };
65394     } catch (std::exception& e) {
65395       {
65396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65397       };
65398     } catch (...) {
65399       {
65400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65401       };
65402     }
65403   }
65404   jresult = (void *)result;
65405   return jresult;
65406 }
65407
65408
65409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65410   void * jresult ;
65411   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65412   Dali::Toolkit::RadioButton *arg2 = 0 ;
65413   Dali::Toolkit::RadioButton *result = 0 ;
65414
65415   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65416   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65417   if (!arg2) {
65418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65419     return 0;
65420   }
65421   {
65422     try {
65423       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65424     } catch (std::out_of_range& e) {
65425       {
65426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65427       };
65428     } catch (std::exception& e) {
65429       {
65430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65431       };
65432     } catch (...) {
65433       {
65434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65435       };
65436     }
65437   }
65438   jresult = (void *)result;
65439   return jresult;
65440 }
65441
65442
65443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65444   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65445
65446   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65447   {
65448     try {
65449       delete arg1;
65450     } catch (std::out_of_range& e) {
65451       {
65452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65453       };
65454     } catch (std::exception& e) {
65455       {
65456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65457       };
65458     } catch (...) {
65459       {
65460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65461       };
65462     }
65463   }
65464 }
65465
65466
65467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65468   void * jresult ;
65469   Dali::Toolkit::RadioButton result;
65470
65471   {
65472     try {
65473       result = Dali::Toolkit::RadioButton::New();
65474     } catch (std::out_of_range& e) {
65475       {
65476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65477       };
65478     } catch (std::exception& e) {
65479       {
65480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65481       };
65482     } catch (...) {
65483       {
65484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65485       };
65486     }
65487   }
65488   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65489   return jresult;
65490 }
65491
65492
65493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65494   void * jresult ;
65495   std::string *arg1 = 0 ;
65496   Dali::Toolkit::RadioButton result;
65497
65498   if (!jarg1) {
65499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65500     return 0;
65501   }
65502   std::string arg1_str(jarg1);
65503   arg1 = &arg1_str;
65504   {
65505     try {
65506       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
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 = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65522
65523   //argout typemap for const std::string&
65524
65525   return jresult;
65526 }
65527
65528
65529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65530   void * jresult ;
65531   Dali::BaseHandle arg1 ;
65532   Dali::BaseHandle *argp1 ;
65533   Dali::Toolkit::RadioButton result;
65534
65535   argp1 = (Dali::BaseHandle *)jarg1;
65536   if (!argp1) {
65537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65538     return 0;
65539   }
65540   arg1 = *argp1;
65541   {
65542     try {
65543       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65544     } catch (std::out_of_range& e) {
65545       {
65546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65547       };
65548     } catch (std::exception& e) {
65549       {
65550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65551       };
65552     } catch (...) {
65553       {
65554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65555       };
65556     }
65557   }
65558   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65559   return jresult;
65560 }
65561
65562
65563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65564   int jresult ;
65565   int result;
65566
65567   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65568   jresult = (int)result;
65569   return jresult;
65570 }
65571
65572
65573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65574   int jresult ;
65575   int result;
65576
65577   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65578   jresult = (int)result;
65579   return jresult;
65580 }
65581
65582
65583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65584   int jresult ;
65585   int result;
65586
65587   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65588   jresult = (int)result;
65589   return jresult;
65590 }
65591
65592
65593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65594   int jresult ;
65595   int result;
65596
65597   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65598   jresult = (int)result;
65599   return jresult;
65600 }
65601
65602
65603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65604   int jresult ;
65605   int result;
65606
65607   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65608   jresult = (int)result;
65609   return jresult;
65610 }
65611
65612
65613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65614   int jresult ;
65615   int result;
65616
65617   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65618   jresult = (int)result;
65619   return jresult;
65620 }
65621
65622
65623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65624   void * jresult ;
65625   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65626
65627   {
65628     try {
65629       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
65630     } catch (std::out_of_range& e) {
65631       {
65632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65633       };
65634     } catch (std::exception& e) {
65635       {
65636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65637       };
65638     } catch (...) {
65639       {
65640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65641       };
65642     }
65643   }
65644   jresult = (void *)result;
65645   return jresult;
65646 }
65647
65648
65649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65650   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65651
65652   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
65653   {
65654     try {
65655       delete arg1;
65656     } catch (std::out_of_range& e) {
65657       {
65658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65659       };
65660     } catch (std::exception& e) {
65661       {
65662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65663       };
65664     } catch (...) {
65665       {
65666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65667       };
65668     }
65669   }
65670 }
65671
65672
65673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
65674   int jresult ;
65675   int result;
65676
65677   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
65678   jresult = (int)result;
65679   return jresult;
65680 }
65681
65682
65683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
65684   int jresult ;
65685   int result;
65686
65687   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
65688   jresult = (int)result;
65689   return jresult;
65690 }
65691
65692
65693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
65694   int jresult ;
65695   int result;
65696
65697   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
65698   jresult = (int)result;
65699   return jresult;
65700 }
65701
65702
65703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
65704   void * jresult ;
65705   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
65706
65707   {
65708     try {
65709       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
65710     } catch (std::out_of_range& e) {
65711       {
65712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65713       };
65714     } catch (std::exception& e) {
65715       {
65716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65717       };
65718     } catch (...) {
65719       {
65720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65721       };
65722     }
65723   }
65724   jresult = (void *)result;
65725   return jresult;
65726 }
65727
65728
65729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
65730   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
65731
65732   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
65733   {
65734     try {
65735       delete arg1;
65736     } catch (std::out_of_range& e) {
65737       {
65738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65739       };
65740     } catch (std::exception& e) {
65741       {
65742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65743       };
65744     } catch (...) {
65745       {
65746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65747       };
65748     }
65749   }
65750 }
65751
65752
65753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
65754   void * jresult ;
65755   Dali::Toolkit::FlexContainer *result = 0 ;
65756
65757   {
65758     try {
65759       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
65760     } catch (std::out_of_range& e) {
65761       {
65762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65763       };
65764     } catch (std::exception& e) {
65765       {
65766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65767       };
65768     } catch (...) {
65769       {
65770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65771       };
65772     }
65773   }
65774   jresult = (void *)result;
65775   return jresult;
65776 }
65777
65778
65779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
65780   void * jresult ;
65781   Dali::Toolkit::FlexContainer *arg1 = 0 ;
65782   Dali::Toolkit::FlexContainer *result = 0 ;
65783
65784   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65785   if (!arg1) {
65786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65787     return 0;
65788   }
65789   {
65790     try {
65791       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
65792     } catch (std::out_of_range& e) {
65793       {
65794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65795       };
65796     } catch (std::exception& e) {
65797       {
65798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65799       };
65800     } catch (...) {
65801       {
65802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65803       };
65804     }
65805   }
65806   jresult = (void *)result;
65807   return jresult;
65808 }
65809
65810
65811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
65812   void * jresult ;
65813   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65814   Dali::Toolkit::FlexContainer *arg2 = 0 ;
65815   Dali::Toolkit::FlexContainer *result = 0 ;
65816
65817   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65818   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
65819   if (!arg2) {
65820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65821     return 0;
65822   }
65823   {
65824     try {
65825       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
65826     } catch (std::out_of_range& e) {
65827       {
65828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65829       };
65830     } catch (std::exception& e) {
65831       {
65832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65833       };
65834     } catch (...) {
65835       {
65836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65837       };
65838     }
65839   }
65840   jresult = (void *)result;
65841   return jresult;
65842 }
65843
65844
65845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
65846   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65847
65848   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65849   {
65850     try {
65851       delete arg1;
65852     } catch (std::out_of_range& e) {
65853       {
65854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65855       };
65856     } catch (std::exception& e) {
65857       {
65858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65859       };
65860     } catch (...) {
65861       {
65862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65863       };
65864     }
65865   }
65866 }
65867
65868
65869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
65870   void * jresult ;
65871   Dali::Toolkit::FlexContainer result;
65872
65873   {
65874     try {
65875       result = Dali::Toolkit::FlexContainer::New();
65876     } catch (std::out_of_range& e) {
65877       {
65878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65879       };
65880     } catch (std::exception& e) {
65881       {
65882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65883       };
65884     } catch (...) {
65885       {
65886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65887       };
65888     }
65889   }
65890   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
65891   return jresult;
65892 }
65893
65894
65895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
65896   void * jresult ;
65897   Dali::BaseHandle arg1 ;
65898   Dali::BaseHandle *argp1 ;
65899   Dali::Toolkit::FlexContainer result;
65900
65901   argp1 = (Dali::BaseHandle *)jarg1;
65902   if (!argp1) {
65903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65904     return 0;
65905   }
65906   arg1 = *argp1;
65907   {
65908     try {
65909       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
65910     } catch (std::out_of_range& e) {
65911       {
65912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65913       };
65914     } catch (std::exception& e) {
65915       {
65916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65917       };
65918     } catch (...) {
65919       {
65920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65921       };
65922     }
65923   }
65924   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
65925   return jresult;
65926 }
65927
65928
65929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
65930   int jresult ;
65931   int result;
65932
65933   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
65934   jresult = (int)result;
65935   return jresult;
65936 }
65937
65938
65939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
65940   int jresult ;
65941   int result;
65942
65943   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
65944   jresult = (int)result;
65945   return jresult;
65946 }
65947
65948
65949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
65950   int jresult ;
65951   int result;
65952
65953   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
65954   jresult = (int)result;
65955   return jresult;
65956 }
65957
65958
65959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
65960   int jresult ;
65961   int result;
65962
65963   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
65964   jresult = (int)result;
65965   return jresult;
65966 }
65967
65968
65969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
65970   void * jresult ;
65971   Dali::Toolkit::ImageView::Property *result = 0 ;
65972
65973   {
65974     try {
65975       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
65976     } catch (std::out_of_range& e) {
65977       {
65978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65979       };
65980     } catch (std::exception& e) {
65981       {
65982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65983       };
65984     } catch (...) {
65985       {
65986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65987       };
65988     }
65989   }
65990   jresult = (void *)result;
65991   return jresult;
65992 }
65993
65994
65995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
65996   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
65997
65998   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
65999   {
66000     try {
66001       delete arg1;
66002     } catch (std::out_of_range& e) {
66003       {
66004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66005       };
66006     } catch (std::exception& e) {
66007       {
66008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66009       };
66010     } catch (...) {
66011       {
66012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66013       };
66014     }
66015   }
66016 }
66017
66018
66019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66020   void * jresult ;
66021   Dali::Toolkit::ImageView *result = 0 ;
66022
66023   {
66024     try {
66025       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66026     } catch (std::out_of_range& e) {
66027       {
66028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66029       };
66030     } catch (std::exception& e) {
66031       {
66032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66033       };
66034     } catch (...) {
66035       {
66036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66037       };
66038     }
66039   }
66040   jresult = (void *)result;
66041   return jresult;
66042 }
66043
66044
66045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66046   void * jresult ;
66047   Dali::Toolkit::ImageView result;
66048
66049   {
66050     try {
66051       result = Dali::Toolkit::ImageView::New();
66052     } catch (std::out_of_range& e) {
66053       {
66054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66055       };
66056     } catch (std::exception& e) {
66057       {
66058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66059       };
66060     } catch (...) {
66061       {
66062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66063       };
66064     }
66065   }
66066   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66067   return jresult;
66068 }
66069
66070
66071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
66072   void * jresult ;
66073   Dali::Image arg1 ;
66074   Dali::Image *argp1 ;
66075   Dali::Toolkit::ImageView result;
66076
66077   argp1 = (Dali::Image *)jarg1;
66078   if (!argp1) {
66079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66080     return 0;
66081   }
66082   arg1 = *argp1;
66083   {
66084     try {
66085       result = Dali::Toolkit::ImageView::New(arg1);
66086     } catch (std::out_of_range& e) {
66087       {
66088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66089       };
66090     } catch (std::exception& e) {
66091       {
66092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66093       };
66094     } catch (...) {
66095       {
66096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66097       };
66098     }
66099   }
66100   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66101   return jresult;
66102 }
66103
66104
66105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66106   void * jresult ;
66107   std::string *arg1 = 0 ;
66108   Dali::Toolkit::ImageView result;
66109
66110   if (!jarg1) {
66111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66112     return 0;
66113   }
66114   std::string arg1_str(jarg1);
66115   arg1 = &arg1_str;
66116   {
66117     try {
66118       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66119     } catch (std::out_of_range& e) {
66120       {
66121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66122       };
66123     } catch (std::exception& e) {
66124       {
66125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66126       };
66127     } catch (...) {
66128       {
66129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66130       };
66131     }
66132   }
66133   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66134
66135   //argout typemap for const std::string&
66136
66137   return jresult;
66138 }
66139
66140
66141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66142   void * jresult ;
66143   std::string *arg1 = 0 ;
66144   Dali::ImageDimensions arg2 ;
66145   Dali::ImageDimensions *argp2 ;
66146   Dali::Toolkit::ImageView result;
66147
66148   if (!jarg1) {
66149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66150     return 0;
66151   }
66152   std::string arg1_str(jarg1);
66153   arg1 = &arg1_str;
66154   argp2 = (Dali::ImageDimensions *)jarg2;
66155   if (!argp2) {
66156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66157     return 0;
66158   }
66159   arg2 = *argp2;
66160   {
66161     try {
66162       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66163     } catch (std::out_of_range& e) {
66164       {
66165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66166       };
66167     } catch (std::exception& e) {
66168       {
66169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66170       };
66171     } catch (...) {
66172       {
66173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66174       };
66175     }
66176   }
66177   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66178
66179   //argout typemap for const std::string&
66180
66181   return jresult;
66182 }
66183
66184
66185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66186   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66187
66188   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66189   {
66190     try {
66191       delete arg1;
66192     } catch (std::out_of_range& e) {
66193       {
66194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66195       };
66196     } catch (std::exception& e) {
66197       {
66198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66199       };
66200     } catch (...) {
66201       {
66202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66203       };
66204     }
66205   }
66206 }
66207
66208
66209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66210   void * jresult ;
66211   Dali::Toolkit::ImageView *arg1 = 0 ;
66212   Dali::Toolkit::ImageView *result = 0 ;
66213
66214   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66215   if (!arg1) {
66216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66217     return 0;
66218   }
66219   {
66220     try {
66221       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66222     } catch (std::out_of_range& e) {
66223       {
66224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66225       };
66226     } catch (std::exception& e) {
66227       {
66228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66229       };
66230     } catch (...) {
66231       {
66232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66233       };
66234     }
66235   }
66236   jresult = (void *)result;
66237   return jresult;
66238 }
66239
66240
66241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66242   void * jresult ;
66243   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66244   Dali::Toolkit::ImageView *arg2 = 0 ;
66245   Dali::Toolkit::ImageView *result = 0 ;
66246
66247   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66248   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66249   if (!arg2) {
66250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66251     return 0;
66252   }
66253   {
66254     try {
66255       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66256     } catch (std::out_of_range& e) {
66257       {
66258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66259       };
66260     } catch (std::exception& e) {
66261       {
66262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66263       };
66264     } catch (...) {
66265       {
66266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66267       };
66268     }
66269   }
66270   jresult = (void *)result;
66271   return jresult;
66272 }
66273
66274
66275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66276   void * jresult ;
66277   Dali::BaseHandle arg1 ;
66278   Dali::BaseHandle *argp1 ;
66279   Dali::Toolkit::ImageView result;
66280
66281   argp1 = (Dali::BaseHandle *)jarg1;
66282   if (!argp1) {
66283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66284     return 0;
66285   }
66286   arg1 = *argp1;
66287   {
66288     try {
66289       result = Dali::Toolkit::ImageView::DownCast(arg1);
66290     } catch (std::out_of_range& e) {
66291       {
66292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66293       };
66294     } catch (std::exception& e) {
66295       {
66296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66297       };
66298     } catch (...) {
66299       {
66300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66301       };
66302     }
66303   }
66304   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66305   return jresult;
66306 }
66307
66308
66309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
66310   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66311   Dali::Image arg2 ;
66312   Dali::Image *argp2 ;
66313
66314   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66315   argp2 = (Dali::Image *)jarg2;
66316   if (!argp2) {
66317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66318     return ;
66319   }
66320   arg2 = *argp2;
66321   {
66322     try {
66323       (arg1)->SetImage(arg2);
66324     } catch (std::out_of_range& e) {
66325       {
66326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66327       };
66328     } catch (std::exception& e) {
66329       {
66330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66331       };
66332     } catch (...) {
66333       {
66334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66335       };
66336     }
66337   }
66338 }
66339
66340
66341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66342   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66343   std::string *arg2 = 0 ;
66344
66345   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66346   if (!jarg2) {
66347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66348     return ;
66349   }
66350   std::string arg2_str(jarg2);
66351   arg2 = &arg2_str;
66352   {
66353     try {
66354       (arg1)->SetImage((std::string const &)*arg2);
66355     } catch (std::out_of_range& e) {
66356       {
66357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66358       };
66359     } catch (std::exception& e) {
66360       {
66361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66362       };
66363     } catch (...) {
66364       {
66365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66366       };
66367     }
66368   }
66369
66370   //argout typemap for const std::string&
66371
66372 }
66373
66374
66375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66376   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66377   std::string *arg2 = 0 ;
66378   Dali::ImageDimensions arg3 ;
66379   Dali::ImageDimensions *argp3 ;
66380
66381   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66382   if (!jarg2) {
66383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66384     return ;
66385   }
66386   std::string arg2_str(jarg2);
66387   arg2 = &arg2_str;
66388   argp3 = (Dali::ImageDimensions *)jarg3;
66389   if (!argp3) {
66390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66391     return ;
66392   }
66393   arg3 = *argp3;
66394   {
66395     try {
66396       (arg1)->SetImage((std::string const &)*arg2,arg3);
66397     } catch (std::out_of_range& e) {
66398       {
66399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66400       };
66401     } catch (std::exception& e) {
66402       {
66403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66404       };
66405     } catch (...) {
66406       {
66407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66408       };
66409     }
66410   }
66411
66412   //argout typemap for const std::string&
66413
66414 }
66415
66416
66417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
66418   void * jresult ;
66419   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66420   Dali::Image result;
66421
66422   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66423   {
66424     try {
66425       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
66426     } catch (std::out_of_range& e) {
66427       {
66428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66429       };
66430     } catch (std::exception& e) {
66431       {
66432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66433       };
66434     } catch (...) {
66435       {
66436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66437       };
66438     }
66439   }
66440   jresult = new Dali::Image((const Dali::Image &)result);
66441   return jresult;
66442 }
66443
66444
66445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66446   int jresult ;
66447   int result;
66448
66449   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66450   jresult = (int)result;
66451   return jresult;
66452 }
66453
66454
66455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66456   int jresult ;
66457   int result;
66458
66459   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66460   jresult = (int)result;
66461   return jresult;
66462 }
66463
66464
66465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66466   int jresult ;
66467   int result;
66468
66469   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66470   jresult = (int)result;
66471   return jresult;
66472 }
66473
66474
66475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66476   int jresult ;
66477   int result;
66478
66479   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66480   jresult = (int)result;
66481   return jresult;
66482 }
66483
66484
66485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66486   int jresult ;
66487   int result;
66488
66489   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66490   jresult = (int)result;
66491   return jresult;
66492 }
66493
66494
66495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66496   int jresult ;
66497   int result;
66498
66499   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66500   jresult = (int)result;
66501   return jresult;
66502 }
66503
66504
66505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66506   int jresult ;
66507   int result;
66508
66509   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66510   jresult = (int)result;
66511   return jresult;
66512 }
66513
66514
66515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66516   int jresult ;
66517   int result;
66518
66519   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66520   jresult = (int)result;
66521   return jresult;
66522 }
66523
66524
66525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66526   void * jresult ;
66527   Dali::Toolkit::Model3dView::Property *result = 0 ;
66528
66529   {
66530     try {
66531       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66532     } catch (std::out_of_range& e) {
66533       {
66534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66535       };
66536     } catch (std::exception& e) {
66537       {
66538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66539       };
66540     } catch (...) {
66541       {
66542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66543       };
66544     }
66545   }
66546   jresult = (void *)result;
66547   return jresult;
66548 }
66549
66550
66551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66552   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66553
66554   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66555   {
66556     try {
66557       delete arg1;
66558     } catch (std::out_of_range& e) {
66559       {
66560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66561       };
66562     } catch (std::exception& e) {
66563       {
66564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66565       };
66566     } catch (...) {
66567       {
66568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66569       };
66570     }
66571   }
66572 }
66573
66574
66575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66576   void * jresult ;
66577   Dali::Toolkit::Model3dView result;
66578
66579   {
66580     try {
66581       result = Dali::Toolkit::Model3dView::New();
66582     } catch (std::out_of_range& e) {
66583       {
66584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66585       };
66586     } catch (std::exception& e) {
66587       {
66588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66589       };
66590     } catch (...) {
66591       {
66592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66593       };
66594     }
66595   }
66596   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66597   return jresult;
66598 }
66599
66600
66601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66602   void * jresult ;
66603   std::string *arg1 = 0 ;
66604   std::string *arg2 = 0 ;
66605   std::string *arg3 = 0 ;
66606   Dali::Toolkit::Model3dView result;
66607
66608   if (!jarg1) {
66609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66610     return 0;
66611   }
66612   std::string arg1_str(jarg1);
66613   arg1 = &arg1_str;
66614   if (!jarg2) {
66615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66616     return 0;
66617   }
66618   std::string arg2_str(jarg2);
66619   arg2 = &arg2_str;
66620   if (!jarg3) {
66621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66622     return 0;
66623   }
66624   std::string arg3_str(jarg3);
66625   arg3 = &arg3_str;
66626   {
66627     try {
66628       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66629     } catch (std::out_of_range& e) {
66630       {
66631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66632       };
66633     } catch (std::exception& e) {
66634       {
66635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66636       };
66637     } catch (...) {
66638       {
66639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66640       };
66641     }
66642   }
66643   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66644
66645   //argout typemap for const std::string&
66646
66647
66648   //argout typemap for const std::string&
66649
66650
66651   //argout typemap for const std::string&
66652
66653   return jresult;
66654 }
66655
66656
66657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
66658   void * jresult ;
66659   Dali::Toolkit::Model3dView *result = 0 ;
66660
66661   {
66662     try {
66663       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
66664     } catch (std::out_of_range& e) {
66665       {
66666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66667       };
66668     } catch (std::exception& e) {
66669       {
66670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66671       };
66672     } catch (...) {
66673       {
66674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66675       };
66676     }
66677   }
66678   jresult = (void *)result;
66679   return jresult;
66680 }
66681
66682
66683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
66684   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66685
66686   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66687   {
66688     try {
66689       delete arg1;
66690     } catch (std::out_of_range& e) {
66691       {
66692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66693       };
66694     } catch (std::exception& e) {
66695       {
66696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66697       };
66698     } catch (...) {
66699       {
66700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66701       };
66702     }
66703   }
66704 }
66705
66706
66707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
66708   void * jresult ;
66709   Dali::Toolkit::Model3dView *arg1 = 0 ;
66710   Dali::Toolkit::Model3dView *result = 0 ;
66711
66712   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66713   if (!arg1) {
66714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66715     return 0;
66716   }
66717   {
66718     try {
66719       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
66720     } catch (std::out_of_range& e) {
66721       {
66722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66723       };
66724     } catch (std::exception& e) {
66725       {
66726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66727       };
66728     } catch (...) {
66729       {
66730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66731       };
66732     }
66733   }
66734   jresult = (void *)result;
66735   return jresult;
66736 }
66737
66738
66739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
66740   void * jresult ;
66741   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66742   Dali::Toolkit::Model3dView *arg2 = 0 ;
66743   Dali::Toolkit::Model3dView *result = 0 ;
66744
66745   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66746   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
66747   if (!arg2) {
66748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66749     return 0;
66750   }
66751   {
66752     try {
66753       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
66754     } catch (std::out_of_range& e) {
66755       {
66756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66757       };
66758     } catch (std::exception& e) {
66759       {
66760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66761       };
66762     } catch (...) {
66763       {
66764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66765       };
66766     }
66767   }
66768   jresult = (void *)result;
66769   return jresult;
66770 }
66771
66772
66773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
66774   void * jresult ;
66775   Dali::BaseHandle arg1 ;
66776   Dali::BaseHandle *argp1 ;
66777   Dali::Toolkit::Model3dView result;
66778
66779   argp1 = (Dali::BaseHandle *)jarg1;
66780   if (!argp1) {
66781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66782     return 0;
66783   }
66784   arg1 = *argp1;
66785   {
66786     try {
66787       result = Dali::Toolkit::Model3dView::DownCast(arg1);
66788     } catch (std::out_of_range& e) {
66789       {
66790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66791       };
66792     } catch (std::exception& e) {
66793       {
66794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66795       };
66796     } catch (...) {
66797       {
66798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66799       };
66800     }
66801   }
66802   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66803   return jresult;
66804 }
66805
66806
66807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
66808   int jresult ;
66809   int result;
66810
66811   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
66812   jresult = (int)result;
66813   return jresult;
66814 }
66815
66816
66817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
66818   int jresult ;
66819   int result;
66820
66821   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
66822   jresult = (int)result;
66823   return jresult;
66824 }
66825
66826
66827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
66828   int jresult ;
66829   int result;
66830
66831   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
66832   jresult = (int)result;
66833   return jresult;
66834 }
66835
66836
66837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
66838   int jresult ;
66839   int result;
66840
66841   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
66842   jresult = (int)result;
66843   return jresult;
66844 }
66845
66846
66847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
66848   int jresult ;
66849   int result;
66850
66851   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
66852   jresult = (int)result;
66853   return jresult;
66854 }
66855
66856
66857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
66858   int jresult ;
66859   int result;
66860
66861   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
66862   jresult = (int)result;
66863   return jresult;
66864 }
66865
66866
66867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
66868   int jresult ;
66869   int result;
66870
66871   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
66872   jresult = (int)result;
66873   return jresult;
66874 }
66875
66876
66877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
66878   int jresult ;
66879   int result;
66880
66881   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
66882   jresult = (int)result;
66883   return jresult;
66884 }
66885
66886
66887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
66888   int jresult ;
66889   int result;
66890
66891   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
66892   jresult = (int)result;
66893   return jresult;
66894 }
66895
66896
66897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
66898   void * jresult ;
66899   Dali::Toolkit::ScrollBar::Property *result = 0 ;
66900
66901   {
66902     try {
66903       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
66904     } catch (std::out_of_range& e) {
66905       {
66906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66907       };
66908     } catch (std::exception& e) {
66909       {
66910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66911       };
66912     } catch (...) {
66913       {
66914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66915       };
66916     }
66917   }
66918   jresult = (void *)result;
66919   return jresult;
66920 }
66921
66922
66923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
66924   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
66925
66926   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
66927   {
66928     try {
66929       delete arg1;
66930     } catch (std::out_of_range& e) {
66931       {
66932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66933       };
66934     } catch (std::exception& e) {
66935       {
66936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66937       };
66938     } catch (...) {
66939       {
66940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66941       };
66942     }
66943   }
66944 }
66945
66946
66947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
66948   void * jresult ;
66949   Dali::Toolkit::ScrollBar *result = 0 ;
66950
66951   {
66952     try {
66953       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
66954     } catch (std::out_of_range& e) {
66955       {
66956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66957       };
66958     } catch (std::exception& e) {
66959       {
66960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66961       };
66962     } catch (...) {
66963       {
66964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66965       };
66966     }
66967   }
66968   jresult = (void *)result;
66969   return jresult;
66970 }
66971
66972
66973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
66974   void * jresult ;
66975   Dali::Toolkit::ScrollBar *arg1 = 0 ;
66976   Dali::Toolkit::ScrollBar *result = 0 ;
66977
66978   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66979   if (!arg1) {
66980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
66981     return 0;
66982   }
66983   {
66984     try {
66985       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
66986     } catch (std::out_of_range& e) {
66987       {
66988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66989       };
66990     } catch (std::exception& e) {
66991       {
66992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66993       };
66994     } catch (...) {
66995       {
66996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66997       };
66998     }
66999   }
67000   jresult = (void *)result;
67001   return jresult;
67002 }
67003
67004
67005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67006   void * jresult ;
67007   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67008   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67009   Dali::Toolkit::ScrollBar *result = 0 ;
67010
67011   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67012   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67013   if (!arg2) {
67014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67015     return 0;
67016   }
67017   {
67018     try {
67019       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67020     } catch (std::out_of_range& e) {
67021       {
67022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67023       };
67024     } catch (std::exception& e) {
67025       {
67026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67027       };
67028     } catch (...) {
67029       {
67030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67031       };
67032     }
67033   }
67034   jresult = (void *)result;
67035   return jresult;
67036 }
67037
67038
67039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67040   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67041
67042   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67043   {
67044     try {
67045       delete arg1;
67046     } catch (std::out_of_range& e) {
67047       {
67048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67049       };
67050     } catch (std::exception& e) {
67051       {
67052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67053       };
67054     } catch (...) {
67055       {
67056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67057       };
67058     }
67059   }
67060 }
67061
67062
67063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67064   void * jresult ;
67065   Dali::Toolkit::ScrollBar::Direction arg1 ;
67066   Dali::Toolkit::ScrollBar result;
67067
67068   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67069   {
67070     try {
67071       result = Dali::Toolkit::ScrollBar::New(arg1);
67072     } catch (std::out_of_range& e) {
67073       {
67074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67075       };
67076     } catch (std::exception& e) {
67077       {
67078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67079       };
67080     } catch (...) {
67081       {
67082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67083       };
67084     }
67085   }
67086   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67087   return jresult;
67088 }
67089
67090
67091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67092   void * jresult ;
67093   Dali::Toolkit::ScrollBar result;
67094
67095   {
67096     try {
67097       result = Dali::Toolkit::ScrollBar::New();
67098     } catch (std::out_of_range& e) {
67099       {
67100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67101       };
67102     } catch (std::exception& e) {
67103       {
67104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67105       };
67106     } catch (...) {
67107       {
67108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67109       };
67110     }
67111   }
67112   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67113   return jresult;
67114 }
67115
67116
67117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67118   void * jresult ;
67119   Dali::BaseHandle arg1 ;
67120   Dali::BaseHandle *argp1 ;
67121   Dali::Toolkit::ScrollBar result;
67122
67123   argp1 = (Dali::BaseHandle *)jarg1;
67124   if (!argp1) {
67125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67126     return 0;
67127   }
67128   arg1 = *argp1;
67129   {
67130     try {
67131       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67132     } catch (std::out_of_range& e) {
67133       {
67134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67135       };
67136     } catch (std::exception& e) {
67137       {
67138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67139       };
67140     } catch (...) {
67141       {
67142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67143       };
67144     }
67145   }
67146   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67147   return jresult;
67148 }
67149
67150
67151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67152   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67153   Dali::Handle arg2 ;
67154   Dali::Property::Index arg3 ;
67155   Dali::Property::Index arg4 ;
67156   Dali::Property::Index arg5 ;
67157   Dali::Property::Index arg6 ;
67158   Dali::Handle *argp2 ;
67159
67160   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67161   argp2 = (Dali::Handle *)jarg2;
67162   if (!argp2) {
67163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67164     return ;
67165   }
67166   arg2 = *argp2;
67167   arg3 = (Dali::Property::Index)jarg3;
67168   arg4 = (Dali::Property::Index)jarg4;
67169   arg5 = (Dali::Property::Index)jarg5;
67170   arg6 = (Dali::Property::Index)jarg6;
67171   {
67172     try {
67173       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67174     } catch (std::out_of_range& e) {
67175       {
67176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67177       };
67178     } catch (std::exception& e) {
67179       {
67180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67181       };
67182     } catch (...) {
67183       {
67184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67185       };
67186     }
67187   }
67188 }
67189
67190
67191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67192   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67193   Dali::Actor arg2 ;
67194   Dali::Actor *argp2 ;
67195
67196   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67197   argp2 = (Dali::Actor *)jarg2;
67198   if (!argp2) {
67199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67200     return ;
67201   }
67202   arg2 = *argp2;
67203   {
67204     try {
67205       (arg1)->SetScrollIndicator(arg2);
67206     } catch (std::out_of_range& e) {
67207       {
67208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67209       };
67210     } catch (std::exception& e) {
67211       {
67212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67213       };
67214     } catch (...) {
67215       {
67216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67217       };
67218     }
67219   }
67220 }
67221
67222
67223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67224   void * jresult ;
67225   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67226   Dali::Actor result;
67227
67228   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67229   {
67230     try {
67231       result = (arg1)->GetScrollIndicator();
67232     } catch (std::out_of_range& e) {
67233       {
67234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67235       };
67236     } catch (std::exception& e) {
67237       {
67238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67239       };
67240     } catch (...) {
67241       {
67242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67243       };
67244     }
67245   }
67246   jresult = new Dali::Actor((const Dali::Actor &)result);
67247   return jresult;
67248 }
67249
67250
67251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67252   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67253   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67254
67255   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67256   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67257   if (!arg2) {
67258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67259     return ;
67260   }
67261   {
67262     try {
67263       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67264     } catch (std::out_of_range& e) {
67265       {
67266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67267       };
67268     } catch (std::exception& e) {
67269       {
67270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67271       };
67272     } catch (...) {
67273       {
67274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67275       };
67276     }
67277   }
67278 }
67279
67280
67281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67282   void * jresult ;
67283   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67284   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
67285
67286   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67287   {
67288     try {
67289       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
67290     } catch (std::out_of_range& e) {
67291       {
67292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67293       };
67294     } catch (std::exception& e) {
67295       {
67296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67297       };
67298     } catch (...) {
67299       {
67300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67301       };
67302     }
67303   }
67304   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
67305   return jresult;
67306 }
67307
67308
67309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67310   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67311   Dali::Toolkit::ScrollBar::Direction arg2 ;
67312
67313   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67314   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67315   {
67316     try {
67317       (arg1)->SetScrollDirection(arg2);
67318     } catch (std::out_of_range& e) {
67319       {
67320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67321       };
67322     } catch (std::exception& e) {
67323       {
67324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67325       };
67326     } catch (...) {
67327       {
67328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67329       };
67330     }
67331   }
67332 }
67333
67334
67335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67336   int jresult ;
67337   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67338   Dali::Toolkit::ScrollBar::Direction result;
67339
67340   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67341   {
67342     try {
67343       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67344     } catch (std::out_of_range& e) {
67345       {
67346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67347       };
67348     } catch (std::exception& e) {
67349       {
67350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67351       };
67352     } catch (...) {
67353       {
67354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67355       };
67356     }
67357   }
67358   jresult = (int)result;
67359   return jresult;
67360 }
67361
67362
67363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67364   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67365   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67366
67367   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67368   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67369   {
67370     try {
67371       (arg1)->SetIndicatorHeightPolicy(arg2);
67372     } catch (std::out_of_range& e) {
67373       {
67374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67375       };
67376     } catch (std::exception& e) {
67377       {
67378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67379       };
67380     } catch (...) {
67381       {
67382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67383       };
67384     }
67385   }
67386 }
67387
67388
67389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67390   int jresult ;
67391   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67392   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67393
67394   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67395   {
67396     try {
67397       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
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 = (int)result;
67413   return jresult;
67414 }
67415
67416
67417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67418   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67419   float arg2 ;
67420
67421   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67422   arg2 = (float)jarg2;
67423   {
67424     try {
67425       (arg1)->SetIndicatorFixedHeight(arg2);
67426     } catch (std::out_of_range& e) {
67427       {
67428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67429       };
67430     } catch (std::exception& e) {
67431       {
67432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67433       };
67434     } catch (...) {
67435       {
67436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67437       };
67438     }
67439   }
67440 }
67441
67442
67443 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67444   float jresult ;
67445   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67446   float result;
67447
67448   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67449   {
67450     try {
67451       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67452     } catch (std::out_of_range& e) {
67453       {
67454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67455       };
67456     } catch (std::exception& e) {
67457       {
67458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67459       };
67460     } catch (...) {
67461       {
67462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67463       };
67464     }
67465   }
67466   jresult = result;
67467   return jresult;
67468 }
67469
67470
67471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67472   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67473   float arg2 ;
67474
67475   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67476   arg2 = (float)jarg2;
67477   {
67478     try {
67479       (arg1)->SetIndicatorShowDuration(arg2);
67480     } catch (std::out_of_range& e) {
67481       {
67482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67483       };
67484     } catch (std::exception& e) {
67485       {
67486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67487       };
67488     } catch (...) {
67489       {
67490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67491       };
67492     }
67493   }
67494 }
67495
67496
67497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67498   float jresult ;
67499   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67500   float result;
67501
67502   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67503   {
67504     try {
67505       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67506     } catch (std::out_of_range& e) {
67507       {
67508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67509       };
67510     } catch (std::exception& e) {
67511       {
67512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67513       };
67514     } catch (...) {
67515       {
67516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67517       };
67518     }
67519   }
67520   jresult = result;
67521   return jresult;
67522 }
67523
67524
67525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
67526   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67527   float arg2 ;
67528
67529   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67530   arg2 = (float)jarg2;
67531   {
67532     try {
67533       (arg1)->SetIndicatorHideDuration(arg2);
67534     } catch (std::out_of_range& e) {
67535       {
67536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67537       };
67538     } catch (std::exception& e) {
67539       {
67540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67541       };
67542     } catch (...) {
67543       {
67544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67545       };
67546     }
67547   }
67548 }
67549
67550
67551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
67552   float jresult ;
67553   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67554   float result;
67555
67556   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67557   {
67558     try {
67559       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
67560     } catch (std::out_of_range& e) {
67561       {
67562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67563       };
67564     } catch (std::exception& e) {
67565       {
67566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67567       };
67568     } catch (...) {
67569       {
67570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67571       };
67572     }
67573   }
67574   jresult = result;
67575   return jresult;
67576 }
67577
67578
67579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
67580   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67581
67582   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67583   {
67584     try {
67585       (arg1)->ShowIndicator();
67586     } catch (std::out_of_range& e) {
67587       {
67588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67589       };
67590     } catch (std::exception& e) {
67591       {
67592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67593       };
67594     } catch (...) {
67595       {
67596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67597       };
67598     }
67599   }
67600 }
67601
67602
67603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
67604   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67605
67606   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67607   {
67608     try {
67609       (arg1)->HideIndicator();
67610     } catch (std::out_of_range& e) {
67611       {
67612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67613       };
67614     } catch (std::exception& e) {
67615       {
67616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67617       };
67618     } catch (...) {
67619       {
67620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67621       };
67622     }
67623   }
67624 }
67625
67626
67627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
67628   void * jresult ;
67629   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67630   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
67631
67632   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67633   {
67634     try {
67635       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
67636     } catch (std::out_of_range& e) {
67637       {
67638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67639       };
67640     } catch (std::exception& e) {
67641       {
67642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67643       };
67644     } catch (...) {
67645       {
67646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67647       };
67648     }
67649   }
67650   jresult = (void *)result;
67651   return jresult;
67652 }
67653
67654
67655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
67656   void * jresult ;
67657   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67658   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
67659
67660   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67661   {
67662     try {
67663       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
67664     } catch (std::out_of_range& e) {
67665       {
67666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67667       };
67668     } catch (std::exception& e) {
67669       {
67670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67671       };
67672     } catch (...) {
67673       {
67674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67675       };
67676     }
67677   }
67678   jresult = (void *)result;
67679   return jresult;
67680 }
67681
67682
67683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
67684   int jresult ;
67685   int result;
67686
67687   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
67688   jresult = (int)result;
67689   return jresult;
67690 }
67691
67692
67693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
67694   int jresult ;
67695   int result;
67696
67697   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
67698   jresult = (int)result;
67699   return jresult;
67700 }
67701
67702
67703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
67704   int jresult ;
67705   int result;
67706
67707   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
67708   jresult = (int)result;
67709   return jresult;
67710 }
67711
67712
67713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
67714   int jresult ;
67715   int result;
67716
67717   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
67718   jresult = (int)result;
67719   return jresult;
67720 }
67721
67722
67723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
67724   int jresult ;
67725   int result;
67726
67727   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
67728   jresult = (int)result;
67729   return jresult;
67730 }
67731
67732
67733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
67734   int jresult ;
67735   int result;
67736
67737   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
67738   jresult = (int)result;
67739   return jresult;
67740 }
67741
67742
67743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
67744   int jresult ;
67745   int result;
67746
67747   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
67748   jresult = (int)result;
67749   return jresult;
67750 }
67751
67752
67753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
67754   int jresult ;
67755   int result;
67756
67757   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
67758   jresult = (int)result;
67759   return jresult;
67760 }
67761
67762
67763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
67764   int jresult ;
67765   int result;
67766
67767   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
67768   jresult = (int)result;
67769   return jresult;
67770 }
67771
67772
67773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
67774   int jresult ;
67775   int result;
67776
67777   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
67778   jresult = (int)result;
67779   return jresult;
67780 }
67781
67782
67783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
67784   int jresult ;
67785   int result;
67786
67787   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
67788   jresult = (int)result;
67789   return jresult;
67790 }
67791
67792
67793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
67794   int jresult ;
67795   int result;
67796
67797   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
67798   jresult = (int)result;
67799   return jresult;
67800 }
67801
67802
67803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
67804   int jresult ;
67805   int result;
67806
67807   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
67808   jresult = (int)result;
67809   return jresult;
67810 }
67811
67812
67813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
67814   int jresult ;
67815   int result;
67816
67817   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
67818   jresult = (int)result;
67819   return jresult;
67820 }
67821
67822
67823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
67824   void * jresult ;
67825   Dali::Toolkit::Scrollable::Property *result = 0 ;
67826
67827   {
67828     try {
67829       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
67830     } catch (std::out_of_range& e) {
67831       {
67832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67833       };
67834     } catch (std::exception& e) {
67835       {
67836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67837       };
67838     } catch (...) {
67839       {
67840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67841       };
67842     }
67843   }
67844   jresult = (void *)result;
67845   return jresult;
67846 }
67847
67848
67849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
67850   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
67851
67852   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
67853   {
67854     try {
67855       delete arg1;
67856     } catch (std::out_of_range& e) {
67857       {
67858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67859       };
67860     } catch (std::exception& e) {
67861       {
67862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67863       };
67864     } catch (...) {
67865       {
67866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67867       };
67868     }
67869   }
67870 }
67871
67872
67873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
67874   void * jresult ;
67875   Dali::Toolkit::Scrollable *result = 0 ;
67876
67877   {
67878     try {
67879       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
67880     } catch (std::out_of_range& e) {
67881       {
67882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67883       };
67884     } catch (std::exception& e) {
67885       {
67886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67887       };
67888     } catch (...) {
67889       {
67890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67891       };
67892     }
67893   }
67894   jresult = (void *)result;
67895   return jresult;
67896 }
67897
67898
67899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
67900   void * jresult ;
67901   Dali::Toolkit::Scrollable *arg1 = 0 ;
67902   Dali::Toolkit::Scrollable *result = 0 ;
67903
67904   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67905   if (!arg1) {
67906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
67907     return 0;
67908   }
67909   {
67910     try {
67911       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
67912     } catch (std::out_of_range& e) {
67913       {
67914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67915       };
67916     } catch (std::exception& e) {
67917       {
67918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67919       };
67920     } catch (...) {
67921       {
67922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67923       };
67924     }
67925   }
67926   jresult = (void *)result;
67927   return jresult;
67928 }
67929
67930
67931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
67932   void * jresult ;
67933   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67934   Dali::Toolkit::Scrollable *arg2 = 0 ;
67935   Dali::Toolkit::Scrollable *result = 0 ;
67936
67937   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67938   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
67939   if (!arg2) {
67940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
67941     return 0;
67942   }
67943   {
67944     try {
67945       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
67946     } catch (std::out_of_range& e) {
67947       {
67948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67949       };
67950     } catch (std::exception& e) {
67951       {
67952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67953       };
67954     } catch (...) {
67955       {
67956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67957       };
67958     }
67959   }
67960   jresult = (void *)result;
67961   return jresult;
67962 }
67963
67964
67965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
67966   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67967
67968   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67969   {
67970     try {
67971       delete arg1;
67972     } catch (std::out_of_range& e) {
67973       {
67974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67975       };
67976     } catch (std::exception& e) {
67977       {
67978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67979       };
67980     } catch (...) {
67981       {
67982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67983       };
67984     }
67985   }
67986 }
67987
67988
67989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
67990   void * jresult ;
67991   Dali::BaseHandle arg1 ;
67992   Dali::BaseHandle *argp1 ;
67993   Dali::Toolkit::Scrollable result;
67994
67995   argp1 = (Dali::BaseHandle *)jarg1;
67996   if (!argp1) {
67997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67998     return 0;
67999   }
68000   arg1 = *argp1;
68001   {
68002     try {
68003       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68004     } catch (std::out_of_range& e) {
68005       {
68006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68007       };
68008     } catch (std::exception& e) {
68009       {
68010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68011       };
68012     } catch (...) {
68013       {
68014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68015       };
68016     }
68017   }
68018   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68019   return jresult;
68020 }
68021
68022
68023 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68024   unsigned int jresult ;
68025   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68026   bool result;
68027
68028   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68029   {
68030     try {
68031       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68032     } catch (std::out_of_range& e) {
68033       {
68034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68035       };
68036     } catch (std::exception& e) {
68037       {
68038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68039       };
68040     } catch (...) {
68041       {
68042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68043       };
68044     }
68045   }
68046   jresult = result;
68047   return jresult;
68048 }
68049
68050
68051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68052   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68053   bool arg2 ;
68054
68055   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68056   arg2 = jarg2 ? true : false;
68057   {
68058     try {
68059       (arg1)->SetOvershootEnabled(arg2);
68060     } catch (std::out_of_range& e) {
68061       {
68062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68063       };
68064     } catch (std::exception& e) {
68065       {
68066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68067       };
68068     } catch (...) {
68069       {
68070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68071       };
68072     }
68073   }
68074 }
68075
68076
68077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68078   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68079   Dali::Vector4 *arg2 = 0 ;
68080
68081   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68082   arg2 = (Dali::Vector4 *)jarg2;
68083   if (!arg2) {
68084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68085     return ;
68086   }
68087   {
68088     try {
68089       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68090     } catch (std::out_of_range& e) {
68091       {
68092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68093       };
68094     } catch (std::exception& e) {
68095       {
68096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68097       };
68098     } catch (...) {
68099       {
68100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68101       };
68102     }
68103   }
68104 }
68105
68106
68107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68108   void * jresult ;
68109   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68110   Dali::Vector4 result;
68111
68112   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68113   {
68114     try {
68115       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68116     } catch (std::out_of_range& e) {
68117       {
68118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68119       };
68120     } catch (std::exception& e) {
68121       {
68122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68123       };
68124     } catch (...) {
68125       {
68126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68127       };
68128     }
68129   }
68130   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68131   return jresult;
68132 }
68133
68134
68135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68136   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68137   float arg2 ;
68138
68139   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68140   arg2 = (float)jarg2;
68141   {
68142     try {
68143       (arg1)->SetOvershootAnimationSpeed(arg2);
68144     } catch (std::out_of_range& e) {
68145       {
68146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68147       };
68148     } catch (std::exception& e) {
68149       {
68150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68151       };
68152     } catch (...) {
68153       {
68154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68155       };
68156     }
68157   }
68158 }
68159
68160
68161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68162   float jresult ;
68163   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68164   float result;
68165
68166   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68167   {
68168     try {
68169       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68170     } catch (std::out_of_range& e) {
68171       {
68172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68173       };
68174     } catch (std::exception& e) {
68175       {
68176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68177       };
68178     } catch (...) {
68179       {
68180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68181       };
68182     }
68183   }
68184   jresult = result;
68185   return jresult;
68186 }
68187
68188
68189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68190   void * jresult ;
68191   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68192   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68193
68194   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68195   {
68196     try {
68197       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68198     } catch (std::out_of_range& e) {
68199       {
68200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68201       };
68202     } catch (std::exception& e) {
68203       {
68204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68205       };
68206     } catch (...) {
68207       {
68208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68209       };
68210     }
68211   }
68212   jresult = (void *)result;
68213   return jresult;
68214 }
68215
68216
68217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68218   void * jresult ;
68219   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68220   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68221
68222   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68223   {
68224     try {
68225       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68226     } catch (std::out_of_range& e) {
68227       {
68228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68229       };
68230     } catch (std::exception& e) {
68231       {
68232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68233       };
68234     } catch (...) {
68235       {
68236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68237       };
68238     }
68239   }
68240   jresult = (void *)result;
68241   return jresult;
68242 }
68243
68244
68245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68246   void * jresult ;
68247   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68248   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68249
68250   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68251   {
68252     try {
68253       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68254     } catch (std::out_of_range& e) {
68255       {
68256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68257       };
68258     } catch (std::exception& e) {
68259       {
68260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68261       };
68262     } catch (...) {
68263       {
68264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68265       };
68266     }
68267   }
68268   jresult = (void *)result;
68269   return jresult;
68270 }
68271
68272
68273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68274   unsigned int jresult ;
68275   Dali::Toolkit::ControlOrientation::Type arg1 ;
68276   bool result;
68277
68278   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68279   {
68280     try {
68281       result = (bool)Dali::Toolkit::IsVertical(arg1);
68282     } catch (std::out_of_range& e) {
68283       {
68284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68285       };
68286     } catch (std::exception& e) {
68287       {
68288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68289       };
68290     } catch (...) {
68291       {
68292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68293       };
68294     }
68295   }
68296   jresult = result;
68297   return jresult;
68298 }
68299
68300
68301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68302   unsigned int jresult ;
68303   Dali::Toolkit::ControlOrientation::Type arg1 ;
68304   bool result;
68305
68306   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68307   {
68308     try {
68309       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68310     } catch (std::out_of_range& e) {
68311       {
68312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68313       };
68314     } catch (std::exception& e) {
68315       {
68316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68317       };
68318     } catch (...) {
68319       {
68320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68321       };
68322     }
68323   }
68324   jresult = result;
68325   return jresult;
68326 }
68327
68328
68329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68330   void * jresult ;
68331   unsigned int arg1 ;
68332   unsigned int arg2 ;
68333   Dali::Toolkit::ItemRange *result = 0 ;
68334
68335   arg1 = (unsigned int)jarg1;
68336   arg2 = (unsigned int)jarg2;
68337   {
68338     try {
68339       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68340     } catch (std::out_of_range& e) {
68341       {
68342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68343       };
68344     } catch (std::exception& e) {
68345       {
68346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68347       };
68348     } catch (...) {
68349       {
68350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68351       };
68352     }
68353   }
68354   jresult = (void *)result;
68355   return jresult;
68356 }
68357
68358
68359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68360   void * jresult ;
68361   Dali::Toolkit::ItemRange *arg1 = 0 ;
68362   Dali::Toolkit::ItemRange *result = 0 ;
68363
68364   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68365   if (!arg1) {
68366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68367     return 0;
68368   }
68369   {
68370     try {
68371       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68372     } catch (std::out_of_range& e) {
68373       {
68374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68375       };
68376     } catch (std::exception& e) {
68377       {
68378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68379       };
68380     } catch (...) {
68381       {
68382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68383       };
68384     }
68385   }
68386   jresult = (void *)result;
68387   return jresult;
68388 }
68389
68390
68391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
68392   void * jresult ;
68393   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68394   Dali::Toolkit::ItemRange *arg2 = 0 ;
68395   Dali::Toolkit::ItemRange *result = 0 ;
68396
68397   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68398   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68399   if (!arg2) {
68400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68401     return 0;
68402   }
68403   {
68404     try {
68405       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
68406     } catch (std::out_of_range& e) {
68407       {
68408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68409       };
68410     } catch (std::exception& e) {
68411       {
68412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68413       };
68414     } catch (...) {
68415       {
68416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68417       };
68418     }
68419   }
68420   jresult = (void *)result;
68421   return jresult;
68422 }
68423
68424
68425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
68426   unsigned int jresult ;
68427   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68428   unsigned int arg2 ;
68429   bool result;
68430
68431   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68432   arg2 = (unsigned int)jarg2;
68433   {
68434     try {
68435       result = (bool)(arg1)->Within(arg2);
68436     } catch (std::out_of_range& e) {
68437       {
68438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68439       };
68440     } catch (std::exception& e) {
68441       {
68442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68443       };
68444     } catch (...) {
68445       {
68446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68447       };
68448     }
68449   }
68450   jresult = result;
68451   return jresult;
68452 }
68453
68454
68455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
68456   void * jresult ;
68457   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68458   Dali::Toolkit::ItemRange *arg2 = 0 ;
68459   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68460
68461   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68462   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68463   if (!arg2) {
68464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68465     return 0;
68466   }
68467   {
68468     try {
68469       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
68470     } catch (std::out_of_range& e) {
68471       {
68472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68473       };
68474     } catch (std::exception& e) {
68475       {
68476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68477       };
68478     } catch (...) {
68479       {
68480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68481       };
68482     }
68483   }
68484   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68485   return jresult;
68486 }
68487
68488
68489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
68490   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68491   unsigned int arg2 ;
68492
68493   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68494   arg2 = (unsigned int)jarg2;
68495   if (arg1) (arg1)->begin = arg2;
68496 }
68497
68498
68499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
68500   unsigned int jresult ;
68501   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68502   unsigned int result;
68503
68504   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68505   result = (unsigned int) ((arg1)->begin);
68506   jresult = result;
68507   return jresult;
68508 }
68509
68510
68511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
68512   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68513   unsigned int arg2 ;
68514
68515   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68516   arg2 = (unsigned int)jarg2;
68517   if (arg1) (arg1)->end = arg2;
68518 }
68519
68520
68521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
68522   unsigned int jresult ;
68523   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68524   unsigned int result;
68525
68526   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68527   result = (unsigned int) ((arg1)->end);
68528   jresult = result;
68529   return jresult;
68530 }
68531
68532
68533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
68534   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68535
68536   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68537   {
68538     try {
68539       delete arg1;
68540     } catch (std::out_of_range& e) {
68541       {
68542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68543       };
68544     } catch (std::exception& e) {
68545       {
68546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68547       };
68548     } catch (...) {
68549       {
68550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68551       };
68552     }
68553   }
68554 }
68555
68556
68557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
68558   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68559
68560   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68561   {
68562     try {
68563       delete arg1;
68564     } catch (std::out_of_range& e) {
68565       {
68566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68567       };
68568     } catch (std::exception& e) {
68569       {
68570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68571       };
68572     } catch (...) {
68573       {
68574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68575       };
68576     }
68577   }
68578 }
68579
68580
68581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
68582   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68583   Dali::Toolkit::ControlOrientation::Type arg2 ;
68584
68585   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68586   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
68587   {
68588     try {
68589       (arg1)->SetOrientation(arg2);
68590     } catch (std::out_of_range& e) {
68591       {
68592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68593       };
68594     } catch (std::exception& e) {
68595       {
68596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68597       };
68598     } catch (...) {
68599       {
68600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68601       };
68602     }
68603   }
68604 }
68605
68606
68607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
68608   int jresult ;
68609   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68610   Dali::Toolkit::ControlOrientation::Type result;
68611
68612   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68613   {
68614     try {
68615       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
68616     } catch (std::out_of_range& e) {
68617       {
68618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68619       };
68620     } catch (std::exception& e) {
68621       {
68622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68623       };
68624     } catch (...) {
68625       {
68626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68627       };
68628     }
68629   }
68630   jresult = (int)result;
68631   return jresult;
68632 }
68633
68634
68635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
68636   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68637   Dali::Property::Map *arg2 = 0 ;
68638
68639   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68640   arg2 = (Dali::Property::Map *)jarg2;
68641   if (!arg2) {
68642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
68643     return ;
68644   }
68645   {
68646     try {
68647       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
68648     } catch (std::out_of_range& e) {
68649       {
68650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68651       };
68652     } catch (std::exception& e) {
68653       {
68654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68655       };
68656     } catch (...) {
68657       {
68658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68659       };
68660     }
68661   }
68662 }
68663
68664
68665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
68666   void * jresult ;
68667   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68668   Dali::Property::Map result;
68669
68670   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68671   {
68672     try {
68673       result = (arg1)->GetLayoutProperties();
68674     } catch (std::out_of_range& e) {
68675       {
68676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68677       };
68678     } catch (std::exception& e) {
68679       {
68680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68681       };
68682     } catch (...) {
68683       {
68684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68685       };
68686     }
68687   }
68688   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
68689   return jresult;
68690 }
68691
68692
68693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68694   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68695   unsigned int arg2 ;
68696   Dali::Vector3 *arg3 = 0 ;
68697   Dali::Vector3 *arg4 = 0 ;
68698
68699   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68700   arg2 = (unsigned int)jarg2;
68701   arg3 = (Dali::Vector3 *)jarg3;
68702   if (!arg3) {
68703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68704     return ;
68705   }
68706   arg4 = (Dali::Vector3 *)jarg4;
68707   if (!arg4) {
68708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68709     return ;
68710   }
68711   {
68712     try {
68713       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68714     } catch (std::out_of_range& e) {
68715       {
68716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68717       };
68718     } catch (std::exception& e) {
68719       {
68720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68721       };
68722     } catch (...) {
68723       {
68724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68725       };
68726     }
68727   }
68728 }
68729
68730
68731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
68732   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68733   Dali::Vector3 *arg2 = 0 ;
68734
68735   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68736   arg2 = (Dali::Vector3 *)jarg2;
68737   if (!arg2) {
68738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68739     return ;
68740   }
68741   {
68742     try {
68743       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
68744     } catch (std::out_of_range& e) {
68745       {
68746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68747       };
68748     } catch (std::exception& e) {
68749       {
68750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68751       };
68752     } catch (...) {
68753       {
68754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68755       };
68756     }
68757   }
68758 }
68759
68760
68761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
68762   float jresult ;
68763   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68764   unsigned int arg2 ;
68765   Dali::Vector3 arg3 ;
68766   Dali::Vector3 *argp3 ;
68767   float result;
68768
68769   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68770   arg2 = (unsigned int)jarg2;
68771   argp3 = (Dali::Vector3 *)jarg3;
68772   if (!argp3) {
68773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68774     return 0;
68775   }
68776   arg3 = *argp3;
68777   {
68778     try {
68779       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
68780     } catch (std::out_of_range& e) {
68781       {
68782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68783       };
68784     } catch (std::exception& e) {
68785       {
68786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68787       };
68788     } catch (...) {
68789       {
68790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68791       };
68792     }
68793   }
68794   jresult = result;
68795   return jresult;
68796 }
68797
68798
68799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
68800   float jresult ;
68801   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68802   float arg2 ;
68803   float result;
68804
68805   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68806   arg2 = (float)jarg2;
68807   {
68808     try {
68809       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
68810     } catch (std::out_of_range& e) {
68811       {
68812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68813       };
68814     } catch (std::exception& e) {
68815       {
68816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68817       };
68818     } catch (...) {
68819       {
68820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68821       };
68822     }
68823   }
68824   jresult = result;
68825   return jresult;
68826 }
68827
68828
68829 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
68830   float jresult ;
68831   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68832   unsigned int arg2 ;
68833   float result;
68834
68835   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68836   arg2 = (unsigned int)jarg2;
68837   {
68838     try {
68839       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
68840     } catch (std::out_of_range& e) {
68841       {
68842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68843       };
68844     } catch (std::exception& e) {
68845       {
68846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68847       };
68848     } catch (...) {
68849       {
68850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68851       };
68852     }
68853   }
68854   jresult = result;
68855   return jresult;
68856 }
68857
68858
68859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
68860   void * jresult ;
68861   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68862   float arg2 ;
68863   Dali::Vector3 arg3 ;
68864   Dali::Vector3 *argp3 ;
68865   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68866
68867   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68868   arg2 = (float)jarg2;
68869   argp3 = (Dali::Vector3 *)jarg3;
68870   if (!argp3) {
68871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68872     return 0;
68873   }
68874   arg3 = *argp3;
68875   {
68876     try {
68877       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
68878     } catch (std::out_of_range& e) {
68879       {
68880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68881       };
68882     } catch (std::exception& e) {
68883       {
68884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68885       };
68886     } catch (...) {
68887       {
68888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68889       };
68890     }
68891   }
68892   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68893   return jresult;
68894 }
68895
68896
68897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
68898   float jresult ;
68899   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68900   int arg2 ;
68901   float arg3 ;
68902   Dali::Vector3 *arg4 = 0 ;
68903   float result;
68904
68905   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68906   arg2 = (int)jarg2;
68907   arg3 = (float)jarg3;
68908   arg4 = (Dali::Vector3 *)jarg4;
68909   if (!arg4) {
68910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68911     return 0;
68912   }
68913   {
68914     try {
68915       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
68916     } catch (std::out_of_range& e) {
68917       {
68918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68919       };
68920     } catch (std::exception& e) {
68921       {
68922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68923       };
68924     } catch (...) {
68925       {
68926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68927       };
68928     }
68929   }
68930   jresult = result;
68931   return jresult;
68932 }
68933
68934
68935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
68936   unsigned int jresult ;
68937   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68938   Dali::Vector3 arg2 ;
68939   Dali::Vector3 *argp2 ;
68940   unsigned int result;
68941
68942   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68943   argp2 = (Dali::Vector3 *)jarg2;
68944   if (!argp2) {
68945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68946     return 0;
68947   }
68948   arg2 = *argp2;
68949   {
68950     try {
68951       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
68952     } catch (std::out_of_range& e) {
68953       {
68954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68955       };
68956     } catch (std::exception& e) {
68957       {
68958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68959       };
68960     } catch (...) {
68961       {
68962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68963       };
68964     }
68965   }
68966   jresult = result;
68967   return jresult;
68968 }
68969
68970
68971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68972   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68973   unsigned int arg2 ;
68974   Dali::Vector3 *arg3 = 0 ;
68975   Dali::Vector3 *arg4 = 0 ;
68976
68977   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68978   arg2 = (unsigned int)jarg2;
68979   arg3 = (Dali::Vector3 *)jarg3;
68980   if (!arg3) {
68981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68982     return ;
68983   }
68984   arg4 = (Dali::Vector3 *)jarg4;
68985   if (!arg4) {
68986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68987     return ;
68988   }
68989   {
68990     try {
68991       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68992     } catch (std::out_of_range& e) {
68993       {
68994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68995       };
68996     } catch (std::exception& e) {
68997       {
68998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68999       };
69000     } catch (...) {
69001       {
69002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69003       };
69004     }
69005   }
69006 }
69007
69008
69009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69010   void * jresult ;
69011   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69012   Dali::Degree result;
69013
69014   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69015   {
69016     try {
69017       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69018     } catch (std::out_of_range& e) {
69019       {
69020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69021       };
69022     } catch (std::exception& e) {
69023       {
69024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69025       };
69026     } catch (...) {
69027       {
69028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69029       };
69030     }
69031   }
69032   jresult = new Dali::Degree((const Dali::Degree &)result);
69033   return jresult;
69034 }
69035
69036
69037 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69038   float jresult ;
69039   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69040   float result;
69041
69042   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69043   {
69044     try {
69045       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69046     } catch (std::out_of_range& e) {
69047       {
69048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69049       };
69050     } catch (std::exception& e) {
69051       {
69052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69053       };
69054     } catch (...) {
69055       {
69056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69057       };
69058     }
69059   }
69060   jresult = result;
69061   return jresult;
69062 }
69063
69064
69065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69066   float jresult ;
69067   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69068   float result;
69069
69070   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69071   {
69072     try {
69073       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69074     } catch (std::out_of_range& e) {
69075       {
69076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69077       };
69078     } catch (std::exception& e) {
69079       {
69080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69081       };
69082     } catch (...) {
69083       {
69084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69085       };
69086     }
69087   }
69088   jresult = result;
69089   return jresult;
69090 }
69091
69092
69093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69094   float jresult ;
69095   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69096   float result;
69097
69098   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69099   {
69100     try {
69101       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69102     } catch (std::out_of_range& e) {
69103       {
69104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69105       };
69106     } catch (std::exception& e) {
69107       {
69108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69109       };
69110     } catch (...) {
69111       {
69112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69113       };
69114     }
69115   }
69116   jresult = result;
69117   return jresult;
69118 }
69119
69120
69121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69122   int jresult ;
69123   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69124   int arg2 ;
69125   int arg3 ;
69126   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69127   bool arg5 ;
69128   int result;
69129
69130   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69131   arg2 = (int)jarg2;
69132   arg3 = (int)jarg3;
69133   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69134   arg5 = jarg5 ? true : false;
69135   {
69136     try {
69137       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69138     } catch (std::out_of_range& e) {
69139       {
69140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69141       };
69142     } catch (std::exception& e) {
69143       {
69144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69145       };
69146     } catch (...) {
69147       {
69148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69149       };
69150     }
69151   }
69152   jresult = result;
69153   return jresult;
69154 }
69155
69156
69157 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69158   float jresult ;
69159   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69160   float result;
69161
69162   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69163   {
69164     try {
69165       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69166     } catch (std::out_of_range& e) {
69167       {
69168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69169       };
69170     } catch (std::exception& e) {
69171       {
69172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69173       };
69174     } catch (...) {
69175       {
69176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69177       };
69178     }
69179   }
69180   jresult = result;
69181   return jresult;
69182 }
69183
69184
69185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69186   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69187   Dali::Actor *arg2 = 0 ;
69188   int arg3 ;
69189   Dali::Vector3 *arg4 = 0 ;
69190   Dali::Actor *arg5 = 0 ;
69191
69192   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69193   arg2 = (Dali::Actor *)jarg2;
69194   if (!arg2) {
69195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69196     return ;
69197   }
69198   arg3 = (int)jarg3;
69199   arg4 = (Dali::Vector3 *)jarg4;
69200   if (!arg4) {
69201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69202     return ;
69203   }
69204   arg5 = (Dali::Actor *)jarg5;
69205   if (!arg5) {
69206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69207     return ;
69208   }
69209   {
69210     try {
69211       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69212     } catch (std::out_of_range& e) {
69213       {
69214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69215       };
69216     } catch (std::exception& e) {
69217       {
69218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69219       };
69220     } catch (...) {
69221       {
69222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69223       };
69224     }
69225   }
69226 }
69227
69228
69229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69230   void * jresult ;
69231   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69232   int arg2 ;
69233   float arg3 ;
69234   Dali::Vector3 *arg4 = 0 ;
69235   Dali::Vector3 result;
69236
69237   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69238   arg2 = (int)jarg2;
69239   arg3 = (float)jarg3;
69240   arg4 = (Dali::Vector3 *)jarg4;
69241   if (!arg4) {
69242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69243     return 0;
69244   }
69245   {
69246     try {
69247       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69248     } catch (std::out_of_range& e) {
69249       {
69250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69251       };
69252     } catch (std::exception& e) {
69253       {
69254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69255       };
69256     } catch (...) {
69257       {
69258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69259       };
69260     }
69261   }
69262   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
69263   return jresult;
69264 }
69265
69266
69267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
69268   void * jresult ;
69269   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
69270   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69271
69272   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
69273   {
69274     try {
69275       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
69276     } catch (std::out_of_range& e) {
69277       {
69278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69279       };
69280     } catch (std::exception& e) {
69281       {
69282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69283       };
69284     } catch (...) {
69285       {
69286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69287       };
69288     }
69289   }
69290   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69291   return jresult;
69292 }
69293
69294
69295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
69296   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69297
69298   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69299   {
69300     try {
69301       delete arg1;
69302     } catch (std::out_of_range& e) {
69303       {
69304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69305       };
69306     } catch (std::exception& e) {
69307       {
69308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69309       };
69310     } catch (...) {
69311       {
69312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69313       };
69314     }
69315   }
69316 }
69317
69318
69319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
69320   unsigned int jresult ;
69321   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69322   unsigned int result;
69323
69324   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69325   {
69326     try {
69327       result = (unsigned int)(arg1)->GetNumberOfItems();
69328     } catch (std::out_of_range& e) {
69329       {
69330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69331       };
69332     } catch (std::exception& e) {
69333       {
69334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69335       };
69336     } catch (...) {
69337       {
69338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69339       };
69340     }
69341   }
69342   jresult = result;
69343   return jresult;
69344 }
69345
69346
69347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
69348   void * jresult ;
69349   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69350   unsigned int arg2 ;
69351   Dali::Actor result;
69352
69353   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69354   arg2 = (unsigned int)jarg2;
69355   {
69356     try {
69357       result = (arg1)->NewItem(arg2);
69358     } catch (std::out_of_range& e) {
69359       {
69360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69361       };
69362     } catch (std::exception& e) {
69363       {
69364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69365       };
69366     } catch (...) {
69367       {
69368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69369       };
69370     }
69371   }
69372   jresult = new Dali::Actor((const Dali::Actor &)result);
69373   return jresult;
69374 }
69375
69376
69377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
69378   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69379   unsigned int arg2 ;
69380   Dali::Actor arg3 ;
69381   Dali::Actor *argp3 ;
69382
69383   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69384   arg2 = (unsigned int)jarg2;
69385   argp3 = (Dali::Actor *)jarg3;
69386   if (!argp3) {
69387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69388     return ;
69389   }
69390   arg3 = *argp3;
69391   {
69392     try {
69393       (arg1)->ItemReleased(arg2,arg3);
69394     } catch (std::out_of_range& e) {
69395       {
69396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69397       };
69398     } catch (std::exception& e) {
69399       {
69400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69401       };
69402     } catch (...) {
69403       {
69404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69405       };
69406     }
69407   }
69408 }
69409
69410
69411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
69412   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69413   unsigned int arg2 ;
69414   Dali::Actor arg3 ;
69415   Dali::Actor *argp3 ;
69416
69417   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69418   arg2 = (unsigned int)jarg2;
69419   argp3 = (Dali::Actor *)jarg3;
69420   if (!argp3) {
69421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69422     return ;
69423   }
69424   arg3 = *argp3;
69425   {
69426     try {
69427       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
69428     } catch (std::out_of_range& e) {
69429       {
69430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69431       };
69432     } catch (std::exception& e) {
69433       {
69434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69435       };
69436     } catch (...) {
69437       {
69438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69439       };
69440     }
69441   }
69442 }
69443
69444
69445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
69446   void * jresult ;
69447   Dali::Toolkit::ItemFactory *result = 0 ;
69448
69449   {
69450     try {
69451       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
69452     } catch (std::out_of_range& e) {
69453       {
69454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69455       };
69456     } catch (std::exception& e) {
69457       {
69458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69459       };
69460     } catch (...) {
69461       {
69462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69463       };
69464     }
69465   }
69466   jresult = (void *)result;
69467   return jresult;
69468 }
69469
69470
69471 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) {
69472   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
69473   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
69474   if (director) {
69475     director->swig_connect_director(callback0, callback1, callback2);
69476   }
69477 }
69478
69479
69480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
69481   int jresult ;
69482   int result;
69483
69484   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
69485   jresult = (int)result;
69486   return jresult;
69487 }
69488
69489
69490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
69491   int jresult ;
69492   int result;
69493
69494   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
69495   jresult = (int)result;
69496   return jresult;
69497 }
69498
69499
69500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
69501   int jresult ;
69502   int result;
69503
69504   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
69505   jresult = (int)result;
69506   return jresult;
69507 }
69508
69509
69510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
69511   int jresult ;
69512   int result;
69513
69514   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
69515   jresult = (int)result;
69516   return jresult;
69517 }
69518
69519
69520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
69521   int jresult ;
69522   int result;
69523
69524   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
69525   jresult = (int)result;
69526   return jresult;
69527 }
69528
69529
69530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
69531   int jresult ;
69532   int result;
69533
69534   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
69535   jresult = (int)result;
69536   return jresult;
69537 }
69538
69539
69540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
69541   int jresult ;
69542   int result;
69543
69544   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
69545   jresult = (int)result;
69546   return jresult;
69547 }
69548
69549
69550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
69551   int jresult ;
69552   int result;
69553
69554   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
69555   jresult = (int)result;
69556   return jresult;
69557 }
69558
69559
69560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
69561   int jresult ;
69562   int result;
69563
69564   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
69565   jresult = (int)result;
69566   return jresult;
69567 }
69568
69569
69570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
69571   int jresult ;
69572   int result;
69573
69574   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
69575   jresult = (int)result;
69576   return jresult;
69577 }
69578
69579
69580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
69581   int jresult ;
69582   int result;
69583
69584   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
69585   jresult = (int)result;
69586   return jresult;
69587 }
69588
69589
69590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
69591   void * jresult ;
69592   Dali::Toolkit::ItemView::Property *result = 0 ;
69593
69594   {
69595     try {
69596       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
69597     } catch (std::out_of_range& e) {
69598       {
69599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69600       };
69601     } catch (std::exception& e) {
69602       {
69603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69604       };
69605     } catch (...) {
69606       {
69607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69608       };
69609     }
69610   }
69611   jresult = (void *)result;
69612   return jresult;
69613 }
69614
69615
69616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
69617   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
69618
69619   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
69620   {
69621     try {
69622       delete arg1;
69623     } catch (std::out_of_range& e) {
69624       {
69625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69626       };
69627     } catch (std::exception& e) {
69628       {
69629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69630       };
69631     } catch (...) {
69632       {
69633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69634       };
69635     }
69636   }
69637 }
69638
69639
69640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
69641   void * jresult ;
69642   Dali::Toolkit::ItemView *result = 0 ;
69643
69644   {
69645     try {
69646       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
69647     } catch (std::out_of_range& e) {
69648       {
69649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69650       };
69651     } catch (std::exception& e) {
69652       {
69653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69654       };
69655     } catch (...) {
69656       {
69657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69658       };
69659     }
69660   }
69661   jresult = (void *)result;
69662   return jresult;
69663 }
69664
69665
69666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
69667   void * jresult ;
69668   Dali::Toolkit::ItemView *arg1 = 0 ;
69669   Dali::Toolkit::ItemView *result = 0 ;
69670
69671   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69672   if (!arg1) {
69673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69674     return 0;
69675   }
69676   {
69677     try {
69678       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
69679     } catch (std::out_of_range& e) {
69680       {
69681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69682       };
69683     } catch (std::exception& e) {
69684       {
69685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69686       };
69687     } catch (...) {
69688       {
69689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69690       };
69691     }
69692   }
69693   jresult = (void *)result;
69694   return jresult;
69695 }
69696
69697
69698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
69699   void * jresult ;
69700   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69701   Dali::Toolkit::ItemView *arg2 = 0 ;
69702   Dali::Toolkit::ItemView *result = 0 ;
69703
69704   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69705   arg2 = (Dali::Toolkit::ItemView *)jarg2;
69706   if (!arg2) {
69707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69708     return 0;
69709   }
69710   {
69711     try {
69712       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
69713     } catch (std::out_of_range& e) {
69714       {
69715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69716       };
69717     } catch (std::exception& e) {
69718       {
69719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69720       };
69721     } catch (...) {
69722       {
69723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69724       };
69725     }
69726   }
69727   jresult = (void *)result;
69728   return jresult;
69729 }
69730
69731
69732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
69733   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69734
69735   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69736   {
69737     try {
69738       delete arg1;
69739     } catch (std::out_of_range& e) {
69740       {
69741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69742       };
69743     } catch (std::exception& e) {
69744       {
69745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69746       };
69747     } catch (...) {
69748       {
69749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69750       };
69751     }
69752   }
69753 }
69754
69755
69756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
69757   void * jresult ;
69758   Dali::Toolkit::ItemFactory *arg1 = 0 ;
69759   Dali::Toolkit::ItemView result;
69760
69761   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69762   if (!arg1) {
69763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
69764     return 0;
69765   }
69766   {
69767     try {
69768       result = Dali::Toolkit::ItemView::New(*arg1);
69769     } catch (std::out_of_range& e) {
69770       {
69771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69772       };
69773     } catch (std::exception& e) {
69774       {
69775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69776       };
69777     } catch (...) {
69778       {
69779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69780       };
69781     }
69782   }
69783   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69784   return jresult;
69785 }
69786
69787
69788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
69789   void * jresult ;
69790   Dali::BaseHandle arg1 ;
69791   Dali::BaseHandle *argp1 ;
69792   Dali::Toolkit::ItemView result;
69793
69794   argp1 = (Dali::BaseHandle *)jarg1;
69795   if (!argp1) {
69796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69797     return 0;
69798   }
69799   arg1 = *argp1;
69800   {
69801     try {
69802       result = Dali::Toolkit::ItemView::DownCast(arg1);
69803     } catch (std::out_of_range& e) {
69804       {
69805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69806       };
69807     } catch (std::exception& e) {
69808       {
69809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69810       };
69811     } catch (...) {
69812       {
69813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69814       };
69815     }
69816   }
69817   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69818   return jresult;
69819 }
69820
69821
69822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
69823   unsigned int jresult ;
69824   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69825   unsigned int result;
69826
69827   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69828   {
69829     try {
69830       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
69831     } catch (std::out_of_range& e) {
69832       {
69833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69834       };
69835     } catch (std::exception& e) {
69836       {
69837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69838       };
69839     } catch (...) {
69840       {
69841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69842       };
69843     }
69844   }
69845   jresult = result;
69846   return jresult;
69847 }
69848
69849
69850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
69851   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69852   Dali::Toolkit::ItemLayout *arg2 = 0 ;
69853
69854   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69855   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
69856   if (!arg2) {
69857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
69858     return ;
69859   }
69860   {
69861     try {
69862       (arg1)->AddLayout(*arg2);
69863     } catch (std::out_of_range& e) {
69864       {
69865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69866       };
69867     } catch (std::exception& e) {
69868       {
69869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69870       };
69871     } catch (...) {
69872       {
69873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69874       };
69875     }
69876   }
69877 }
69878
69879
69880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
69881   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69882   unsigned int arg2 ;
69883
69884   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69885   arg2 = (unsigned int)jarg2;
69886   {
69887     try {
69888       (arg1)->RemoveLayout(arg2);
69889     } catch (std::out_of_range& e) {
69890       {
69891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69892       };
69893     } catch (std::exception& e) {
69894       {
69895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69896       };
69897     } catch (...) {
69898       {
69899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69900       };
69901     }
69902   }
69903 }
69904
69905
69906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
69907   void * jresult ;
69908   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69909   unsigned int arg2 ;
69910   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69911
69912   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69913   arg2 = (unsigned int)jarg2;
69914   {
69915     try {
69916       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
69917     } catch (std::out_of_range& e) {
69918       {
69919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69920       };
69921     } catch (std::exception& e) {
69922       {
69923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69924       };
69925     } catch (...) {
69926       {
69927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69928       };
69929     }
69930   }
69931   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69932   return jresult;
69933 }
69934
69935
69936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
69937   void * jresult ;
69938   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69939   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69940
69941   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69942   {
69943     try {
69944       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
69945     } catch (std::out_of_range& e) {
69946       {
69947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69948       };
69949     } catch (std::exception& e) {
69950       {
69951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69952       };
69953     } catch (...) {
69954       {
69955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69956       };
69957     }
69958   }
69959   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69960   return jresult;
69961 }
69962
69963
69964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
69965   float jresult ;
69966   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69967   Dali::Toolkit::ItemId arg2 ;
69968   float result;
69969
69970   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69971   arg2 = (Dali::Toolkit::ItemId)jarg2;
69972   {
69973     try {
69974       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
69975     } catch (std::out_of_range& e) {
69976       {
69977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69978       };
69979     } catch (std::exception& e) {
69980       {
69981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69982       };
69983     } catch (...) {
69984       {
69985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69986       };
69987     }
69988   }
69989   jresult = result;
69990   return jresult;
69991 }
69992
69993
69994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
69995   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69996   unsigned int arg2 ;
69997   Dali::Vector3 arg3 ;
69998   float arg4 ;
69999   Dali::Vector3 *argp3 ;
70000
70001   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70002   arg2 = (unsigned int)jarg2;
70003   argp3 = (Dali::Vector3 *)jarg3;
70004   if (!argp3) {
70005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70006     return ;
70007   }
70008   arg3 = *argp3;
70009   arg4 = (float)jarg4;
70010   {
70011     try {
70012       (arg1)->ActivateLayout(arg2,arg3,arg4);
70013     } catch (std::out_of_range& e) {
70014       {
70015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70016       };
70017     } catch (std::exception& e) {
70018       {
70019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70020       };
70021     } catch (...) {
70022       {
70023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70024       };
70025     }
70026   }
70027 }
70028
70029
70030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70031   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70032
70033   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70034   {
70035     try {
70036       (arg1)->DeactivateCurrentLayout();
70037     } catch (std::out_of_range& e) {
70038       {
70039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70040       };
70041     } catch (std::exception& e) {
70042       {
70043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70044       };
70045     } catch (...) {
70046       {
70047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70048       };
70049     }
70050   }
70051 }
70052
70053
70054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70055   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70056   float arg2 ;
70057
70058   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70059   arg2 = (float)jarg2;
70060   {
70061     try {
70062       (arg1)->SetMinimumSwipeSpeed(arg2);
70063     } catch (std::out_of_range& e) {
70064       {
70065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70066       };
70067     } catch (std::exception& e) {
70068       {
70069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70070       };
70071     } catch (...) {
70072       {
70073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70074       };
70075     }
70076   }
70077 }
70078
70079
70080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70081   float jresult ;
70082   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70083   float result;
70084
70085   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70086   {
70087     try {
70088       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70089     } catch (std::out_of_range& e) {
70090       {
70091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70092       };
70093     } catch (std::exception& e) {
70094       {
70095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70096       };
70097     } catch (...) {
70098       {
70099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70100       };
70101     }
70102   }
70103   jresult = result;
70104   return jresult;
70105 }
70106
70107
70108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70109   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70110   float arg2 ;
70111
70112   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70113   arg2 = (float)jarg2;
70114   {
70115     try {
70116       (arg1)->SetMinimumSwipeDistance(arg2);
70117     } catch (std::out_of_range& e) {
70118       {
70119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70120       };
70121     } catch (std::exception& e) {
70122       {
70123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70124       };
70125     } catch (...) {
70126       {
70127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70128       };
70129     }
70130   }
70131 }
70132
70133
70134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
70135   float jresult ;
70136   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70137   float result;
70138
70139   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70140   {
70141     try {
70142       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
70143     } catch (std::out_of_range& e) {
70144       {
70145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70146       };
70147     } catch (std::exception& e) {
70148       {
70149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70150       };
70151     } catch (...) {
70152       {
70153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70154       };
70155     }
70156   }
70157   jresult = result;
70158   return jresult;
70159 }
70160
70161
70162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
70163   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70164   float arg2 ;
70165
70166   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70167   arg2 = (float)jarg2;
70168   {
70169     try {
70170       (arg1)->SetWheelScrollDistanceStep(arg2);
70171     } catch (std::out_of_range& e) {
70172       {
70173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70174       };
70175     } catch (std::exception& e) {
70176       {
70177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70178       };
70179     } catch (...) {
70180       {
70181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70182       };
70183     }
70184   }
70185 }
70186
70187
70188 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
70189   float jresult ;
70190   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70191   float result;
70192
70193   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70194   {
70195     try {
70196       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
70197     } catch (std::out_of_range& e) {
70198       {
70199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70200       };
70201     } catch (std::exception& e) {
70202       {
70203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70204       };
70205     } catch (...) {
70206       {
70207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70208       };
70209     }
70210   }
70211   jresult = result;
70212   return jresult;
70213 }
70214
70215
70216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
70217   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70218   bool arg2 ;
70219
70220   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70221   arg2 = jarg2 ? true : false;
70222   {
70223     try {
70224       (arg1)->SetAnchoring(arg2);
70225     } catch (std::out_of_range& e) {
70226       {
70227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70228       };
70229     } catch (std::exception& e) {
70230       {
70231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70232       };
70233     } catch (...) {
70234       {
70235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70236       };
70237     }
70238   }
70239 }
70240
70241
70242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
70243   unsigned int jresult ;
70244   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70245   bool result;
70246
70247   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70248   {
70249     try {
70250       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
70251     } catch (std::out_of_range& e) {
70252       {
70253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70254       };
70255     } catch (std::exception& e) {
70256       {
70257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70258       };
70259     } catch (...) {
70260       {
70261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70262       };
70263     }
70264   }
70265   jresult = result;
70266   return jresult;
70267 }
70268
70269
70270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
70271   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70272   float arg2 ;
70273
70274   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70275   arg2 = (float)jarg2;
70276   {
70277     try {
70278       (arg1)->SetAnchoringDuration(arg2);
70279     } catch (std::out_of_range& e) {
70280       {
70281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70282       };
70283     } catch (std::exception& e) {
70284       {
70285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70286       };
70287     } catch (...) {
70288       {
70289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70290       };
70291     }
70292   }
70293 }
70294
70295
70296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
70297   float jresult ;
70298   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70299   float result;
70300
70301   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70302   {
70303     try {
70304       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
70305     } catch (std::out_of_range& e) {
70306       {
70307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70308       };
70309     } catch (std::exception& e) {
70310       {
70311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70312       };
70313     } catch (...) {
70314       {
70315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70316       };
70317     }
70318   }
70319   jresult = result;
70320   return jresult;
70321 }
70322
70323
70324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
70325   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70326   Dali::Toolkit::ItemId arg2 ;
70327   float arg3 ;
70328
70329   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70330   arg2 = (Dali::Toolkit::ItemId)jarg2;
70331   arg3 = (float)jarg3;
70332   {
70333     try {
70334       (arg1)->ScrollToItem(arg2,arg3);
70335     } catch (std::out_of_range& e) {
70336       {
70337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70338       };
70339     } catch (std::exception& e) {
70340       {
70341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70342       };
70343     } catch (...) {
70344       {
70345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70346       };
70347     }
70348   }
70349 }
70350
70351
70352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
70353   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70354   float arg2 ;
70355
70356   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70357   arg2 = (float)jarg2;
70358   {
70359     try {
70360       (arg1)->SetRefreshInterval(arg2);
70361     } catch (std::out_of_range& e) {
70362       {
70363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70364       };
70365     } catch (std::exception& e) {
70366       {
70367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70368       };
70369     } catch (...) {
70370       {
70371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70372       };
70373     }
70374   }
70375 }
70376
70377
70378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
70379   float jresult ;
70380   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70381   float result;
70382
70383   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70384   {
70385     try {
70386       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
70387     } catch (std::out_of_range& e) {
70388       {
70389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70390       };
70391     } catch (std::exception& e) {
70392       {
70393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70394       };
70395     } catch (...) {
70396       {
70397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70398       };
70399     }
70400   }
70401   jresult = result;
70402   return jresult;
70403 }
70404
70405
70406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
70407   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70408
70409   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70410   {
70411     try {
70412       (arg1)->Refresh();
70413     } catch (std::out_of_range& e) {
70414       {
70415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70416       };
70417     } catch (std::exception& e) {
70418       {
70419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70420       };
70421     } catch (...) {
70422       {
70423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70424       };
70425     }
70426   }
70427 }
70428
70429
70430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
70431   void * jresult ;
70432   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70433   Dali::Toolkit::ItemId arg2 ;
70434   Dali::Actor result;
70435
70436   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70437   arg2 = (Dali::Toolkit::ItemId)jarg2;
70438   {
70439     try {
70440       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
70441     } catch (std::out_of_range& e) {
70442       {
70443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70444       };
70445     } catch (std::exception& e) {
70446       {
70447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70448       };
70449     } catch (...) {
70450       {
70451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70452       };
70453     }
70454   }
70455   jresult = new Dali::Actor((const Dali::Actor &)result);
70456   return jresult;
70457 }
70458
70459
70460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
70461   unsigned int jresult ;
70462   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70463   Dali::Actor arg2 ;
70464   Dali::Actor *argp2 ;
70465   Dali::Toolkit::ItemId result;
70466
70467   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70468   argp2 = (Dali::Actor *)jarg2;
70469   if (!argp2) {
70470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70471     return 0;
70472   }
70473   arg2 = *argp2;
70474   {
70475     try {
70476       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
70477     } catch (std::out_of_range& e) {
70478       {
70479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70480       };
70481     } catch (std::exception& e) {
70482       {
70483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70484       };
70485     } catch (...) {
70486       {
70487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70488       };
70489     }
70490   }
70491   jresult = result;
70492   return jresult;
70493 }
70494
70495
70496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
70497   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70498   Dali::Toolkit::Item arg2 ;
70499   float arg3 ;
70500   Dali::Toolkit::Item *argp2 ;
70501
70502   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70503   argp2 = (Dali::Toolkit::Item *)jarg2;
70504   if (!argp2) {
70505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70506     return ;
70507   }
70508   arg2 = *argp2;
70509   arg3 = (float)jarg3;
70510   {
70511     try {
70512       (arg1)->InsertItem(arg2,arg3);
70513     } catch (std::out_of_range& e) {
70514       {
70515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70516       };
70517     } catch (std::exception& e) {
70518       {
70519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70520       };
70521     } catch (...) {
70522       {
70523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70524       };
70525     }
70526   }
70527 }
70528
70529
70530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
70531   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70532   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70533   float arg3 ;
70534
70535   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70536   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70537   if (!arg2) {
70538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70539     return ;
70540   }
70541   arg3 = (float)jarg3;
70542   {
70543     try {
70544       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70545     } catch (std::out_of_range& e) {
70546       {
70547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70548       };
70549     } catch (std::exception& e) {
70550       {
70551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70552       };
70553     } catch (...) {
70554       {
70555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70556       };
70557     }
70558   }
70559 }
70560
70561
70562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
70563   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70564   Dali::Toolkit::ItemId arg2 ;
70565   float arg3 ;
70566
70567   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70568   arg2 = (Dali::Toolkit::ItemId)jarg2;
70569   arg3 = (float)jarg3;
70570   {
70571     try {
70572       (arg1)->RemoveItem(arg2,arg3);
70573     } catch (std::out_of_range& e) {
70574       {
70575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70576       };
70577     } catch (std::exception& e) {
70578       {
70579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70580       };
70581     } catch (...) {
70582       {
70583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70584       };
70585     }
70586   }
70587 }
70588
70589
70590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
70591   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70592   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
70593   float arg3 ;
70594
70595   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70596   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
70597   if (!arg2) {
70598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
70599     return ;
70600   }
70601   arg3 = (float)jarg3;
70602   {
70603     try {
70604       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
70605     } catch (std::out_of_range& e) {
70606       {
70607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70608       };
70609     } catch (std::exception& e) {
70610       {
70611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70612       };
70613     } catch (...) {
70614       {
70615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70616       };
70617     }
70618   }
70619 }
70620
70621
70622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
70623   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70624   Dali::Toolkit::Item arg2 ;
70625   float arg3 ;
70626   Dali::Toolkit::Item *argp2 ;
70627
70628   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70629   argp2 = (Dali::Toolkit::Item *)jarg2;
70630   if (!argp2) {
70631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70632     return ;
70633   }
70634   arg2 = *argp2;
70635   arg3 = (float)jarg3;
70636   {
70637     try {
70638       (arg1)->ReplaceItem(arg2,arg3);
70639     } catch (std::out_of_range& e) {
70640       {
70641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70642       };
70643     } catch (std::exception& e) {
70644       {
70645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70646       };
70647     } catch (...) {
70648       {
70649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70650       };
70651     }
70652   }
70653 }
70654
70655
70656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
70657   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70658   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70659   float arg3 ;
70660
70661   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70662   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70663   if (!arg2) {
70664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70665     return ;
70666   }
70667   arg3 = (float)jarg3;
70668   {
70669     try {
70670       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70671     } catch (std::out_of_range& e) {
70672       {
70673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70674       };
70675     } catch (std::exception& e) {
70676       {
70677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70678       };
70679     } catch (...) {
70680       {
70681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70682       };
70683     }
70684   }
70685 }
70686
70687
70688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
70689   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70690   Dali::Vector3 *arg2 = 0 ;
70691
70692   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70693   arg2 = (Dali::Vector3 *)jarg2;
70694   if (!arg2) {
70695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70696     return ;
70697   }
70698   {
70699     try {
70700       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
70701     } catch (std::out_of_range& e) {
70702       {
70703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70704       };
70705     } catch (std::exception& e) {
70706       {
70707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70708       };
70709     } catch (...) {
70710       {
70711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70712       };
70713     }
70714   }
70715 }
70716
70717
70718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
70719   void * jresult ;
70720   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70721   Dali::Vector3 result;
70722
70723   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70724   {
70725     try {
70726       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
70727     } catch (std::out_of_range& e) {
70728       {
70729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70730       };
70731     } catch (std::exception& e) {
70732       {
70733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70734       };
70735     } catch (...) {
70736       {
70737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70738       };
70739     }
70740   }
70741   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70742   return jresult;
70743 }
70744
70745
70746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
70747   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70748   Dali::Vector3 *arg2 = 0 ;
70749
70750   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70751   arg2 = (Dali::Vector3 *)jarg2;
70752   if (!arg2) {
70753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70754     return ;
70755   }
70756   {
70757     try {
70758       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
70759     } catch (std::out_of_range& e) {
70760       {
70761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70762       };
70763     } catch (std::exception& e) {
70764       {
70765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70766       };
70767     } catch (...) {
70768       {
70769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70770       };
70771     }
70772   }
70773 }
70774
70775
70776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
70777   void * jresult ;
70778   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70779   Dali::Vector3 result;
70780
70781   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70782   {
70783     try {
70784       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
70785     } catch (std::out_of_range& e) {
70786       {
70787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70788       };
70789     } catch (std::exception& e) {
70790       {
70791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70792       };
70793     } catch (...) {
70794       {
70795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70796       };
70797     }
70798   }
70799   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70800   return jresult;
70801 }
70802
70803
70804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
70805   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70806   Dali::Toolkit::ItemRange *arg2 = 0 ;
70807
70808   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70809   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
70810   if (!arg2) {
70811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
70812     return ;
70813   }
70814   {
70815     try {
70816       (arg1)->GetItemsRange(*arg2);
70817     } catch (std::out_of_range& e) {
70818       {
70819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70820       };
70821     } catch (std::exception& e) {
70822       {
70823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70824       };
70825     } catch (...) {
70826       {
70827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70828       };
70829     }
70830   }
70831 }
70832
70833
70834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
70835   void * jresult ;
70836   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70837   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
70838
70839   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70840   {
70841     try {
70842       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
70843     } catch (std::out_of_range& e) {
70844       {
70845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70846       };
70847     } catch (std::exception& e) {
70848       {
70849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70850       };
70851     } catch (...) {
70852       {
70853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70854       };
70855     }
70856   }
70857   jresult = (void *)result;
70858   return jresult;
70859 }
70860
70861
70862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
70863   Dali::Vector3 *arg1 = 0 ;
70864   PropertyInputContainer *arg2 = 0 ;
70865
70866   arg1 = (Dali::Vector3 *)jarg1;
70867   if (!arg1) {
70868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70869     return ;
70870   }
70871   arg2 = (PropertyInputContainer *)jarg2;
70872   if (!arg2) {
70873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
70874     return ;
70875   }
70876   {
70877     try {
70878       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
70879     } catch (std::out_of_range& e) {
70880       {
70881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70882       };
70883     } catch (std::exception& e) {
70884       {
70885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70886       };
70887     } catch (...) {
70888       {
70889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70890       };
70891     }
70892   }
70893 }
70894
70895
70896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
70897   Dali::Vector3 *arg1 = 0 ;
70898   PropertyInputContainer *arg2 = 0 ;
70899
70900   arg1 = (Dali::Vector3 *)jarg1;
70901   if (!arg1) {
70902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70903     return ;
70904   }
70905   arg2 = (PropertyInputContainer *)jarg2;
70906   if (!arg2) {
70907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
70908     return ;
70909   }
70910   {
70911     try {
70912       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
70913     } catch (std::out_of_range& e) {
70914       {
70915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70916       };
70917     } catch (std::exception& e) {
70918       {
70919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70920       };
70921     } catch (...) {
70922       {
70923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70924       };
70925     }
70926   }
70927 }
70928
70929
70930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
70931   void * jresult ;
70932   Dali::Toolkit::ScrollViewEffect *result = 0 ;
70933
70934   {
70935     try {
70936       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
70937     } catch (std::out_of_range& e) {
70938       {
70939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70940       };
70941     } catch (std::exception& e) {
70942       {
70943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70944       };
70945     } catch (...) {
70946       {
70947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70948       };
70949     }
70950   }
70951   jresult = (void *)result;
70952   return jresult;
70953 }
70954
70955
70956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
70957   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
70958
70959   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
70960   {
70961     try {
70962       delete arg1;
70963     } catch (std::out_of_range& e) {
70964       {
70965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70966       };
70967     } catch (std::exception& e) {
70968       {
70969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70970       };
70971     } catch (...) {
70972       {
70973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70974       };
70975     }
70976   }
70977 }
70978
70979
70980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
70981   void * jresult ;
70982   Dali::Path arg1 ;
70983   Dali::Vector3 *arg2 = 0 ;
70984   Dali::Property::Index arg3 ;
70985   Dali::Vector3 *arg4 = 0 ;
70986   unsigned int arg5 ;
70987   Dali::Path *argp1 ;
70988   Dali::Toolkit::ScrollViewPagePathEffect result;
70989
70990   argp1 = (Dali::Path *)jarg1;
70991   if (!argp1) {
70992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
70993     return 0;
70994   }
70995   arg1 = *argp1;
70996   arg2 = (Dali::Vector3 *)jarg2;
70997   if (!arg2) {
70998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70999     return 0;
71000   }
71001   arg3 = (Dali::Property::Index)jarg3;
71002   arg4 = (Dali::Vector3 *)jarg4;
71003   if (!arg4) {
71004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71005     return 0;
71006   }
71007   arg5 = (unsigned int)jarg5;
71008   {
71009     try {
71010       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
71011     } catch (std::out_of_range& e) {
71012       {
71013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71014       };
71015     } catch (std::exception& e) {
71016       {
71017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71018       };
71019     } catch (...) {
71020       {
71021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71022       };
71023     }
71024   }
71025   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71026   return jresult;
71027 }
71028
71029
71030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
71031   void * jresult ;
71032   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
71033
71034   {
71035     try {
71036       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
71037     } catch (std::out_of_range& e) {
71038       {
71039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71040       };
71041     } catch (std::exception& e) {
71042       {
71043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71044       };
71045     } catch (...) {
71046       {
71047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71048       };
71049     }
71050   }
71051   jresult = (void *)result;
71052   return jresult;
71053 }
71054
71055
71056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
71057   void * jresult ;
71058   Dali::BaseHandle arg1 ;
71059   Dali::BaseHandle *argp1 ;
71060   Dali::Toolkit::ScrollViewPagePathEffect result;
71061
71062   argp1 = (Dali::BaseHandle *)jarg1;
71063   if (!argp1) {
71064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71065     return 0;
71066   }
71067   arg1 = *argp1;
71068   {
71069     try {
71070       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
71071     } catch (std::out_of_range& e) {
71072       {
71073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71074       };
71075     } catch (std::exception& e) {
71076       {
71077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71078       };
71079     } catch (...) {
71080       {
71081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71082       };
71083     }
71084   }
71085   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71086   return jresult;
71087 }
71088
71089
71090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
71091   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71092   Dali::Actor arg2 ;
71093   unsigned int arg3 ;
71094   Dali::Actor *argp2 ;
71095
71096   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71097   argp2 = (Dali::Actor *)jarg2;
71098   if (!argp2) {
71099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71100     return ;
71101   }
71102   arg2 = *argp2;
71103   arg3 = (unsigned int)jarg3;
71104   {
71105     try {
71106       (arg1)->ApplyToPage(arg2,arg3);
71107     } catch (std::out_of_range& e) {
71108       {
71109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71110       };
71111     } catch (std::exception& e) {
71112       {
71113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71114       };
71115     } catch (...) {
71116       {
71117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71118       };
71119     }
71120   }
71121 }
71122
71123
71124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
71125   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71126
71127   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71128   {
71129     try {
71130       delete arg1;
71131     } catch (std::out_of_range& e) {
71132       {
71133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71134       };
71135     } catch (std::exception& e) {
71136       {
71137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71138       };
71139     } catch (...) {
71140       {
71141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71142       };
71143     }
71144   }
71145 }
71146
71147
71148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
71149   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71150   Dali::Toolkit::ClampState arg2 ;
71151
71152   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71153   arg2 = (Dali::Toolkit::ClampState)jarg2;
71154   if (arg1) (arg1)->x = arg2;
71155 }
71156
71157
71158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
71159   int jresult ;
71160   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71161   Dali::Toolkit::ClampState result;
71162
71163   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71164   result = (Dali::Toolkit::ClampState) ((arg1)->x);
71165   jresult = (int)result;
71166   return jresult;
71167 }
71168
71169
71170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
71171   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71172   Dali::Toolkit::ClampState arg2 ;
71173
71174   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71175   arg2 = (Dali::Toolkit::ClampState)jarg2;
71176   if (arg1) (arg1)->y = arg2;
71177 }
71178
71179
71180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
71181   int jresult ;
71182   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71183   Dali::Toolkit::ClampState result;
71184
71185   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71186   result = (Dali::Toolkit::ClampState) ((arg1)->y);
71187   jresult = (int)result;
71188   return jresult;
71189 }
71190
71191
71192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
71193   void * jresult ;
71194   Dali::Toolkit::ClampState2D *result = 0 ;
71195
71196   {
71197     try {
71198       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
71199     } catch (std::out_of_range& e) {
71200       {
71201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71202       };
71203     } catch (std::exception& e) {
71204       {
71205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71206       };
71207     } catch (...) {
71208       {
71209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71210       };
71211     }
71212   }
71213   jresult = (void *)result;
71214   return jresult;
71215 }
71216
71217
71218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
71219   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71220
71221   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71222   {
71223     try {
71224       delete arg1;
71225     } catch (std::out_of_range& e) {
71226       {
71227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71228       };
71229     } catch (std::exception& e) {
71230       {
71231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71232       };
71233     } catch (...) {
71234       {
71235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71236       };
71237     }
71238   }
71239 }
71240
71241
71242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
71243   void * jresult ;
71244   float arg1 ;
71245   float arg2 ;
71246   bool arg3 ;
71247   Dali::Toolkit::RulerDomain *result = 0 ;
71248
71249   arg1 = (float)jarg1;
71250   arg2 = (float)jarg2;
71251   arg3 = jarg3 ? true : false;
71252   {
71253     try {
71254       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
71255     } catch (std::out_of_range& e) {
71256       {
71257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71258       };
71259     } catch (std::exception& e) {
71260       {
71261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71262       };
71263     } catch (...) {
71264       {
71265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71266       };
71267     }
71268   }
71269   jresult = (void *)result;
71270   return jresult;
71271 }
71272
71273
71274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
71275   void * jresult ;
71276   float arg1 ;
71277   float arg2 ;
71278   Dali::Toolkit::RulerDomain *result = 0 ;
71279
71280   arg1 = (float)jarg1;
71281   arg2 = (float)jarg2;
71282   {
71283     try {
71284       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
71285     } catch (std::out_of_range& e) {
71286       {
71287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71288       };
71289     } catch (std::exception& e) {
71290       {
71291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71292       };
71293     } catch (...) {
71294       {
71295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71296       };
71297     }
71298   }
71299   jresult = (void *)result;
71300   return jresult;
71301 }
71302
71303
71304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
71305   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71306   float arg2 ;
71307
71308   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71309   arg2 = (float)jarg2;
71310   if (arg1) (arg1)->min = arg2;
71311 }
71312
71313
71314 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
71315   float jresult ;
71316   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71317   float result;
71318
71319   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71320   result = (float) ((arg1)->min);
71321   jresult = result;
71322   return jresult;
71323 }
71324
71325
71326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
71327   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71328   float arg2 ;
71329
71330   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71331   arg2 = (float)jarg2;
71332   if (arg1) (arg1)->max = arg2;
71333 }
71334
71335
71336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
71337   float jresult ;
71338   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71339   float result;
71340
71341   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71342   result = (float) ((arg1)->max);
71343   jresult = result;
71344   return jresult;
71345 }
71346
71347
71348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
71349   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71350   bool arg2 ;
71351
71352   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71353   arg2 = jarg2 ? true : false;
71354   if (arg1) (arg1)->enabled = arg2;
71355 }
71356
71357
71358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
71359   unsigned int jresult ;
71360   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71361   bool result;
71362
71363   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71364   result = (bool) ((arg1)->enabled);
71365   jresult = result;
71366   return jresult;
71367 }
71368
71369
71370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71371   float jresult ;
71372   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71373   float arg2 ;
71374   float arg3 ;
71375   float arg4 ;
71376   float result;
71377
71378   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71379   arg2 = (float)jarg2;
71380   arg3 = (float)jarg3;
71381   arg4 = (float)jarg4;
71382   {
71383     try {
71384       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
71385     } catch (std::out_of_range& e) {
71386       {
71387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71388       };
71389     } catch (std::exception& e) {
71390       {
71391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71392       };
71393     } catch (...) {
71394       {
71395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71396       };
71397     }
71398   }
71399   jresult = result;
71400   return jresult;
71401 }
71402
71403
71404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71405   float jresult ;
71406   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71407   float arg2 ;
71408   float arg3 ;
71409   float result;
71410
71411   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71412   arg2 = (float)jarg2;
71413   arg3 = (float)jarg3;
71414   {
71415     try {
71416       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
71417     } catch (std::out_of_range& e) {
71418       {
71419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71420       };
71421     } catch (std::exception& e) {
71422       {
71423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71424       };
71425     } catch (...) {
71426       {
71427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71428       };
71429     }
71430   }
71431   jresult = result;
71432   return jresult;
71433 }
71434
71435
71436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
71437   float jresult ;
71438   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71439   float arg2 ;
71440   float result;
71441
71442   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71443   arg2 = (float)jarg2;
71444   {
71445     try {
71446       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
71447     } catch (std::out_of_range& e) {
71448       {
71449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71450       };
71451     } catch (std::exception& e) {
71452       {
71453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71454       };
71455     } catch (...) {
71456       {
71457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71458       };
71459     }
71460   }
71461   jresult = result;
71462   return jresult;
71463 }
71464
71465
71466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71467   float jresult ;
71468   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71469   float arg2 ;
71470   float arg3 ;
71471   float arg4 ;
71472   Dali::Toolkit::ClampState *arg5 = 0 ;
71473   float result;
71474
71475   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71476   arg2 = (float)jarg2;
71477   arg3 = (float)jarg3;
71478   arg4 = (float)jarg4;
71479   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71480   if (!arg5) {
71481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71482     return 0;
71483   }
71484   {
71485     try {
71486       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71487     } catch (std::out_of_range& e) {
71488       {
71489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71490       };
71491     } catch (std::exception& e) {
71492       {
71493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71494       };
71495     } catch (...) {
71496       {
71497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71498       };
71499     }
71500   }
71501   jresult = result;
71502   return jresult;
71503 }
71504
71505
71506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
71507   float jresult ;
71508   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71509   float result;
71510
71511   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71512   {
71513     try {
71514       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
71515     } catch (std::out_of_range& e) {
71516       {
71517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71518       };
71519     } catch (std::exception& e) {
71520       {
71521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71522       };
71523     } catch (...) {
71524       {
71525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71526       };
71527     }
71528   }
71529   jresult = result;
71530   return jresult;
71531 }
71532
71533
71534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
71535   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71536
71537   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71538   {
71539     try {
71540       delete arg1;
71541     } catch (std::out_of_range& e) {
71542       {
71543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71544       };
71545     } catch (std::exception& e) {
71546       {
71547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71548       };
71549     } catch (...) {
71550       {
71551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71552       };
71553     }
71554   }
71555 }
71556
71557
71558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
71559   float jresult ;
71560   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71561   float arg2 ;
71562   float arg3 ;
71563   float result;
71564
71565   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71566   arg2 = (float)jarg2;
71567   arg3 = (float)jarg3;
71568   {
71569     try {
71570       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
71571     } catch (std::out_of_range& e) {
71572       {
71573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71574       };
71575     } catch (std::exception& e) {
71576       {
71577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71578       };
71579     } catch (...) {
71580       {
71581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71582       };
71583     }
71584   }
71585   jresult = result;
71586   return jresult;
71587 }
71588
71589
71590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
71591   float jresult ;
71592   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71593   float arg2 ;
71594   float result;
71595
71596   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71597   arg2 = (float)jarg2;
71598   {
71599     try {
71600       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
71601     } catch (std::out_of_range& e) {
71602       {
71603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71604       };
71605     } catch (std::exception& e) {
71606       {
71607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71608       };
71609     } catch (...) {
71610       {
71611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71612       };
71613     }
71614   }
71615   jresult = result;
71616   return jresult;
71617 }
71618
71619
71620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
71621   float jresult ;
71622   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71623   unsigned int arg2 ;
71624   unsigned int *arg3 = 0 ;
71625   bool arg4 ;
71626   float result;
71627
71628   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71629   arg2 = (unsigned int)jarg2;
71630   arg3 = (unsigned int *)jarg3;
71631   arg4 = jarg4 ? true : false;
71632   {
71633     try {
71634       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
71635     } catch (std::out_of_range& e) {
71636       {
71637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71638       };
71639     } catch (std::exception& e) {
71640       {
71641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71642       };
71643     } catch (...) {
71644       {
71645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71646       };
71647     }
71648   }
71649   jresult = result;
71650   return jresult;
71651 }
71652
71653
71654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
71655   unsigned int jresult ;
71656   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71657   float arg2 ;
71658   bool arg3 ;
71659   unsigned int result;
71660
71661   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71662   arg2 = (float)jarg2;
71663   arg3 = jarg3 ? true : false;
71664   {
71665     try {
71666       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
71667     } catch (std::out_of_range& e) {
71668       {
71669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71670       };
71671     } catch (std::exception& e) {
71672       {
71673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71674       };
71675     } catch (...) {
71676       {
71677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71678       };
71679     }
71680   }
71681   jresult = result;
71682   return jresult;
71683 }
71684
71685
71686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
71687   unsigned int jresult ;
71688   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71689   unsigned int result;
71690
71691   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71692   {
71693     try {
71694       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
71695     } catch (std::out_of_range& e) {
71696       {
71697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71698       };
71699     } catch (std::exception& e) {
71700       {
71701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71702       };
71703     } catch (...) {
71704       {
71705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71706       };
71707     }
71708   }
71709   jresult = result;
71710   return jresult;
71711 }
71712
71713
71714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
71715   int jresult ;
71716   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71717   Dali::Toolkit::Ruler::RulerType result;
71718
71719   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71720   {
71721     try {
71722       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
71723     } catch (std::out_of_range& e) {
71724       {
71725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71726       };
71727     } catch (std::exception& e) {
71728       {
71729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71730       };
71731     } catch (...) {
71732       {
71733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71734       };
71735     }
71736   }
71737   jresult = (int)result;
71738   return jresult;
71739 }
71740
71741
71742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
71743   unsigned int jresult ;
71744   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71745   bool result;
71746
71747   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71748   {
71749     try {
71750       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
71751     } catch (std::out_of_range& e) {
71752       {
71753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71754       };
71755     } catch (std::exception& e) {
71756       {
71757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71758       };
71759     } catch (...) {
71760       {
71761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71762       };
71763     }
71764   }
71765   jresult = result;
71766   return jresult;
71767 }
71768
71769
71770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
71771   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71772
71773   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71774   {
71775     try {
71776       (arg1)->Enable();
71777     } catch (std::out_of_range& e) {
71778       {
71779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71780       };
71781     } catch (std::exception& e) {
71782       {
71783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71784       };
71785     } catch (...) {
71786       {
71787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71788       };
71789     }
71790   }
71791 }
71792
71793
71794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
71795   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71796
71797   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71798   {
71799     try {
71800       (arg1)->Disable();
71801     } catch (std::out_of_range& e) {
71802       {
71803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71804       };
71805     } catch (std::exception& e) {
71806       {
71807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71808       };
71809     } catch (...) {
71810       {
71811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71812       };
71813     }
71814   }
71815 }
71816
71817
71818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
71819   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71820   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
71821   Dali::Toolkit::RulerDomain *argp2 ;
71822
71823   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71824   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
71825   if (!argp2) {
71826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
71827     return ;
71828   }
71829   arg2 = *argp2;
71830   {
71831     try {
71832       (arg1)->SetDomain(arg2);
71833     } catch (std::out_of_range& e) {
71834       {
71835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71836       };
71837     } catch (std::exception& e) {
71838       {
71839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71840       };
71841     } catch (...) {
71842       {
71843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71844       };
71845     }
71846   }
71847 }
71848
71849
71850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
71851   void * jresult ;
71852   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71853   Dali::Toolkit::RulerDomain *result = 0 ;
71854
71855   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71856   {
71857     try {
71858       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
71859     } catch (std::out_of_range& e) {
71860       {
71861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71862       };
71863     } catch (std::exception& e) {
71864       {
71865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71866       };
71867     } catch (...) {
71868       {
71869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71870       };
71871     }
71872   }
71873   jresult = (void *)result;
71874   return jresult;
71875 }
71876
71877
71878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
71879   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71880
71881   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71882   {
71883     try {
71884       (arg1)->DisableDomain();
71885     } catch (std::out_of_range& e) {
71886       {
71887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71888       };
71889     } catch (std::exception& e) {
71890       {
71891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71892       };
71893     } catch (...) {
71894       {
71895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71896       };
71897     }
71898   }
71899 }
71900
71901
71902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71903   float jresult ;
71904   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71905   float arg2 ;
71906   float arg3 ;
71907   float arg4 ;
71908   float result;
71909
71910   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71911   arg2 = (float)jarg2;
71912   arg3 = (float)jarg3;
71913   arg4 = (float)jarg4;
71914   {
71915     try {
71916       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
71917     } catch (std::out_of_range& e) {
71918       {
71919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71920       };
71921     } catch (std::exception& e) {
71922       {
71923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71924       };
71925     } catch (...) {
71926       {
71927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71928       };
71929     }
71930   }
71931   jresult = result;
71932   return jresult;
71933 }
71934
71935
71936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71937   float jresult ;
71938   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71939   float arg2 ;
71940   float arg3 ;
71941   float result;
71942
71943   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71944   arg2 = (float)jarg2;
71945   arg3 = (float)jarg3;
71946   {
71947     try {
71948       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
71949     } catch (std::out_of_range& e) {
71950       {
71951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71952       };
71953     } catch (std::exception& e) {
71954       {
71955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71956       };
71957     } catch (...) {
71958       {
71959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71960       };
71961     }
71962   }
71963   jresult = result;
71964   return jresult;
71965 }
71966
71967
71968 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
71969   float jresult ;
71970   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71971   float arg2 ;
71972   float result;
71973
71974   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71975   arg2 = (float)jarg2;
71976   {
71977     try {
71978       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
71979     } catch (std::out_of_range& e) {
71980       {
71981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71982       };
71983     } catch (std::exception& e) {
71984       {
71985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71986       };
71987     } catch (...) {
71988       {
71989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71990       };
71991     }
71992   }
71993   jresult = result;
71994   return jresult;
71995 }
71996
71997
71998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71999   float jresult ;
72000   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72001   float arg2 ;
72002   float arg3 ;
72003   float arg4 ;
72004   Dali::Toolkit::ClampState *arg5 = 0 ;
72005   float result;
72006
72007   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72008   arg2 = (float)jarg2;
72009   arg3 = (float)jarg3;
72010   arg4 = (float)jarg4;
72011   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72012   if (!arg5) {
72013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72014     return 0;
72015   }
72016   {
72017     try {
72018       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72019     } catch (std::out_of_range& e) {
72020       {
72021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72022       };
72023     } catch (std::exception& e) {
72024       {
72025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72026       };
72027     } catch (...) {
72028       {
72029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72030       };
72031     }
72032   }
72033   jresult = result;
72034   return jresult;
72035 }
72036
72037
72038 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
72039   float jresult ;
72040   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72041   float arg2 ;
72042   float arg3 ;
72043   float arg4 ;
72044   float arg5 ;
72045   float result;
72046
72047   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72048   arg2 = (float)jarg2;
72049   arg3 = (float)jarg3;
72050   arg4 = (float)jarg4;
72051   arg5 = (float)jarg5;
72052   {
72053     try {
72054       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
72055     } catch (std::out_of_range& e) {
72056       {
72057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72058       };
72059     } catch (std::exception& e) {
72060       {
72061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72062       };
72063     } catch (...) {
72064       {
72065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72066       };
72067     }
72068   }
72069   jresult = result;
72070   return jresult;
72071 }
72072
72073
72074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
72075   float jresult ;
72076   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72077   float arg2 ;
72078   float arg3 ;
72079   float arg4 ;
72080   float result;
72081
72082   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72083   arg2 = (float)jarg2;
72084   arg3 = (float)jarg3;
72085   arg4 = (float)jarg4;
72086   {
72087     try {
72088       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
72089     } catch (std::out_of_range& e) {
72090       {
72091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72092       };
72093     } catch (std::exception& e) {
72094       {
72095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72096       };
72097     } catch (...) {
72098       {
72099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72100       };
72101     }
72102   }
72103   jresult = result;
72104   return jresult;
72105 }
72106
72107
72108 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
72109   float jresult ;
72110   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72111   float arg2 ;
72112   float arg3 ;
72113   float result;
72114
72115   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72116   arg2 = (float)jarg2;
72117   arg3 = (float)jarg3;
72118   {
72119     try {
72120       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
72121     } catch (std::out_of_range& e) {
72122       {
72123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72124       };
72125     } catch (std::exception& e) {
72126       {
72127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72128       };
72129     } catch (...) {
72130       {
72131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72132       };
72133     }
72134   }
72135   jresult = result;
72136   return jresult;
72137 }
72138
72139
72140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
72141   float jresult ;
72142   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72143   float arg2 ;
72144   float result;
72145
72146   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72147   arg2 = (float)jarg2;
72148   {
72149     try {
72150       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
72151     } catch (std::out_of_range& e) {
72152       {
72153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72154       };
72155     } catch (std::exception& e) {
72156       {
72157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72158       };
72159     } catch (...) {
72160       {
72161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72162       };
72163     }
72164   }
72165   jresult = result;
72166   return jresult;
72167 }
72168
72169
72170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
72171   float jresult ;
72172   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72173   float arg2 ;
72174   float arg3 ;
72175   float arg4 ;
72176   float arg5 ;
72177   Dali::Toolkit::ClampState *arg6 = 0 ;
72178   float result;
72179
72180   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72181   arg2 = (float)jarg2;
72182   arg3 = (float)jarg3;
72183   arg4 = (float)jarg4;
72184   arg5 = (float)jarg5;
72185   arg6 = (Dali::Toolkit::ClampState *)jarg6;
72186   if (!arg6) {
72187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72188     return 0;
72189   }
72190   {
72191     try {
72192       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
72193     } catch (std::out_of_range& e) {
72194       {
72195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72196       };
72197     } catch (std::exception& e) {
72198       {
72199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72200       };
72201     } catch (...) {
72202       {
72203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72204       };
72205     }
72206   }
72207   jresult = result;
72208   return jresult;
72209 }
72210
72211
72212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
72213   void * jresult ;
72214   Dali::Toolkit::DefaultRuler *result = 0 ;
72215
72216   {
72217     try {
72218       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
72219     } catch (std::out_of_range& e) {
72220       {
72221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72222       };
72223     } catch (std::exception& e) {
72224       {
72225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72226       };
72227     } catch (...) {
72228       {
72229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72230       };
72231     }
72232   }
72233   jresult = (void *)result;
72234   return jresult;
72235 }
72236
72237
72238 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72239   float jresult ;
72240   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72241   float arg2 ;
72242   float arg3 ;
72243   float result;
72244
72245   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72246   arg2 = (float)jarg2;
72247   arg3 = (float)jarg3;
72248   {
72249     try {
72250       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
72251     } catch (std::out_of_range& e) {
72252       {
72253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72254       };
72255     } catch (std::exception& e) {
72256       {
72257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72258       };
72259     } catch (...) {
72260       {
72261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72262       };
72263     }
72264   }
72265   jresult = result;
72266   return jresult;
72267 }
72268
72269
72270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72271   float jresult ;
72272   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72273   unsigned int arg2 ;
72274   unsigned int *arg3 = 0 ;
72275   bool arg4 ;
72276   float result;
72277
72278   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72279   arg2 = (unsigned int)jarg2;
72280   arg3 = (unsigned int *)jarg3;
72281   arg4 = jarg4 ? true : false;
72282   {
72283     try {
72284       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72285     } catch (std::out_of_range& e) {
72286       {
72287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72288       };
72289     } catch (std::exception& e) {
72290       {
72291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72292       };
72293     } catch (...) {
72294       {
72295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72296       };
72297     }
72298   }
72299   jresult = result;
72300   return jresult;
72301 }
72302
72303
72304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72305   unsigned int jresult ;
72306   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72307   float arg2 ;
72308   bool arg3 ;
72309   unsigned int result;
72310
72311   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72312   arg2 = (float)jarg2;
72313   arg3 = jarg3 ? true : false;
72314   {
72315     try {
72316       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72317     } catch (std::out_of_range& e) {
72318       {
72319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72320       };
72321     } catch (std::exception& e) {
72322       {
72323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72324       };
72325     } catch (...) {
72326       {
72327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72328       };
72329     }
72330   }
72331   jresult = result;
72332   return jresult;
72333 }
72334
72335
72336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
72337   unsigned int jresult ;
72338   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72339   unsigned int result;
72340
72341   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72342   {
72343     try {
72344       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
72345     } catch (std::out_of_range& e) {
72346       {
72347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72348       };
72349     } catch (std::exception& e) {
72350       {
72351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72352       };
72353     } catch (...) {
72354       {
72355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72356       };
72357     }
72358   }
72359   jresult = result;
72360   return jresult;
72361 }
72362
72363
72364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
72365   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72366
72367   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72368   {
72369     try {
72370       delete arg1;
72371     } catch (std::out_of_range& e) {
72372       {
72373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72374       };
72375     } catch (std::exception& e) {
72376       {
72377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72378       };
72379     } catch (...) {
72380       {
72381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72382       };
72383     }
72384   }
72385 }
72386
72387
72388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
72389   void * jresult ;
72390   float arg1 ;
72391   Dali::Toolkit::FixedRuler *result = 0 ;
72392
72393   arg1 = (float)jarg1;
72394   {
72395     try {
72396       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
72397     } catch (std::out_of_range& e) {
72398       {
72399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72400       };
72401     } catch (std::exception& e) {
72402       {
72403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72404       };
72405     } catch (...) {
72406       {
72407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72408       };
72409     }
72410   }
72411   jresult = (void *)result;
72412   return jresult;
72413 }
72414
72415
72416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
72417   void * jresult ;
72418   Dali::Toolkit::FixedRuler *result = 0 ;
72419
72420   {
72421     try {
72422       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
72423     } catch (std::out_of_range& e) {
72424       {
72425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72426       };
72427     } catch (std::exception& e) {
72428       {
72429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72430       };
72431     } catch (...) {
72432       {
72433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72434       };
72435     }
72436   }
72437   jresult = (void *)result;
72438   return jresult;
72439 }
72440
72441
72442 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72443   float jresult ;
72444   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72445   float arg2 ;
72446   float arg3 ;
72447   float result;
72448
72449   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72450   arg2 = (float)jarg2;
72451   arg3 = (float)jarg3;
72452   {
72453     try {
72454       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
72455     } catch (std::out_of_range& e) {
72456       {
72457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72458       };
72459     } catch (std::exception& e) {
72460       {
72461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72462       };
72463     } catch (...) {
72464       {
72465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72466       };
72467     }
72468   }
72469   jresult = result;
72470   return jresult;
72471 }
72472
72473
72474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72475   float jresult ;
72476   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72477   unsigned int arg2 ;
72478   unsigned int *arg3 = 0 ;
72479   bool arg4 ;
72480   float result;
72481
72482   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72483   arg2 = (unsigned int)jarg2;
72484   arg3 = (unsigned int *)jarg3;
72485   arg4 = jarg4 ? true : false;
72486   {
72487     try {
72488       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72489     } catch (std::out_of_range& e) {
72490       {
72491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72492       };
72493     } catch (std::exception& e) {
72494       {
72495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72496       };
72497     } catch (...) {
72498       {
72499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72500       };
72501     }
72502   }
72503   jresult = result;
72504   return jresult;
72505 }
72506
72507
72508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72509   unsigned int jresult ;
72510   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72511   float arg2 ;
72512   bool arg3 ;
72513   unsigned int result;
72514
72515   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72516   arg2 = (float)jarg2;
72517   arg3 = jarg3 ? true : false;
72518   {
72519     try {
72520       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72521     } catch (std::out_of_range& e) {
72522       {
72523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72524       };
72525     } catch (std::exception& e) {
72526       {
72527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72528       };
72529     } catch (...) {
72530       {
72531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72532       };
72533     }
72534   }
72535   jresult = result;
72536   return jresult;
72537 }
72538
72539
72540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
72541   unsigned int jresult ;
72542   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72543   unsigned int result;
72544
72545   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72546   {
72547     try {
72548       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
72549     } catch (std::out_of_range& e) {
72550       {
72551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72552       };
72553     } catch (std::exception& e) {
72554       {
72555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72556       };
72557     } catch (...) {
72558       {
72559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72560       };
72561     }
72562   }
72563   jresult = result;
72564   return jresult;
72565 }
72566
72567
72568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
72569   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72570
72571   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72572   {
72573     try {
72574       delete arg1;
72575     } catch (std::out_of_range& e) {
72576       {
72577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72578       };
72579     } catch (std::exception& e) {
72580       {
72581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72582       };
72583     } catch (...) {
72584       {
72585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72586       };
72587     }
72588   }
72589 }
72590
72591
72592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
72593   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72594   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72595
72596   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72597   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72598   if (arg1) (arg1)->scale = *arg2;
72599 }
72600
72601
72602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
72603   void * jresult ;
72604   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72605   Dali::Toolkit::ClampState2D *result = 0 ;
72606
72607   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72608   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
72609   jresult = (void *)result;
72610   return jresult;
72611 }
72612
72613
72614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
72615   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72616   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72617
72618   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72619   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72620   if (arg1) (arg1)->position = *arg2;
72621 }
72622
72623
72624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
72625   void * jresult ;
72626   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72627   Dali::Toolkit::ClampState2D *result = 0 ;
72628
72629   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72630   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
72631   jresult = (void *)result;
72632   return jresult;
72633 }
72634
72635
72636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
72637   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72638   Dali::Toolkit::ClampState arg2 ;
72639
72640   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72641   arg2 = (Dali::Toolkit::ClampState)jarg2;
72642   if (arg1) (arg1)->rotation = arg2;
72643 }
72644
72645
72646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
72647   int jresult ;
72648   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72649   Dali::Toolkit::ClampState result;
72650
72651   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72652   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
72653   jresult = (int)result;
72654   return jresult;
72655 }
72656
72657
72658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
72659   void * jresult ;
72660   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
72661
72662   {
72663     try {
72664       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
72665     } catch (std::out_of_range& e) {
72666       {
72667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72668       };
72669     } catch (std::exception& e) {
72670       {
72671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72672       };
72673     } catch (...) {
72674       {
72675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72676       };
72677     }
72678   }
72679   jresult = (void *)result;
72680   return jresult;
72681 }
72682
72683
72684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
72685   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72686
72687   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72688   {
72689     try {
72690       delete arg1;
72691     } catch (std::out_of_range& e) {
72692       {
72693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72694       };
72695     } catch (std::exception& e) {
72696       {
72697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72698       };
72699     } catch (...) {
72700       {
72701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72702       };
72703     }
72704   }
72705 }
72706
72707
72708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
72709   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72710   Dali::Toolkit::SnapType arg2 ;
72711
72712   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72713   arg2 = (Dali::Toolkit::SnapType)jarg2;
72714   if (arg1) (arg1)->type = arg2;
72715 }
72716
72717
72718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
72719   int jresult ;
72720   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72721   Dali::Toolkit::SnapType result;
72722
72723   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72724   result = (Dali::Toolkit::SnapType) ((arg1)->type);
72725   jresult = (int)result;
72726   return jresult;
72727 }
72728
72729
72730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
72731   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72732   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
72733
72734   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72735   arg2 = (Dali::Vector2 *)jarg2;
72736   if (arg1) (arg1)->position = *arg2;
72737 }
72738
72739
72740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
72741   void * jresult ;
72742   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72743   Dali::Vector2 *result = 0 ;
72744
72745   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72746   result = (Dali::Vector2 *)& ((arg1)->position);
72747   jresult = (void *)result;
72748   return jresult;
72749 }
72750
72751
72752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
72753   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72754   float arg2 ;
72755
72756   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72757   arg2 = (float)jarg2;
72758   if (arg1) (arg1)->duration = arg2;
72759 }
72760
72761
72762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
72763   float jresult ;
72764   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72765   float result;
72766
72767   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72768   result = (float) ((arg1)->duration);
72769   jresult = result;
72770   return jresult;
72771 }
72772
72773
72774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
72775   void * jresult ;
72776   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
72777
72778   {
72779     try {
72780       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
72781     } catch (std::out_of_range& e) {
72782       {
72783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72784       };
72785     } catch (std::exception& e) {
72786       {
72787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72788       };
72789     } catch (...) {
72790       {
72791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72792       };
72793     }
72794   }
72795   jresult = (void *)result;
72796   return jresult;
72797 }
72798
72799
72800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
72801   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72802
72803   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72804   {
72805     try {
72806       delete arg1;
72807     } catch (std::out_of_range& e) {
72808       {
72809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72810       };
72811     } catch (std::exception& e) {
72812       {
72813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72814       };
72815     } catch (...) {
72816       {
72817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72818       };
72819     }
72820   }
72821 }
72822
72823
72824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
72825   int jresult ;
72826   int result;
72827
72828   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
72829   jresult = (int)result;
72830   return jresult;
72831 }
72832
72833
72834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
72835   int jresult ;
72836   int result;
72837
72838   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
72839   jresult = (int)result;
72840   return jresult;
72841 }
72842
72843
72844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
72845   int jresult ;
72846   int result;
72847
72848   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
72849   jresult = (int)result;
72850   return jresult;
72851 }
72852
72853
72854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
72855   int jresult ;
72856   int result;
72857
72858   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
72859   jresult = (int)result;
72860   return jresult;
72861 }
72862
72863
72864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
72865   int jresult ;
72866   int result;
72867
72868   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
72869   jresult = (int)result;
72870   return jresult;
72871 }
72872
72873
72874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
72875   int jresult ;
72876   int result;
72877
72878   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
72879   jresult = (int)result;
72880   return jresult;
72881 }
72882
72883
72884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
72885   int jresult ;
72886   int result;
72887
72888   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
72889   jresult = (int)result;
72890   return jresult;
72891 }
72892
72893
72894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
72895   int jresult ;
72896   int result;
72897
72898   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
72899   jresult = (int)result;
72900   return jresult;
72901 }
72902
72903
72904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
72905   int jresult ;
72906   int result;
72907
72908   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
72909   jresult = (int)result;
72910   return jresult;
72911 }
72912
72913
72914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
72915   int jresult ;
72916   int result;
72917
72918   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
72919   jresult = (int)result;
72920   return jresult;
72921 }
72922
72923
72924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
72925   int jresult ;
72926   int result;
72927
72928   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
72929   jresult = (int)result;
72930   return jresult;
72931 }
72932
72933
72934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
72935   int jresult ;
72936   int result;
72937
72938   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
72939   jresult = (int)result;
72940   return jresult;
72941 }
72942
72943
72944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
72945   int jresult ;
72946   int result;
72947
72948   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
72949   jresult = (int)result;
72950   return jresult;
72951 }
72952
72953
72954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
72955   int jresult ;
72956   int result;
72957
72958   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
72959   jresult = (int)result;
72960   return jresult;
72961 }
72962
72963
72964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
72965   int jresult ;
72966   int result;
72967
72968   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
72969   jresult = (int)result;
72970   return jresult;
72971 }
72972
72973
72974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
72975   int jresult ;
72976   int result;
72977
72978   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
72979   jresult = (int)result;
72980   return jresult;
72981 }
72982
72983
72984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
72985   int jresult ;
72986   int result;
72987
72988   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
72989   jresult = (int)result;
72990   return jresult;
72991 }
72992
72993
72994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
72995   int jresult ;
72996   int result;
72997
72998   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
72999   jresult = (int)result;
73000   return jresult;
73001 }
73002
73003
73004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
73005   int jresult ;
73006   int result;
73007
73008   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
73009   jresult = (int)result;
73010   return jresult;
73011 }
73012
73013
73014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
73015   int jresult ;
73016   int result;
73017
73018   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
73019   jresult = (int)result;
73020   return jresult;
73021 }
73022
73023
73024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
73025   int jresult ;
73026   int result;
73027
73028   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
73029   jresult = (int)result;
73030   return jresult;
73031 }
73032
73033
73034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
73035   int jresult ;
73036   int result;
73037
73038   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
73039   jresult = (int)result;
73040   return jresult;
73041 }
73042
73043
73044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
73045   int jresult ;
73046   int result;
73047
73048   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
73049   jresult = (int)result;
73050   return jresult;
73051 }
73052
73053
73054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
73055   int jresult ;
73056   int result;
73057
73058   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
73059   jresult = (int)result;
73060   return jresult;
73061 }
73062
73063
73064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
73065   int jresult ;
73066   int result;
73067
73068   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
73069   jresult = (int)result;
73070   return jresult;
73071 }
73072
73073
73074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
73075   void * jresult ;
73076   Dali::Toolkit::ScrollView::Property *result = 0 ;
73077
73078   {
73079     try {
73080       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
73081     } catch (std::out_of_range& e) {
73082       {
73083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73084       };
73085     } catch (std::exception& e) {
73086       {
73087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73088       };
73089     } catch (...) {
73090       {
73091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73092       };
73093     }
73094   }
73095   jresult = (void *)result;
73096   return jresult;
73097 }
73098
73099
73100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
73101   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
73102
73103   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
73104   {
73105     try {
73106       delete arg1;
73107     } catch (std::out_of_range& e) {
73108       {
73109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73110       };
73111     } catch (std::exception& e) {
73112       {
73113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73114       };
73115     } catch (...) {
73116       {
73117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73118       };
73119     }
73120   }
73121 }
73122
73123
73124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
73125   void * jresult ;
73126   Dali::Toolkit::ScrollView *result = 0 ;
73127
73128   {
73129     try {
73130       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
73131     } catch (std::out_of_range& e) {
73132       {
73133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73134       };
73135     } catch (std::exception& e) {
73136       {
73137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73138       };
73139     } catch (...) {
73140       {
73141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73142       };
73143     }
73144   }
73145   jresult = (void *)result;
73146   return jresult;
73147 }
73148
73149
73150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
73151   void * jresult ;
73152   Dali::Toolkit::ScrollView *arg1 = 0 ;
73153   Dali::Toolkit::ScrollView *result = 0 ;
73154
73155   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73156   if (!arg1) {
73157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73158     return 0;
73159   }
73160   {
73161     try {
73162       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
73163     } catch (std::out_of_range& e) {
73164       {
73165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73166       };
73167     } catch (std::exception& e) {
73168       {
73169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73170       };
73171     } catch (...) {
73172       {
73173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73174       };
73175     }
73176   }
73177   jresult = (void *)result;
73178   return jresult;
73179 }
73180
73181
73182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
73183   void * jresult ;
73184   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73185   Dali::Toolkit::ScrollView *arg2 = 0 ;
73186   Dali::Toolkit::ScrollView *result = 0 ;
73187
73188   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73189   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
73190   if (!arg2) {
73191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73192     return 0;
73193   }
73194   {
73195     try {
73196       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
73197     } catch (std::out_of_range& e) {
73198       {
73199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73200       };
73201     } catch (std::exception& e) {
73202       {
73203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73204       };
73205     } catch (...) {
73206       {
73207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73208       };
73209     }
73210   }
73211   jresult = (void *)result;
73212   return jresult;
73213 }
73214
73215
73216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
73217   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73218
73219   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73220   {
73221     try {
73222       delete arg1;
73223     } catch (std::out_of_range& e) {
73224       {
73225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73226       };
73227     } catch (std::exception& e) {
73228       {
73229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73230       };
73231     } catch (...) {
73232       {
73233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73234       };
73235     }
73236   }
73237 }
73238
73239
73240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
73241   void * jresult ;
73242   Dali::Toolkit::ScrollView result;
73243
73244   {
73245     try {
73246       result = Dali::Toolkit::ScrollView::New();
73247     } catch (std::out_of_range& e) {
73248       {
73249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73250       };
73251     } catch (std::exception& e) {
73252       {
73253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73254       };
73255     } catch (...) {
73256       {
73257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73258       };
73259     }
73260   }
73261   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73262   return jresult;
73263 }
73264
73265
73266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
73267   void * jresult ;
73268   Dali::BaseHandle arg1 ;
73269   Dali::BaseHandle *argp1 ;
73270   Dali::Toolkit::ScrollView result;
73271
73272   argp1 = (Dali::BaseHandle *)jarg1;
73273   if (!argp1) {
73274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73275     return 0;
73276   }
73277   arg1 = *argp1;
73278   {
73279     try {
73280       result = Dali::Toolkit::ScrollView::DownCast(arg1);
73281     } catch (std::out_of_range& e) {
73282       {
73283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73284       };
73285     } catch (std::exception& e) {
73286       {
73287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73288       };
73289     } catch (...) {
73290       {
73291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73292       };
73293     }
73294   }
73295   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73296   return jresult;
73297 }
73298
73299
73300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
73301   void * jresult ;
73302   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73303   Dali::AlphaFunction result;
73304
73305   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73306   {
73307     try {
73308       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
73309     } catch (std::out_of_range& e) {
73310       {
73311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73312       };
73313     } catch (std::exception& e) {
73314       {
73315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73316       };
73317     } catch (...) {
73318       {
73319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73320       };
73321     }
73322   }
73323   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73324   return jresult;
73325 }
73326
73327
73328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
73329   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73330   Dali::AlphaFunction arg2 ;
73331   Dali::AlphaFunction *argp2 ;
73332
73333   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73334   argp2 = (Dali::AlphaFunction *)jarg2;
73335   if (!argp2) {
73336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73337     return ;
73338   }
73339   arg2 = *argp2;
73340   {
73341     try {
73342       (arg1)->SetScrollSnapAlphaFunction(arg2);
73343     } catch (std::out_of_range& e) {
73344       {
73345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73346       };
73347     } catch (std::exception& e) {
73348       {
73349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73350       };
73351     } catch (...) {
73352       {
73353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73354       };
73355     }
73356   }
73357 }
73358
73359
73360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
73361   void * jresult ;
73362   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73363   Dali::AlphaFunction result;
73364
73365   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73366   {
73367     try {
73368       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
73369     } catch (std::out_of_range& e) {
73370       {
73371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73372       };
73373     } catch (std::exception& e) {
73374       {
73375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73376       };
73377     } catch (...) {
73378       {
73379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73380       };
73381     }
73382   }
73383   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73384   return jresult;
73385 }
73386
73387
73388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
73389   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73390   Dali::AlphaFunction arg2 ;
73391   Dali::AlphaFunction *argp2 ;
73392
73393   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73394   argp2 = (Dali::AlphaFunction *)jarg2;
73395   if (!argp2) {
73396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73397     return ;
73398   }
73399   arg2 = *argp2;
73400   {
73401     try {
73402       (arg1)->SetScrollFlickAlphaFunction(arg2);
73403     } catch (std::out_of_range& e) {
73404       {
73405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73406       };
73407     } catch (std::exception& e) {
73408       {
73409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73410       };
73411     } catch (...) {
73412       {
73413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73414       };
73415     }
73416   }
73417 }
73418
73419
73420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
73421   float jresult ;
73422   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73423   float result;
73424
73425   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73426   {
73427     try {
73428       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
73429     } catch (std::out_of_range& e) {
73430       {
73431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73432       };
73433     } catch (std::exception& e) {
73434       {
73435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73436       };
73437     } catch (...) {
73438       {
73439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73440       };
73441     }
73442   }
73443   jresult = result;
73444   return jresult;
73445 }
73446
73447
73448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
73449   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73450   float arg2 ;
73451
73452   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73453   arg2 = (float)jarg2;
73454   {
73455     try {
73456       (arg1)->SetScrollSnapDuration(arg2);
73457     } catch (std::out_of_range& e) {
73458       {
73459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73460       };
73461     } catch (std::exception& e) {
73462       {
73463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73464       };
73465     } catch (...) {
73466       {
73467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73468       };
73469     }
73470   }
73471 }
73472
73473
73474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
73475   float jresult ;
73476   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73477   float result;
73478
73479   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73480   {
73481     try {
73482       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
73483     } catch (std::out_of_range& e) {
73484       {
73485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73486       };
73487     } catch (std::exception& e) {
73488       {
73489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73490       };
73491     } catch (...) {
73492       {
73493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73494       };
73495     }
73496   }
73497   jresult = result;
73498   return jresult;
73499 }
73500
73501
73502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
73503   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73504   float arg2 ;
73505
73506   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73507   arg2 = (float)jarg2;
73508   {
73509     try {
73510       (arg1)->SetScrollFlickDuration(arg2);
73511     } catch (std::out_of_range& e) {
73512       {
73513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73514       };
73515     } catch (std::exception& e) {
73516       {
73517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73518       };
73519     } catch (...) {
73520       {
73521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73522       };
73523     }
73524   }
73525 }
73526
73527
73528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
73529   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73530   Dali::Toolkit::RulerPtr arg2 ;
73531   Dali::Toolkit::RulerPtr *argp2 ;
73532
73533   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73534   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73535   if (!argp2) {
73536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73537     return ;
73538   }
73539   arg2 = *argp2;
73540   {
73541     try {
73542       (arg1)->SetRulerX(arg2);
73543     } catch (std::out_of_range& e) {
73544       {
73545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73546       };
73547     } catch (std::exception& e) {
73548       {
73549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73550       };
73551     } catch (...) {
73552       {
73553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73554       };
73555     }
73556   }
73557 }
73558
73559
73560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
73561   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73562   Dali::Toolkit::RulerPtr arg2 ;
73563   Dali::Toolkit::RulerPtr *argp2 ;
73564
73565   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73566   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73567   if (!argp2) {
73568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73569     return ;
73570   }
73571   arg2 = *argp2;
73572   {
73573     try {
73574       (arg1)->SetRulerY(arg2);
73575     } catch (std::out_of_range& e) {
73576       {
73577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73578       };
73579     } catch (std::exception& e) {
73580       {
73581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73582       };
73583     } catch (...) {
73584       {
73585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73586       };
73587     }
73588   }
73589 }
73590
73591
73592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
73593   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73594   bool arg2 ;
73595
73596   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73597   arg2 = jarg2 ? true : false;
73598   {
73599     try {
73600       (arg1)->SetScrollSensitive(arg2);
73601     } catch (std::out_of_range& e) {
73602       {
73603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73604       };
73605     } catch (std::exception& e) {
73606       {
73607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73608       };
73609     } catch (...) {
73610       {
73611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73612       };
73613     }
73614   }
73615 }
73616
73617
73618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
73619   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73620   float arg2 ;
73621   float arg3 ;
73622
73623   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73624   arg2 = (float)jarg2;
73625   arg3 = (float)jarg3;
73626   {
73627     try {
73628       (arg1)->SetMaxOvershoot(arg2,arg3);
73629     } catch (std::out_of_range& e) {
73630       {
73631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73632       };
73633     } catch (std::exception& e) {
73634       {
73635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73636       };
73637     } catch (...) {
73638       {
73639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73640       };
73641     }
73642   }
73643 }
73644
73645
73646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
73647   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73648   Dali::AlphaFunction arg2 ;
73649   Dali::AlphaFunction *argp2 ;
73650
73651   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73652   argp2 = (Dali::AlphaFunction *)jarg2;
73653   if (!argp2) {
73654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73655     return ;
73656   }
73657   arg2 = *argp2;
73658   {
73659     try {
73660       (arg1)->SetSnapOvershootAlphaFunction(arg2);
73661     } catch (std::out_of_range& e) {
73662       {
73663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73664       };
73665     } catch (std::exception& e) {
73666       {
73667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73668       };
73669     } catch (...) {
73670       {
73671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73672       };
73673     }
73674   }
73675 }
73676
73677
73678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
73679   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73680   float arg2 ;
73681
73682   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73683   arg2 = (float)jarg2;
73684   {
73685     try {
73686       (arg1)->SetSnapOvershootDuration(arg2);
73687     } catch (std::out_of_range& e) {
73688       {
73689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73690       };
73691     } catch (std::exception& e) {
73692       {
73693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73694       };
73695     } catch (...) {
73696       {
73697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73698       };
73699     }
73700   }
73701 }
73702
73703
73704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
73705   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73706   bool arg2 ;
73707
73708   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73709   arg2 = jarg2 ? true : false;
73710   {
73711     try {
73712       (arg1)->SetActorAutoSnap(arg2);
73713     } catch (std::out_of_range& e) {
73714       {
73715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73716       };
73717     } catch (std::exception& e) {
73718       {
73719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73720       };
73721     } catch (...) {
73722       {
73723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73724       };
73725     }
73726   }
73727 }
73728
73729
73730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
73731   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73732   bool arg2 ;
73733
73734   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73735   arg2 = jarg2 ? true : false;
73736   {
73737     try {
73738       (arg1)->SetWrapMode(arg2);
73739     } catch (std::out_of_range& e) {
73740       {
73741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73742       };
73743     } catch (std::exception& e) {
73744       {
73745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73746       };
73747     } catch (...) {
73748       {
73749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73750       };
73751     }
73752   }
73753 }
73754
73755
73756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
73757   int jresult ;
73758   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73759   int result;
73760
73761   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73762   {
73763     try {
73764       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
73765     } catch (std::out_of_range& e) {
73766       {
73767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73768       };
73769     } catch (std::exception& e) {
73770       {
73771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73772       };
73773     } catch (...) {
73774       {
73775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73776       };
73777     }
73778   }
73779   jresult = result;
73780   return jresult;
73781 }
73782
73783
73784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
73785   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73786   int arg2 ;
73787
73788   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73789   arg2 = (int)jarg2;
73790   {
73791     try {
73792       (arg1)->SetScrollUpdateDistance(arg2);
73793     } catch (std::out_of_range& e) {
73794       {
73795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73796       };
73797     } catch (std::exception& e) {
73798       {
73799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73800       };
73801     } catch (...) {
73802       {
73803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73804       };
73805     }
73806   }
73807 }
73808
73809
73810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
73811   unsigned int jresult ;
73812   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73813   bool result;
73814
73815   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73816   {
73817     try {
73818       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
73819     } catch (std::out_of_range& e) {
73820       {
73821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73822       };
73823     } catch (std::exception& e) {
73824       {
73825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73826       };
73827     } catch (...) {
73828       {
73829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73830       };
73831     }
73832   }
73833   jresult = result;
73834   return jresult;
73835 }
73836
73837
73838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
73839   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73840   bool arg2 ;
73841
73842   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73843   arg2 = jarg2 ? true : false;
73844   {
73845     try {
73846       (arg1)->SetAxisAutoLock(arg2);
73847     } catch (std::out_of_range& e) {
73848       {
73849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73850       };
73851     } catch (std::exception& e) {
73852       {
73853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73854       };
73855     } catch (...) {
73856       {
73857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73858       };
73859     }
73860   }
73861 }
73862
73863
73864 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
73865   float jresult ;
73866   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73867   float result;
73868
73869   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73870   {
73871     try {
73872       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
73873     } catch (std::out_of_range& e) {
73874       {
73875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73876       };
73877     } catch (std::exception& e) {
73878       {
73879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73880       };
73881     } catch (...) {
73882       {
73883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73884       };
73885     }
73886   }
73887   jresult = result;
73888   return jresult;
73889 }
73890
73891
73892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
73893   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73894   float arg2 ;
73895
73896   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73897   arg2 = (float)jarg2;
73898   {
73899     try {
73900       (arg1)->SetAxisAutoLockGradient(arg2);
73901     } catch (std::out_of_range& e) {
73902       {
73903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73904       };
73905     } catch (std::exception& e) {
73906       {
73907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73908       };
73909     } catch (...) {
73910       {
73911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73912       };
73913     }
73914   }
73915 }
73916
73917
73918 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
73919   float jresult ;
73920   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73921   float result;
73922
73923   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73924   {
73925     try {
73926       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
73927     } catch (std::out_of_range& e) {
73928       {
73929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73930       };
73931     } catch (std::exception& e) {
73932       {
73933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73934       };
73935     } catch (...) {
73936       {
73937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73938       };
73939     }
73940   }
73941   jresult = result;
73942   return jresult;
73943 }
73944
73945
73946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
73947   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73948   float arg2 ;
73949
73950   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73951   arg2 = (float)jarg2;
73952   {
73953     try {
73954       (arg1)->SetFrictionCoefficient(arg2);
73955     } catch (std::out_of_range& e) {
73956       {
73957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73958       };
73959     } catch (std::exception& e) {
73960       {
73961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73962       };
73963     } catch (...) {
73964       {
73965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73966       };
73967     }
73968   }
73969 }
73970
73971
73972 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
73973   float jresult ;
73974   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73975   float result;
73976
73977   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73978   {
73979     try {
73980       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
73981     } catch (std::out_of_range& e) {
73982       {
73983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73984       };
73985     } catch (std::exception& e) {
73986       {
73987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73988       };
73989     } catch (...) {
73990       {
73991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73992       };
73993     }
73994   }
73995   jresult = result;
73996   return jresult;
73997 }
73998
73999
74000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
74001   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74002   float arg2 ;
74003
74004   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74005   arg2 = (float)jarg2;
74006   {
74007     try {
74008       (arg1)->SetFlickSpeedCoefficient(arg2);
74009     } catch (std::out_of_range& e) {
74010       {
74011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74012       };
74013     } catch (std::exception& e) {
74014       {
74015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74016       };
74017     } catch (...) {
74018       {
74019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74020       };
74021     }
74022   }
74023 }
74024
74025
74026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
74027   void * jresult ;
74028   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74029   Dali::Vector2 result;
74030
74031   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74032   {
74033     try {
74034       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
74035     } catch (std::out_of_range& e) {
74036       {
74037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74038       };
74039     } catch (std::exception& e) {
74040       {
74041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74042       };
74043     } catch (...) {
74044       {
74045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74046       };
74047     }
74048   }
74049   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74050   return jresult;
74051 }
74052
74053
74054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
74055   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74056   Dali::Vector2 *arg2 = 0 ;
74057
74058   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74059   arg2 = (Dali::Vector2 *)jarg2;
74060   if (!arg2) {
74061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74062     return ;
74063   }
74064   {
74065     try {
74066       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
74067     } catch (std::out_of_range& e) {
74068       {
74069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74070       };
74071     } catch (std::exception& e) {
74072       {
74073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74074       };
74075     } catch (...) {
74076       {
74077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74078       };
74079     }
74080   }
74081 }
74082
74083
74084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
74085   float jresult ;
74086   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74087   float result;
74088
74089   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74090   {
74091     try {
74092       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
74093     } catch (std::out_of_range& e) {
74094       {
74095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74096       };
74097     } catch (std::exception& e) {
74098       {
74099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74100       };
74101     } catch (...) {
74102       {
74103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74104       };
74105     }
74106   }
74107   jresult = result;
74108   return jresult;
74109 }
74110
74111
74112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
74113   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74114   float arg2 ;
74115
74116   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74117   arg2 = (float)jarg2;
74118   {
74119     try {
74120       (arg1)->SetMinimumSpeedForFlick(arg2);
74121     } catch (std::out_of_range& e) {
74122       {
74123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74124       };
74125     } catch (std::exception& e) {
74126       {
74127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74128       };
74129     } catch (...) {
74130       {
74131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74132       };
74133     }
74134   }
74135 }
74136
74137
74138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
74139   float jresult ;
74140   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74141   float result;
74142
74143   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74144   {
74145     try {
74146       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
74147     } catch (std::out_of_range& e) {
74148       {
74149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74150       };
74151     } catch (std::exception& e) {
74152       {
74153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74154       };
74155     } catch (...) {
74156       {
74157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74158       };
74159     }
74160   }
74161   jresult = result;
74162   return jresult;
74163 }
74164
74165
74166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
74167   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74168   float arg2 ;
74169
74170   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74171   arg2 = (float)jarg2;
74172   {
74173     try {
74174       (arg1)->SetMaxFlickSpeed(arg2);
74175     } catch (std::out_of_range& e) {
74176       {
74177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74178       };
74179     } catch (std::exception& e) {
74180       {
74181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74182       };
74183     } catch (...) {
74184       {
74185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74186       };
74187     }
74188   }
74189 }
74190
74191
74192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
74193   void * jresult ;
74194   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74195   Dali::Vector2 result;
74196
74197   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74198   {
74199     try {
74200       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
74201     } catch (std::out_of_range& e) {
74202       {
74203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74204       };
74205     } catch (std::exception& e) {
74206       {
74207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74208       };
74209     } catch (...) {
74210       {
74211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74212       };
74213     }
74214   }
74215   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74216   return jresult;
74217 }
74218
74219
74220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
74221   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74222   Dali::Vector2 arg2 ;
74223   Dali::Vector2 *argp2 ;
74224
74225   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74226   argp2 = (Dali::Vector2 *)jarg2;
74227   if (!argp2) {
74228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
74229     return ;
74230   }
74231   arg2 = *argp2;
74232   {
74233     try {
74234       (arg1)->SetWheelScrollDistanceStep(arg2);
74235     } catch (std::out_of_range& e) {
74236       {
74237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74238       };
74239     } catch (std::exception& e) {
74240       {
74241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74242       };
74243     } catch (...) {
74244       {
74245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74246       };
74247     }
74248   }
74249 }
74250
74251
74252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
74253   void * jresult ;
74254   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74255   Dali::Vector2 result;
74256
74257   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74258   {
74259     try {
74260       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
74261     } catch (std::out_of_range& e) {
74262       {
74263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74264       };
74265     } catch (std::exception& e) {
74266       {
74267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74268       };
74269     } catch (...) {
74270       {
74271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74272       };
74273     }
74274   }
74275   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74276   return jresult;
74277 }
74278
74279
74280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
74281   unsigned int jresult ;
74282   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74283   unsigned int result;
74284
74285   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74286   {
74287     try {
74288       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
74289     } catch (std::out_of_range& e) {
74290       {
74291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74292       };
74293     } catch (std::exception& e) {
74294       {
74295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74296       };
74297     } catch (...) {
74298       {
74299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74300       };
74301     }
74302   }
74303   jresult = result;
74304   return jresult;
74305 }
74306
74307
74308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
74309   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74310   Dali::Vector2 *arg2 = 0 ;
74311
74312   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74313   arg2 = (Dali::Vector2 *)jarg2;
74314   if (!arg2) {
74315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74316     return ;
74317   }
74318   {
74319     try {
74320       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
74321     } catch (std::out_of_range& e) {
74322       {
74323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74324       };
74325     } catch (std::exception& e) {
74326       {
74327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74328       };
74329     } catch (...) {
74330       {
74331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74332       };
74333     }
74334   }
74335 }
74336
74337
74338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
74339   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74340   Dali::Vector2 *arg2 = 0 ;
74341   float arg3 ;
74342
74343   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74344   arg2 = (Dali::Vector2 *)jarg2;
74345   if (!arg2) {
74346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74347     return ;
74348   }
74349   arg3 = (float)jarg3;
74350   {
74351     try {
74352       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
74353     } catch (std::out_of_range& e) {
74354       {
74355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74356       };
74357     } catch (std::exception& e) {
74358       {
74359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74360       };
74361     } catch (...) {
74362       {
74363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74364       };
74365     }
74366   }
74367 }
74368
74369
74370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
74371   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74372   Dali::Vector2 *arg2 = 0 ;
74373   float arg3 ;
74374   Dali::AlphaFunction arg4 ;
74375   Dali::AlphaFunction *argp4 ;
74376
74377   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74378   arg2 = (Dali::Vector2 *)jarg2;
74379   if (!arg2) {
74380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74381     return ;
74382   }
74383   arg3 = (float)jarg3;
74384   argp4 = (Dali::AlphaFunction *)jarg4;
74385   if (!argp4) {
74386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74387     return ;
74388   }
74389   arg4 = *argp4;
74390   {
74391     try {
74392       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
74393     } catch (std::out_of_range& e) {
74394       {
74395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74396       };
74397     } catch (std::exception& e) {
74398       {
74399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74400       };
74401     } catch (...) {
74402       {
74403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74404       };
74405     }
74406   }
74407 }
74408
74409
74410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
74411   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74412   Dali::Vector2 *arg2 = 0 ;
74413   float arg3 ;
74414   Dali::Toolkit::DirectionBias arg4 ;
74415   Dali::Toolkit::DirectionBias arg5 ;
74416
74417   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74418   arg2 = (Dali::Vector2 *)jarg2;
74419   if (!arg2) {
74420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74421     return ;
74422   }
74423   arg3 = (float)jarg3;
74424   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74425   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74426   {
74427     try {
74428       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
74429     } catch (std::out_of_range& e) {
74430       {
74431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74432       };
74433     } catch (std::exception& e) {
74434       {
74435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74436       };
74437     } catch (...) {
74438       {
74439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74440       };
74441     }
74442   }
74443 }
74444
74445
74446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
74447   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74448   Dali::Vector2 *arg2 = 0 ;
74449   float arg3 ;
74450   Dali::AlphaFunction arg4 ;
74451   Dali::Toolkit::DirectionBias arg5 ;
74452   Dali::Toolkit::DirectionBias arg6 ;
74453   Dali::AlphaFunction *argp4 ;
74454
74455   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74456   arg2 = (Dali::Vector2 *)jarg2;
74457   if (!arg2) {
74458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74459     return ;
74460   }
74461   arg3 = (float)jarg3;
74462   argp4 = (Dali::AlphaFunction *)jarg4;
74463   if (!argp4) {
74464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74465     return ;
74466   }
74467   arg4 = *argp4;
74468   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74469   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
74470   {
74471     try {
74472       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
74473     } catch (std::out_of_range& e) {
74474       {
74475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74476       };
74477     } catch (std::exception& e) {
74478       {
74479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74480       };
74481     } catch (...) {
74482       {
74483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74484       };
74485     }
74486   }
74487 }
74488
74489
74490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
74491   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74492   unsigned int arg2 ;
74493
74494   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74495   arg2 = (unsigned int)jarg2;
74496   {
74497     try {
74498       (arg1)->ScrollTo(arg2);
74499     } catch (std::out_of_range& e) {
74500       {
74501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74502       };
74503     } catch (std::exception& e) {
74504       {
74505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74506       };
74507     } catch (...) {
74508       {
74509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74510       };
74511     }
74512   }
74513 }
74514
74515
74516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
74517   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74518   unsigned int arg2 ;
74519   float arg3 ;
74520
74521   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74522   arg2 = (unsigned int)jarg2;
74523   arg3 = (float)jarg3;
74524   {
74525     try {
74526       (arg1)->ScrollTo(arg2,arg3);
74527     } catch (std::out_of_range& e) {
74528       {
74529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74530       };
74531     } catch (std::exception& e) {
74532       {
74533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74534       };
74535     } catch (...) {
74536       {
74537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74538       };
74539     }
74540   }
74541 }
74542
74543
74544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
74545   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74546   unsigned int arg2 ;
74547   float arg3 ;
74548   Dali::Toolkit::DirectionBias arg4 ;
74549
74550   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74551   arg2 = (unsigned int)jarg2;
74552   arg3 = (float)jarg3;
74553   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74554   {
74555     try {
74556       (arg1)->ScrollTo(arg2,arg3,arg4);
74557     } catch (std::out_of_range& e) {
74558       {
74559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74560       };
74561     } catch (std::exception& e) {
74562       {
74563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74564       };
74565     } catch (...) {
74566       {
74567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74568       };
74569     }
74570   }
74571 }
74572
74573
74574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
74575   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74576   Dali::Actor *arg2 = 0 ;
74577
74578   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74579   arg2 = (Dali::Actor *)jarg2;
74580   if (!arg2) {
74581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74582     return ;
74583   }
74584   {
74585     try {
74586       (arg1)->ScrollTo(*arg2);
74587     } catch (std::out_of_range& e) {
74588       {
74589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74590       };
74591     } catch (std::exception& e) {
74592       {
74593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74594       };
74595     } catch (...) {
74596       {
74597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74598       };
74599     }
74600   }
74601 }
74602
74603
74604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
74605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74606   Dali::Actor *arg2 = 0 ;
74607   float arg3 ;
74608
74609   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74610   arg2 = (Dali::Actor *)jarg2;
74611   if (!arg2) {
74612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74613     return ;
74614   }
74615   arg3 = (float)jarg3;
74616   {
74617     try {
74618       (arg1)->ScrollTo(*arg2,arg3);
74619     } catch (std::out_of_range& e) {
74620       {
74621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74622       };
74623     } catch (std::exception& e) {
74624       {
74625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74626       };
74627     } catch (...) {
74628       {
74629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74630       };
74631     }
74632   }
74633 }
74634
74635
74636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
74637   unsigned int jresult ;
74638   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74639   bool result;
74640
74641   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74642   {
74643     try {
74644       result = (bool)(arg1)->ScrollToSnapPoint();
74645     } catch (std::out_of_range& e) {
74646       {
74647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74648       };
74649     } catch (std::exception& e) {
74650       {
74651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74652       };
74653     } catch (...) {
74654       {
74655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74656       };
74657     }
74658   }
74659   jresult = result;
74660   return jresult;
74661 }
74662
74663
74664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
74665   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74666   Dali::Constraint arg2 ;
74667   Dali::Constraint *argp2 ;
74668
74669   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74670   argp2 = (Dali::Constraint *)jarg2;
74671   if (!argp2) {
74672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
74673     return ;
74674   }
74675   arg2 = *argp2;
74676   {
74677     try {
74678       (arg1)->ApplyConstraintToChildren(arg2);
74679     } catch (std::out_of_range& e) {
74680       {
74681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74682       };
74683     } catch (std::exception& e) {
74684       {
74685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74686       };
74687     } catch (...) {
74688       {
74689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74690       };
74691     }
74692   }
74693 }
74694
74695
74696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
74697   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74698
74699   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74700   {
74701     try {
74702       (arg1)->RemoveConstraintsFromChildren();
74703     } catch (std::out_of_range& e) {
74704       {
74705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74706       };
74707     } catch (std::exception& e) {
74708       {
74709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74710       };
74711     } catch (...) {
74712       {
74713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74714       };
74715     }
74716   }
74717 }
74718
74719
74720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
74721   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74722   Dali::Toolkit::ScrollViewEffect arg2 ;
74723   Dali::Toolkit::ScrollViewEffect *argp2 ;
74724
74725   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74726   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74727   if (!argp2) {
74728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74729     return ;
74730   }
74731   arg2 = *argp2;
74732   {
74733     try {
74734       (arg1)->ApplyEffect(arg2);
74735     } catch (std::out_of_range& e) {
74736       {
74737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74738       };
74739     } catch (std::exception& e) {
74740       {
74741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74742       };
74743     } catch (...) {
74744       {
74745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74746       };
74747     }
74748   }
74749 }
74750
74751
74752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
74753   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74754   Dali::Toolkit::ScrollViewEffect arg2 ;
74755   Dali::Toolkit::ScrollViewEffect *argp2 ;
74756
74757   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74758   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74759   if (!argp2) {
74760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74761     return ;
74762   }
74763   arg2 = *argp2;
74764   {
74765     try {
74766       (arg1)->RemoveEffect(arg2);
74767     } catch (std::out_of_range& e) {
74768       {
74769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74770       };
74771     } catch (std::exception& e) {
74772       {
74773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74774       };
74775     } catch (...) {
74776       {
74777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74778       };
74779     }
74780   }
74781 }
74782
74783
74784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
74785   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74786
74787   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74788   {
74789     try {
74790       (arg1)->RemoveAllEffects();
74791     } catch (std::out_of_range& e) {
74792       {
74793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74794       };
74795     } catch (std::exception& e) {
74796       {
74797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74798       };
74799     } catch (...) {
74800       {
74801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74802       };
74803     }
74804   }
74805 }
74806
74807
74808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
74809   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74810   Dali::Actor arg2 ;
74811   Dali::Actor *argp2 ;
74812
74813   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74814   argp2 = (Dali::Actor *)jarg2;
74815   if (!argp2) {
74816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74817     return ;
74818   }
74819   arg2 = *argp2;
74820   {
74821     try {
74822       (arg1)->BindActor(arg2);
74823     } catch (std::out_of_range& e) {
74824       {
74825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74826       };
74827     } catch (std::exception& e) {
74828       {
74829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74830       };
74831     } catch (...) {
74832       {
74833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74834       };
74835     }
74836   }
74837 }
74838
74839
74840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
74841   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74842   Dali::Actor arg2 ;
74843   Dali::Actor *argp2 ;
74844
74845   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74846   argp2 = (Dali::Actor *)jarg2;
74847   if (!argp2) {
74848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74849     return ;
74850   }
74851   arg2 = *argp2;
74852   {
74853     try {
74854       (arg1)->UnbindActor(arg2);
74855     } catch (std::out_of_range& e) {
74856       {
74857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74858       };
74859     } catch (std::exception& e) {
74860       {
74861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74862       };
74863     } catch (...) {
74864       {
74865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74866       };
74867     }
74868   }
74869 }
74870
74871
74872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
74873   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74874   Dali::Radian arg2 ;
74875   Dali::Radian arg3 ;
74876   Dali::Radian *argp2 ;
74877   Dali::Radian *argp3 ;
74878
74879   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74880   argp2 = (Dali::Radian *)jarg2;
74881   if (!argp2) {
74882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74883     return ;
74884   }
74885   arg2 = *argp2;
74886   argp3 = (Dali::Radian *)jarg3;
74887   if (!argp3) {
74888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74889     return ;
74890   }
74891   arg3 = *argp3;
74892   {
74893     try {
74894       (arg1)->SetScrollingDirection(arg2,arg3);
74895     } catch (std::out_of_range& e) {
74896       {
74897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74898       };
74899     } catch (std::exception& e) {
74900       {
74901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74902       };
74903     } catch (...) {
74904       {
74905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74906       };
74907     }
74908   }
74909 }
74910
74911
74912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
74913   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74914   Dali::Radian arg2 ;
74915   Dali::Radian *argp2 ;
74916
74917   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74918   argp2 = (Dali::Radian *)jarg2;
74919   if (!argp2) {
74920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74921     return ;
74922   }
74923   arg2 = *argp2;
74924   {
74925     try {
74926       (arg1)->SetScrollingDirection(arg2);
74927     } catch (std::out_of_range& e) {
74928       {
74929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74930       };
74931     } catch (std::exception& e) {
74932       {
74933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74934       };
74935     } catch (...) {
74936       {
74937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74938       };
74939     }
74940   }
74941 }
74942
74943
74944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
74945   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74946   Dali::Radian arg2 ;
74947   Dali::Radian *argp2 ;
74948
74949   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74950   argp2 = (Dali::Radian *)jarg2;
74951   if (!argp2) {
74952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74953     return ;
74954   }
74955   arg2 = *argp2;
74956   {
74957     try {
74958       (arg1)->RemoveScrollingDirection(arg2);
74959     } catch (std::out_of_range& e) {
74960       {
74961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74962       };
74963     } catch (std::exception& e) {
74964       {
74965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74966       };
74967     } catch (...) {
74968       {
74969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74970       };
74971     }
74972   }
74973 }
74974
74975
74976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
74977   void * jresult ;
74978   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74979   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
74980
74981   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74982   {
74983     try {
74984       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
74985     } catch (std::out_of_range& e) {
74986       {
74987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74988       };
74989     } catch (std::exception& e) {
74990       {
74991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74992       };
74993     } catch (...) {
74994       {
74995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74996       };
74997     }
74998   }
74999   jresult = (void *)result;
75000   return jresult;
75001 }
75002
75003
75004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
75005   int jresult ;
75006   int result;
75007
75008   result = (int)Dali::Toolkit::TableView::Property::ROWS;
75009   jresult = (int)result;
75010   return jresult;
75011 }
75012
75013
75014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
75015   int jresult ;
75016   int result;
75017
75018   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
75019   jresult = (int)result;
75020   return jresult;
75021 }
75022
75023
75024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
75025   int jresult ;
75026   int result;
75027
75028   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
75029   jresult = (int)result;
75030   return jresult;
75031 }
75032
75033
75034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
75035   int jresult ;
75036   int result;
75037
75038   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
75039   jresult = (int)result;
75040   return jresult;
75041 }
75042
75043
75044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
75045   int jresult ;
75046   int result;
75047
75048   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
75049   jresult = (int)result;
75050   return jresult;
75051 }
75052
75053
75054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
75055   void * jresult ;
75056   Dali::Toolkit::TableView::Property *result = 0 ;
75057
75058   {
75059     try {
75060       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
75061     } catch (std::out_of_range& e) {
75062       {
75063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75064       };
75065     } catch (std::exception& e) {
75066       {
75067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75068       };
75069     } catch (...) {
75070       {
75071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75072       };
75073     }
75074   }
75075   jresult = (void *)result;
75076   return jresult;
75077 }
75078
75079
75080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
75081   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
75082
75083   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
75084   {
75085     try {
75086       delete arg1;
75087     } catch (std::out_of_range& e) {
75088       {
75089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75090       };
75091     } catch (std::exception& e) {
75092       {
75093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75094       };
75095     } catch (...) {
75096       {
75097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75098       };
75099     }
75100   }
75101 }
75102
75103
75104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
75105   int jresult ;
75106   int result;
75107
75108   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
75109   jresult = (int)result;
75110   return jresult;
75111 }
75112
75113
75114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
75115   int jresult ;
75116   int result;
75117
75118   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
75119   jresult = (int)result;
75120   return jresult;
75121 }
75122
75123
75124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
75125   int jresult ;
75126   int result;
75127
75128   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
75129   jresult = (int)result;
75130   return jresult;
75131 }
75132
75133
75134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
75135   int jresult ;
75136   int result;
75137
75138   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
75139   jresult = (int)result;
75140   return jresult;
75141 }
75142
75143
75144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
75145   int jresult ;
75146   int result;
75147
75148   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
75149   jresult = (int)result;
75150   return jresult;
75151 }
75152
75153
75154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
75155   void * jresult ;
75156   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
75157
75158   {
75159     try {
75160       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
75161     } catch (std::out_of_range& e) {
75162       {
75163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75164       };
75165     } catch (std::exception& e) {
75166       {
75167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75168       };
75169     } catch (...) {
75170       {
75171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75172       };
75173     }
75174   }
75175   jresult = (void *)result;
75176   return jresult;
75177 }
75178
75179
75180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
75181   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
75182
75183   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
75184   {
75185     try {
75186       delete arg1;
75187     } catch (std::out_of_range& e) {
75188       {
75189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75190       };
75191     } catch (std::exception& e) {
75192       {
75193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75194       };
75195     } catch (...) {
75196       {
75197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75198       };
75199     }
75200   }
75201 }
75202
75203
75204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
75205   void * jresult ;
75206   unsigned int arg1 ;
75207   unsigned int arg2 ;
75208   unsigned int arg3 ;
75209   unsigned int arg4 ;
75210   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75211
75212   arg1 = (unsigned int)jarg1;
75213   arg2 = (unsigned int)jarg2;
75214   arg3 = (unsigned int)jarg3;
75215   arg4 = (unsigned int)jarg4;
75216   {
75217     try {
75218       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
75219     } catch (std::out_of_range& e) {
75220       {
75221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75222       };
75223     } catch (std::exception& e) {
75224       {
75225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75226       };
75227     } catch (...) {
75228       {
75229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75230       };
75231     }
75232   }
75233   jresult = (void *)result;
75234   return jresult;
75235 }
75236
75237
75238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
75239   void * jresult ;
75240   unsigned int arg1 ;
75241   unsigned int arg2 ;
75242   unsigned int arg3 ;
75243   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75244
75245   arg1 = (unsigned int)jarg1;
75246   arg2 = (unsigned int)jarg2;
75247   arg3 = (unsigned int)jarg3;
75248   {
75249     try {
75250       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
75251     } catch (std::out_of_range& e) {
75252       {
75253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75254       };
75255     } catch (std::exception& e) {
75256       {
75257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75258       };
75259     } catch (...) {
75260       {
75261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75262       };
75263     }
75264   }
75265   jresult = (void *)result;
75266   return jresult;
75267 }
75268
75269
75270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
75271   void * jresult ;
75272   unsigned int arg1 ;
75273   unsigned int arg2 ;
75274   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75275
75276   arg1 = (unsigned int)jarg1;
75277   arg2 = (unsigned int)jarg2;
75278   {
75279     try {
75280       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
75281     } catch (std::out_of_range& e) {
75282       {
75283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75284       };
75285     } catch (std::exception& e) {
75286       {
75287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75288       };
75289     } catch (...) {
75290       {
75291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75292       };
75293     }
75294   }
75295   jresult = (void *)result;
75296   return jresult;
75297 }
75298
75299
75300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
75301   void * jresult ;
75302   unsigned int arg1 ;
75303   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75304
75305   arg1 = (unsigned int)jarg1;
75306   {
75307     try {
75308       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
75309     } catch (std::out_of_range& e) {
75310       {
75311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75312       };
75313     } catch (std::exception& e) {
75314       {
75315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75316       };
75317     } catch (...) {
75318       {
75319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75320       };
75321     }
75322   }
75323   jresult = (void *)result;
75324   return jresult;
75325 }
75326
75327
75328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
75329   void * jresult ;
75330   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75331
75332   {
75333     try {
75334       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
75335     } catch (std::out_of_range& e) {
75336       {
75337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75338       };
75339     } catch (std::exception& e) {
75340       {
75341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75342       };
75343     } catch (...) {
75344       {
75345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75346       };
75347     }
75348   }
75349   jresult = (void *)result;
75350   return jresult;
75351 }
75352
75353
75354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
75355   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75356   unsigned int arg2 ;
75357
75358   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75359   arg2 = (unsigned int)jarg2;
75360   if (arg1) (arg1)->rowIndex = arg2;
75361 }
75362
75363
75364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
75365   unsigned int jresult ;
75366   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75367   unsigned int result;
75368
75369   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75370   result = (unsigned int) ((arg1)->rowIndex);
75371   jresult = result;
75372   return jresult;
75373 }
75374
75375
75376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
75377   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75378   unsigned int arg2 ;
75379
75380   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75381   arg2 = (unsigned int)jarg2;
75382   if (arg1) (arg1)->columnIndex = arg2;
75383 }
75384
75385
75386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
75387   unsigned int jresult ;
75388   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75389   unsigned int result;
75390
75391   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75392   result = (unsigned int) ((arg1)->columnIndex);
75393   jresult = result;
75394   return jresult;
75395 }
75396
75397
75398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
75399   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75400   unsigned int arg2 ;
75401
75402   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75403   arg2 = (unsigned int)jarg2;
75404   if (arg1) (arg1)->rowSpan = arg2;
75405 }
75406
75407
75408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
75409   unsigned int jresult ;
75410   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75411   unsigned int result;
75412
75413   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75414   result = (unsigned int) ((arg1)->rowSpan);
75415   jresult = result;
75416   return jresult;
75417 }
75418
75419
75420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
75421   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75422   unsigned int arg2 ;
75423
75424   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75425   arg2 = (unsigned int)jarg2;
75426   if (arg1) (arg1)->columnSpan = arg2;
75427 }
75428
75429
75430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
75431   unsigned int jresult ;
75432   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75433   unsigned int result;
75434
75435   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75436   result = (unsigned int) ((arg1)->columnSpan);
75437   jresult = result;
75438   return jresult;
75439 }
75440
75441
75442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
75443   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75444
75445   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75446   {
75447     try {
75448       delete arg1;
75449     } catch (std::out_of_range& e) {
75450       {
75451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75452       };
75453     } catch (std::exception& e) {
75454       {
75455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75456       };
75457     } catch (...) {
75458       {
75459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75460       };
75461     }
75462   }
75463 }
75464
75465
75466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
75467   void * jresult ;
75468   Dali::Toolkit::TableView *result = 0 ;
75469
75470   {
75471     try {
75472       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
75473     } catch (std::out_of_range& e) {
75474       {
75475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75476       };
75477     } catch (std::exception& e) {
75478       {
75479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75480       };
75481     } catch (...) {
75482       {
75483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75484       };
75485     }
75486   }
75487   jresult = (void *)result;
75488   return jresult;
75489 }
75490
75491
75492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
75493   void * jresult ;
75494   Dali::Toolkit::TableView *arg1 = 0 ;
75495   Dali::Toolkit::TableView *result = 0 ;
75496
75497   arg1 = (Dali::Toolkit::TableView *)jarg1;
75498   if (!arg1) {
75499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75500     return 0;
75501   }
75502   {
75503     try {
75504       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
75505     } catch (std::out_of_range& e) {
75506       {
75507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75508       };
75509     } catch (std::exception& e) {
75510       {
75511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75512       };
75513     } catch (...) {
75514       {
75515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75516       };
75517     }
75518   }
75519   jresult = (void *)result;
75520   return jresult;
75521 }
75522
75523
75524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
75525   void * jresult ;
75526   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75527   Dali::Toolkit::TableView *arg2 = 0 ;
75528   Dali::Toolkit::TableView *result = 0 ;
75529
75530   arg1 = (Dali::Toolkit::TableView *)jarg1;
75531   arg2 = (Dali::Toolkit::TableView *)jarg2;
75532   if (!arg2) {
75533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75534     return 0;
75535   }
75536   {
75537     try {
75538       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
75539     } catch (std::out_of_range& e) {
75540       {
75541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75542       };
75543     } catch (std::exception& e) {
75544       {
75545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75546       };
75547     } catch (...) {
75548       {
75549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75550       };
75551     }
75552   }
75553   jresult = (void *)result;
75554   return jresult;
75555 }
75556
75557
75558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
75559   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75560
75561   arg1 = (Dali::Toolkit::TableView *)jarg1;
75562   {
75563     try {
75564       delete arg1;
75565     } catch (std::out_of_range& e) {
75566       {
75567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75568       };
75569     } catch (std::exception& e) {
75570       {
75571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75572       };
75573     } catch (...) {
75574       {
75575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75576       };
75577     }
75578   }
75579 }
75580
75581
75582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
75583   void * jresult ;
75584   unsigned int arg1 ;
75585   unsigned int arg2 ;
75586   Dali::Toolkit::TableView result;
75587
75588   arg1 = (unsigned int)jarg1;
75589   arg2 = (unsigned int)jarg2;
75590   {
75591     try {
75592       result = Dali::Toolkit::TableView::New(arg1,arg2);
75593     } catch (std::out_of_range& e) {
75594       {
75595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75596       };
75597     } catch (std::exception& e) {
75598       {
75599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75600       };
75601     } catch (...) {
75602       {
75603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75604       };
75605     }
75606   }
75607   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75608   return jresult;
75609 }
75610
75611
75612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
75613   void * jresult ;
75614   Dali::BaseHandle arg1 ;
75615   Dali::BaseHandle *argp1 ;
75616   Dali::Toolkit::TableView result;
75617
75618   argp1 = (Dali::BaseHandle *)jarg1;
75619   if (!argp1) {
75620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75621     return 0;
75622   }
75623   arg1 = *argp1;
75624   {
75625     try {
75626       result = Dali::Toolkit::TableView::DownCast(arg1);
75627     } catch (std::out_of_range& e) {
75628       {
75629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75630       };
75631     } catch (std::exception& e) {
75632       {
75633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75634       };
75635     } catch (...) {
75636       {
75637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75638       };
75639     }
75640   }
75641   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75642   return jresult;
75643 }
75644
75645
75646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
75647   unsigned int jresult ;
75648   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75649   Dali::Actor arg2 ;
75650   Dali::Toolkit::TableView::CellPosition arg3 ;
75651   Dali::Actor *argp2 ;
75652   Dali::Toolkit::TableView::CellPosition *argp3 ;
75653   bool result;
75654
75655   arg1 = (Dali::Toolkit::TableView *)jarg1;
75656   argp2 = (Dali::Actor *)jarg2;
75657   if (!argp2) {
75658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75659     return 0;
75660   }
75661   arg2 = *argp2;
75662   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75663   if (!argp3) {
75664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75665     return 0;
75666   }
75667   arg3 = *argp3;
75668   {
75669     try {
75670       result = (bool)(arg1)->AddChild(arg2,arg3);
75671     } catch (std::out_of_range& e) {
75672       {
75673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75674       };
75675     } catch (std::exception& e) {
75676       {
75677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75678       };
75679     } catch (...) {
75680       {
75681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75682       };
75683     }
75684   }
75685   jresult = result;
75686   return jresult;
75687 }
75688
75689
75690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
75691   void * jresult ;
75692   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75693   Dali::Toolkit::TableView::CellPosition arg2 ;
75694   Dali::Toolkit::TableView::CellPosition *argp2 ;
75695   Dali::Actor result;
75696
75697   arg1 = (Dali::Toolkit::TableView *)jarg1;
75698   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75699   if (!argp2) {
75700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75701     return 0;
75702   }
75703   arg2 = *argp2;
75704   {
75705     try {
75706       result = (arg1)->GetChildAt(arg2);
75707     } catch (std::out_of_range& e) {
75708       {
75709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75710       };
75711     } catch (std::exception& e) {
75712       {
75713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75714       };
75715     } catch (...) {
75716       {
75717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75718       };
75719     }
75720   }
75721   jresult = new Dali::Actor((const Dali::Actor &)result);
75722   return jresult;
75723 }
75724
75725
75726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
75727   void * jresult ;
75728   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75729   Dali::Toolkit::TableView::CellPosition arg2 ;
75730   Dali::Toolkit::TableView::CellPosition *argp2 ;
75731   Dali::Actor result;
75732
75733   arg1 = (Dali::Toolkit::TableView *)jarg1;
75734   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75735   if (!argp2) {
75736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75737     return 0;
75738   }
75739   arg2 = *argp2;
75740   {
75741     try {
75742       result = (arg1)->RemoveChildAt(arg2);
75743     } catch (std::out_of_range& e) {
75744       {
75745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75746       };
75747     } catch (std::exception& e) {
75748       {
75749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75750       };
75751     } catch (...) {
75752       {
75753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75754       };
75755     }
75756   }
75757   jresult = new Dali::Actor((const Dali::Actor &)result);
75758   return jresult;
75759 }
75760
75761
75762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
75763   unsigned int jresult ;
75764   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75765   Dali::Actor arg2 ;
75766   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
75767   Dali::Actor *argp2 ;
75768   bool result;
75769
75770   arg1 = (Dali::Toolkit::TableView *)jarg1;
75771   argp2 = (Dali::Actor *)jarg2;
75772   if (!argp2) {
75773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75774     return 0;
75775   }
75776   arg2 = *argp2;
75777   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75778   if (!arg3) {
75779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
75780     return 0;
75781   }
75782   {
75783     try {
75784       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
75785     } catch (std::out_of_range& e) {
75786       {
75787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75788       };
75789     } catch (std::exception& e) {
75790       {
75791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75792       };
75793     } catch (...) {
75794       {
75795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75796       };
75797     }
75798   }
75799   jresult = result;
75800   return jresult;
75801 }
75802
75803
75804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
75805   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75806   unsigned int arg2 ;
75807
75808   arg1 = (Dali::Toolkit::TableView *)jarg1;
75809   arg2 = (unsigned int)jarg2;
75810   {
75811     try {
75812       (arg1)->InsertRow(arg2);
75813     } catch (std::out_of_range& e) {
75814       {
75815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75816       };
75817     } catch (std::exception& e) {
75818       {
75819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75820       };
75821     } catch (...) {
75822       {
75823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75824       };
75825     }
75826   }
75827 }
75828
75829
75830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
75831   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75832   unsigned int arg2 ;
75833
75834   arg1 = (Dali::Toolkit::TableView *)jarg1;
75835   arg2 = (unsigned int)jarg2;
75836   {
75837     try {
75838       (arg1)->DeleteRow(arg2);
75839     } catch (std::out_of_range& e) {
75840       {
75841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75842       };
75843     } catch (std::exception& e) {
75844       {
75845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75846       };
75847     } catch (...) {
75848       {
75849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75850       };
75851     }
75852   }
75853 }
75854
75855
75856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75857   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75858   unsigned int arg2 ;
75859   std::vector< Dali::Actor > *arg3 = 0 ;
75860
75861   arg1 = (Dali::Toolkit::TableView *)jarg1;
75862   arg2 = (unsigned int)jarg2;
75863   arg3 = (std::vector< Dali::Actor > *)jarg3;
75864   if (!arg3) {
75865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75866     return ;
75867   }
75868   {
75869     try {
75870       (arg1)->DeleteRow(arg2,*arg3);
75871     } catch (std::out_of_range& e) {
75872       {
75873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75874       };
75875     } catch (std::exception& e) {
75876       {
75877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75878       };
75879     } catch (...) {
75880       {
75881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75882       };
75883     }
75884   }
75885 }
75886
75887
75888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
75889   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75890   unsigned int arg2 ;
75891
75892   arg1 = (Dali::Toolkit::TableView *)jarg1;
75893   arg2 = (unsigned int)jarg2;
75894   {
75895     try {
75896       (arg1)->InsertColumn(arg2);
75897     } catch (std::out_of_range& e) {
75898       {
75899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75900       };
75901     } catch (std::exception& e) {
75902       {
75903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75904       };
75905     } catch (...) {
75906       {
75907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75908       };
75909     }
75910   }
75911 }
75912
75913
75914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
75915   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75916   unsigned int arg2 ;
75917
75918   arg1 = (Dali::Toolkit::TableView *)jarg1;
75919   arg2 = (unsigned int)jarg2;
75920   {
75921     try {
75922       (arg1)->DeleteColumn(arg2);
75923     } catch (std::out_of_range& e) {
75924       {
75925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75926       };
75927     } catch (std::exception& e) {
75928       {
75929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75930       };
75931     } catch (...) {
75932       {
75933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75934       };
75935     }
75936   }
75937 }
75938
75939
75940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75941   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75942   unsigned int arg2 ;
75943   std::vector< Dali::Actor > *arg3 = 0 ;
75944
75945   arg1 = (Dali::Toolkit::TableView *)jarg1;
75946   arg2 = (unsigned int)jarg2;
75947   arg3 = (std::vector< Dali::Actor > *)jarg3;
75948   if (!arg3) {
75949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75950     return ;
75951   }
75952   {
75953     try {
75954       (arg1)->DeleteColumn(arg2,*arg3);
75955     } catch (std::out_of_range& e) {
75956       {
75957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75958       };
75959     } catch (std::exception& e) {
75960       {
75961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75962       };
75963     } catch (...) {
75964       {
75965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75966       };
75967     }
75968   }
75969 }
75970
75971
75972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
75973   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75974   unsigned int arg2 ;
75975   unsigned int arg3 ;
75976
75977   arg1 = (Dali::Toolkit::TableView *)jarg1;
75978   arg2 = (unsigned int)jarg2;
75979   arg3 = (unsigned int)jarg3;
75980   {
75981     try {
75982       (arg1)->Resize(arg2,arg3);
75983     } catch (std::out_of_range& e) {
75984       {
75985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75986       };
75987     } catch (std::exception& e) {
75988       {
75989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75990       };
75991     } catch (...) {
75992       {
75993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75994       };
75995     }
75996   }
75997 }
75998
75999
76000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
76001   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76002   unsigned int arg2 ;
76003   unsigned int arg3 ;
76004   std::vector< Dali::Actor > *arg4 = 0 ;
76005
76006   arg1 = (Dali::Toolkit::TableView *)jarg1;
76007   arg2 = (unsigned int)jarg2;
76008   arg3 = (unsigned int)jarg3;
76009   arg4 = (std::vector< Dali::Actor > *)jarg4;
76010   if (!arg4) {
76011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76012     return ;
76013   }
76014   {
76015     try {
76016       (arg1)->Resize(arg2,arg3,*arg4);
76017     } catch (std::out_of_range& e) {
76018       {
76019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76020       };
76021     } catch (std::exception& e) {
76022       {
76023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76024       };
76025     } catch (...) {
76026       {
76027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76028       };
76029     }
76030   }
76031 }
76032
76033
76034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
76035   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76036   Dali::Size arg2 ;
76037   Dali::Size *argp2 ;
76038
76039   arg1 = (Dali::Toolkit::TableView *)jarg1;
76040   argp2 = (Dali::Size *)jarg2;
76041   if (!argp2) {
76042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
76043     return ;
76044   }
76045   arg2 = *argp2;
76046   {
76047     try {
76048       (arg1)->SetCellPadding(arg2);
76049     } catch (std::out_of_range& e) {
76050       {
76051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76052       };
76053     } catch (std::exception& e) {
76054       {
76055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76056       };
76057     } catch (...) {
76058       {
76059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76060       };
76061     }
76062   }
76063 }
76064
76065
76066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
76067   void * jresult ;
76068   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76069   Dali::Size result;
76070
76071   arg1 = (Dali::Toolkit::TableView *)jarg1;
76072   {
76073     try {
76074       result = (arg1)->GetCellPadding();
76075     } catch (std::out_of_range& e) {
76076       {
76077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76078       };
76079     } catch (std::exception& e) {
76080       {
76081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76082       };
76083     } catch (...) {
76084       {
76085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76086       };
76087     }
76088   }
76089   jresult = new Dali::Size((const Dali::Size &)result);
76090   return jresult;
76091 }
76092
76093
76094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
76095   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76096   unsigned int arg2 ;
76097
76098   arg1 = (Dali::Toolkit::TableView *)jarg1;
76099   arg2 = (unsigned int)jarg2;
76100   {
76101     try {
76102       (arg1)->SetFitHeight(arg2);
76103     } catch (std::out_of_range& e) {
76104       {
76105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76106       };
76107     } catch (std::exception& e) {
76108       {
76109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76110       };
76111     } catch (...) {
76112       {
76113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76114       };
76115     }
76116   }
76117 }
76118
76119
76120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
76121   unsigned int jresult ;
76122   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76123   unsigned int arg2 ;
76124   bool result;
76125
76126   arg1 = (Dali::Toolkit::TableView *)jarg1;
76127   arg2 = (unsigned int)jarg2;
76128   {
76129     try {
76130       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
76131     } catch (std::out_of_range& e) {
76132       {
76133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76134       };
76135     } catch (std::exception& e) {
76136       {
76137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76138       };
76139     } catch (...) {
76140       {
76141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76142       };
76143     }
76144   }
76145   jresult = result;
76146   return jresult;
76147 }
76148
76149
76150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
76151   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76152   unsigned int arg2 ;
76153
76154   arg1 = (Dali::Toolkit::TableView *)jarg1;
76155   arg2 = (unsigned int)jarg2;
76156   {
76157     try {
76158       (arg1)->SetFitWidth(arg2);
76159     } catch (std::out_of_range& e) {
76160       {
76161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76162       };
76163     } catch (std::exception& e) {
76164       {
76165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76166       };
76167     } catch (...) {
76168       {
76169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76170       };
76171     }
76172   }
76173 }
76174
76175
76176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
76177   unsigned int jresult ;
76178   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76179   unsigned int arg2 ;
76180   bool result;
76181
76182   arg1 = (Dali::Toolkit::TableView *)jarg1;
76183   arg2 = (unsigned int)jarg2;
76184   {
76185     try {
76186       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
76187     } catch (std::out_of_range& e) {
76188       {
76189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76190       };
76191     } catch (std::exception& e) {
76192       {
76193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76194       };
76195     } catch (...) {
76196       {
76197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76198       };
76199     }
76200   }
76201   jresult = result;
76202   return jresult;
76203 }
76204
76205
76206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76207   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76208   unsigned int arg2 ;
76209   float arg3 ;
76210
76211   arg1 = (Dali::Toolkit::TableView *)jarg1;
76212   arg2 = (unsigned int)jarg2;
76213   arg3 = (float)jarg3;
76214   {
76215     try {
76216       (arg1)->SetFixedHeight(arg2,arg3);
76217     } catch (std::out_of_range& e) {
76218       {
76219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76220       };
76221     } catch (std::exception& e) {
76222       {
76223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76224       };
76225     } catch (...) {
76226       {
76227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76228       };
76229     }
76230   }
76231 }
76232
76233
76234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
76235   float jresult ;
76236   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76237   unsigned int arg2 ;
76238   float result;
76239
76240   arg1 = (Dali::Toolkit::TableView *)jarg1;
76241   arg2 = (unsigned int)jarg2;
76242   {
76243     try {
76244       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
76245     } catch (std::out_of_range& e) {
76246       {
76247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76248       };
76249     } catch (std::exception& e) {
76250       {
76251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76252       };
76253     } catch (...) {
76254       {
76255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76256       };
76257     }
76258   }
76259   jresult = result;
76260   return jresult;
76261 }
76262
76263
76264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76265   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76266   unsigned int arg2 ;
76267   float arg3 ;
76268
76269   arg1 = (Dali::Toolkit::TableView *)jarg1;
76270   arg2 = (unsigned int)jarg2;
76271   arg3 = (float)jarg3;
76272   {
76273     try {
76274       (arg1)->SetRelativeHeight(arg2,arg3);
76275     } catch (std::out_of_range& e) {
76276       {
76277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76278       };
76279     } catch (std::exception& e) {
76280       {
76281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76282       };
76283     } catch (...) {
76284       {
76285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76286       };
76287     }
76288   }
76289 }
76290
76291
76292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
76293   float jresult ;
76294   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76295   unsigned int arg2 ;
76296   float result;
76297
76298   arg1 = (Dali::Toolkit::TableView *)jarg1;
76299   arg2 = (unsigned int)jarg2;
76300   {
76301     try {
76302       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
76303     } catch (std::out_of_range& e) {
76304       {
76305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76306       };
76307     } catch (std::exception& e) {
76308       {
76309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76310       };
76311     } catch (...) {
76312       {
76313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76314       };
76315     }
76316   }
76317   jresult = result;
76318   return jresult;
76319 }
76320
76321
76322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76323   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76324   unsigned int arg2 ;
76325   float arg3 ;
76326
76327   arg1 = (Dali::Toolkit::TableView *)jarg1;
76328   arg2 = (unsigned int)jarg2;
76329   arg3 = (float)jarg3;
76330   {
76331     try {
76332       (arg1)->SetFixedWidth(arg2,arg3);
76333     } catch (std::out_of_range& e) {
76334       {
76335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76336       };
76337     } catch (std::exception& e) {
76338       {
76339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76340       };
76341     } catch (...) {
76342       {
76343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76344       };
76345     }
76346   }
76347 }
76348
76349
76350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
76351   float jresult ;
76352   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76353   unsigned int arg2 ;
76354   float result;
76355
76356   arg1 = (Dali::Toolkit::TableView *)jarg1;
76357   arg2 = (unsigned int)jarg2;
76358   {
76359     try {
76360       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
76361     } catch (std::out_of_range& e) {
76362       {
76363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76364       };
76365     } catch (std::exception& e) {
76366       {
76367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76368       };
76369     } catch (...) {
76370       {
76371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76372       };
76373     }
76374   }
76375   jresult = result;
76376   return jresult;
76377 }
76378
76379
76380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76381   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76382   unsigned int arg2 ;
76383   float arg3 ;
76384
76385   arg1 = (Dali::Toolkit::TableView *)jarg1;
76386   arg2 = (unsigned int)jarg2;
76387   arg3 = (float)jarg3;
76388   {
76389     try {
76390       (arg1)->SetRelativeWidth(arg2,arg3);
76391     } catch (std::out_of_range& e) {
76392       {
76393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76394       };
76395     } catch (std::exception& e) {
76396       {
76397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76398       };
76399     } catch (...) {
76400       {
76401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76402       };
76403     }
76404   }
76405 }
76406
76407
76408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
76409   float jresult ;
76410   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76411   unsigned int arg2 ;
76412   float result;
76413
76414   arg1 = (Dali::Toolkit::TableView *)jarg1;
76415   arg2 = (unsigned int)jarg2;
76416   {
76417     try {
76418       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
76419     } catch (std::out_of_range& e) {
76420       {
76421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76422       };
76423     } catch (std::exception& e) {
76424       {
76425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76426       };
76427     } catch (...) {
76428       {
76429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76430       };
76431     }
76432   }
76433   jresult = result;
76434   return jresult;
76435 }
76436
76437
76438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
76439   unsigned int jresult ;
76440   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76441   unsigned int result;
76442
76443   arg1 = (Dali::Toolkit::TableView *)jarg1;
76444   {
76445     try {
76446       result = (unsigned int)(arg1)->GetRows();
76447     } catch (std::out_of_range& e) {
76448       {
76449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76450       };
76451     } catch (std::exception& e) {
76452       {
76453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76454       };
76455     } catch (...) {
76456       {
76457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76458       };
76459     }
76460   }
76461   jresult = result;
76462   return jresult;
76463 }
76464
76465
76466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
76467   unsigned int jresult ;
76468   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76469   unsigned int result;
76470
76471   arg1 = (Dali::Toolkit::TableView *)jarg1;
76472   {
76473     try {
76474       result = (unsigned int)(arg1)->GetColumns();
76475     } catch (std::out_of_range& e) {
76476       {
76477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76478       };
76479     } catch (std::exception& e) {
76480       {
76481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76482       };
76483     } catch (...) {
76484       {
76485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76486       };
76487     }
76488   }
76489   jresult = result;
76490   return jresult;
76491 }
76492
76493
76494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
76495   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76496   Dali::Toolkit::TableView::CellPosition arg2 ;
76497   Dali::HorizontalAlignment::Type arg3 ;
76498   Dali::VerticalAlignment::Type arg4 ;
76499   Dali::Toolkit::TableView::CellPosition *argp2 ;
76500
76501   arg1 = (Dali::Toolkit::TableView *)jarg1;
76502   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76503   if (!argp2) {
76504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76505     return ;
76506   }
76507   arg2 = *argp2;
76508   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
76509   arg4 = (Dali::VerticalAlignment::Type)jarg4;
76510   {
76511     try {
76512       (arg1)->SetCellAlignment(arg2,arg3,arg4);
76513     } catch (std::out_of_range& e) {
76514       {
76515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76516       };
76517     } catch (std::exception& e) {
76518       {
76519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76520       };
76521     } catch (...) {
76522       {
76523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76524       };
76525     }
76526   }
76527 }
76528
76529
76530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
76531   unsigned int jresult ;
76532   unsigned int result;
76533
76534   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
76535   jresult = result;
76536   return jresult;
76537 }
76538
76539
76540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
76541   int jresult ;
76542   int result;
76543
76544   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
76545   jresult = (int)result;
76546   return jresult;
76547 }
76548
76549
76550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
76551   int jresult ;
76552   int result;
76553
76554   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
76555   jresult = (int)result;
76556   return jresult;
76557 }
76558
76559
76560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
76561   int jresult ;
76562   int result;
76563
76564   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
76565   jresult = (int)result;
76566   return jresult;
76567 }
76568
76569
76570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
76571   int jresult ;
76572   int result;
76573
76574   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
76575   jresult = (int)result;
76576   return jresult;
76577 }
76578
76579
76580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
76581   int jresult ;
76582   int result;
76583
76584   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
76585   jresult = (int)result;
76586   return jresult;
76587 }
76588
76589
76590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
76591   int jresult ;
76592   int result;
76593
76594   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
76595   jresult = (int)result;
76596   return jresult;
76597 }
76598
76599
76600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
76601   int jresult ;
76602   int result;
76603
76604   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
76605   jresult = (int)result;
76606   return jresult;
76607 }
76608
76609
76610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
76611   int jresult ;
76612   int result;
76613
76614   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
76615   jresult = (int)result;
76616   return jresult;
76617 }
76618
76619
76620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
76621   int jresult ;
76622   int result;
76623
76624   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
76625   jresult = (int)result;
76626   return jresult;
76627 }
76628
76629
76630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
76631   int jresult ;
76632   int result;
76633
76634   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
76635   jresult = (int)result;
76636   return jresult;
76637 }
76638
76639
76640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
76641   int jresult ;
76642   int result;
76643
76644   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
76645   jresult = (int)result;
76646   return jresult;
76647 }
76648
76649
76650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
76651   int jresult ;
76652   int result;
76653
76654   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
76655   jresult = (int)result;
76656   return jresult;
76657 }
76658
76659
76660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
76661   int jresult ;
76662   int result;
76663
76664   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
76665   jresult = (int)result;
76666   return jresult;
76667 }
76668
76669
76670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
76671   int jresult ;
76672   int result;
76673
76674   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
76675   jresult = (int)result;
76676   return jresult;
76677 }
76678
76679
76680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
76681   int jresult ;
76682   int result;
76683
76684   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
76685   jresult = (int)result;
76686   return jresult;
76687 }
76688
76689
76690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
76691   int jresult ;
76692   int result;
76693
76694   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
76695   jresult = (int)result;
76696   return jresult;
76697 }
76698
76699
76700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
76701   int jresult ;
76702   int result;
76703
76704   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
76705   jresult = (int)result;
76706   return jresult;
76707 }
76708
76709
76710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
76711   int jresult ;
76712   int result;
76713
76714   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
76715   jresult = (int)result;
76716   return jresult;
76717 }
76718
76719
76720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
76721   int jresult ;
76722   int result;
76723
76724   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
76725   jresult = (int)result;
76726   return jresult;
76727 }
76728
76729
76730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
76731   int jresult ;
76732   int result;
76733
76734   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
76735   jresult = (int)result;
76736   return jresult;
76737 }
76738
76739
76740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
76741   int jresult ;
76742   int result;
76743
76744   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
76745   jresult = (int)result;
76746   return jresult;
76747 }
76748
76749
76750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
76751   int jresult ;
76752   int result;
76753
76754   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
76755   jresult = (int)result;
76756   return jresult;
76757 }
76758
76759
76760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
76761   int jresult ;
76762   int result;
76763
76764   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
76765   jresult = (int)result;
76766   return jresult;
76767 }
76768
76769
76770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
76771   int jresult ;
76772   int result;
76773
76774   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
76775   jresult = (int)result;
76776   return jresult;
76777 }
76778
76779
76780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
76781   int jresult ;
76782   int result;
76783
76784   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
76785   jresult = (int)result;
76786   return jresult;
76787 }
76788
76789
76790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
76791   int jresult ;
76792   int result;
76793
76794   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
76795   jresult = (int)result;
76796   return jresult;
76797 }
76798
76799
76800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
76801   int jresult ;
76802   int result;
76803
76804   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
76805   jresult = (int)result;
76806   return jresult;
76807 }
76808
76809
76810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
76811   int jresult ;
76812   int result;
76813
76814   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
76815   jresult = (int)result;
76816   return jresult;
76817 }
76818
76819
76820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
76821   int jresult ;
76822   int result;
76823
76824   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
76825   jresult = (int)result;
76826   return jresult;
76827 }
76828
76829
76830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
76831   int jresult ;
76832   int result;
76833
76834   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
76835   jresult = (int)result;
76836   return jresult;
76837 }
76838
76839
76840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
76841   int jresult ;
76842   int result;
76843
76844   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
76845   jresult = (int)result;
76846   return jresult;
76847 }
76848
76849
76850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
76851   int jresult ;
76852   int result;
76853
76854   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
76855   jresult = (int)result;
76856   return jresult;
76857 }
76858
76859
76860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
76861   int jresult ;
76862   int result;
76863
76864   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
76865   jresult = (int)result;
76866   return jresult;
76867 }
76868
76869
76870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
76871   int jresult ;
76872   int result;
76873
76874   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
76875   jresult = (int)result;
76876   return jresult;
76877 }
76878
76879
76880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
76881   int jresult ;
76882   int result;
76883
76884   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
76885   jresult = (int)result;
76886   return jresult;
76887 }
76888
76889
76890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
76891   int jresult ;
76892   int result;
76893
76894   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
76895   jresult = (int)result;
76896   return jresult;
76897 }
76898
76899
76900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
76901   int jresult ;
76902   int result;
76903
76904   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
76905   jresult = (int)result;
76906   return jresult;
76907 }
76908
76909
76910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
76911   int jresult ;
76912   int result;
76913
76914   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
76915   jresult = (int)result;
76916   return jresult;
76917 }
76918
76919
76920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
76921   int jresult ;
76922   int result;
76923
76924   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
76925   jresult = (int)result;
76926   return jresult;
76927 }
76928
76929
76930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
76931   int jresult ;
76932   int result;
76933
76934   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
76935   jresult = (int)result;
76936   return jresult;
76937 }
76938
76939
76940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
76941   void * jresult ;
76942   Dali::Toolkit::TextEditor::Property *result = 0 ;
76943
76944   {
76945     try {
76946       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
76947     } catch (std::out_of_range& e) {
76948       {
76949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76950       };
76951     } catch (std::exception& e) {
76952       {
76953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76954       };
76955     } catch (...) {
76956       {
76957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76958       };
76959     }
76960   }
76961   jresult = (void *)result;
76962   return jresult;
76963 }
76964
76965
76966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
76967   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
76968
76969   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
76970   {
76971     try {
76972       delete arg1;
76973     } catch (std::out_of_range& e) {
76974       {
76975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76976       };
76977     } catch (std::exception& e) {
76978       {
76979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76980       };
76981     } catch (...) {
76982       {
76983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76984       };
76985     }
76986   }
76987 }
76988
76989
76990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
76991   void * jresult ;
76992   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
76993
76994   {
76995     try {
76996       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
76997     } catch (std::out_of_range& e) {
76998       {
76999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77000       };
77001     } catch (std::exception& e) {
77002       {
77003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77004       };
77005     } catch (...) {
77006       {
77007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77008       };
77009     }
77010   }
77011   jresult = (void *)result;
77012   return jresult;
77013 }
77014
77015
77016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
77017   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
77018
77019   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
77020   {
77021     try {
77022       delete arg1;
77023     } catch (std::out_of_range& e) {
77024       {
77025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77026       };
77027     } catch (std::exception& e) {
77028       {
77029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77030       };
77031     } catch (...) {
77032       {
77033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77034       };
77035     }
77036   }
77037 }
77038
77039
77040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
77041   void * jresult ;
77042   Dali::Toolkit::TextEditor result;
77043
77044   {
77045     try {
77046       result = Dali::Toolkit::TextEditor::New();
77047     } catch (std::out_of_range& e) {
77048       {
77049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77050       };
77051     } catch (std::exception& e) {
77052       {
77053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77054       };
77055     } catch (...) {
77056       {
77057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77058       };
77059     }
77060   }
77061   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77062   return jresult;
77063 }
77064
77065
77066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
77067   void * jresult ;
77068   Dali::Toolkit::TextEditor *result = 0 ;
77069
77070   {
77071     try {
77072       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
77073     } catch (std::out_of_range& e) {
77074       {
77075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77076       };
77077     } catch (std::exception& e) {
77078       {
77079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77080       };
77081     } catch (...) {
77082       {
77083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77084       };
77085     }
77086   }
77087   jresult = (void *)result;
77088   return jresult;
77089 }
77090
77091
77092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
77093   void * jresult ;
77094   Dali::Toolkit::TextEditor *arg1 = 0 ;
77095   Dali::Toolkit::TextEditor *result = 0 ;
77096
77097   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77098   if (!arg1) {
77099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77100     return 0;
77101   }
77102   {
77103     try {
77104       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
77105     } catch (std::out_of_range& e) {
77106       {
77107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77108       };
77109     } catch (std::exception& e) {
77110       {
77111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77112       };
77113     } catch (...) {
77114       {
77115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77116       };
77117     }
77118   }
77119   jresult = (void *)result;
77120   return jresult;
77121 }
77122
77123
77124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
77125   void * jresult ;
77126   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77127   Dali::Toolkit::TextEditor *arg2 = 0 ;
77128   Dali::Toolkit::TextEditor *result = 0 ;
77129
77130   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77131   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
77132   if (!arg2) {
77133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77134     return 0;
77135   }
77136   {
77137     try {
77138       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
77139     } catch (std::out_of_range& e) {
77140       {
77141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77142       };
77143     } catch (std::exception& e) {
77144       {
77145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77146       };
77147     } catch (...) {
77148       {
77149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77150       };
77151     }
77152   }
77153   jresult = (void *)result;
77154   return jresult;
77155 }
77156
77157
77158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
77159   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77160
77161   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77162   {
77163     try {
77164       delete arg1;
77165     } catch (std::out_of_range& e) {
77166       {
77167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77168       };
77169     } catch (std::exception& e) {
77170       {
77171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77172       };
77173     } catch (...) {
77174       {
77175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77176       };
77177     }
77178   }
77179 }
77180
77181
77182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
77183   void * jresult ;
77184   Dali::BaseHandle arg1 ;
77185   Dali::BaseHandle *argp1 ;
77186   Dali::Toolkit::TextEditor result;
77187
77188   argp1 = (Dali::BaseHandle *)jarg1;
77189   if (!argp1) {
77190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77191     return 0;
77192   }
77193   arg1 = *argp1;
77194   {
77195     try {
77196       result = Dali::Toolkit::TextEditor::DownCast(arg1);
77197     } catch (std::out_of_range& e) {
77198       {
77199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77200       };
77201     } catch (std::exception& e) {
77202       {
77203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77204       };
77205     } catch (...) {
77206       {
77207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77208       };
77209     }
77210   }
77211   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77212   return jresult;
77213 }
77214
77215
77216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
77217   void * jresult ;
77218   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77219   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
77220
77221   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77222   {
77223     try {
77224       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
77225     } catch (std::out_of_range& e) {
77226       {
77227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77228       };
77229     } catch (std::exception& e) {
77230       {
77231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77232       };
77233     } catch (...) {
77234       {
77235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77236       };
77237     }
77238   }
77239   jresult = (void *)result;
77240   return jresult;
77241 }
77242
77243
77244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
77245   void * jresult ;
77246   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77247   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
77248
77249   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77250   {
77251     try {
77252       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
77253     } catch (std::out_of_range& e) {
77254       {
77255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77256       };
77257     } catch (std::exception& e) {
77258       {
77259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77260       };
77261     } catch (...) {
77262       {
77263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77264       };
77265     }
77266   }
77267   jresult = (void *)result;
77268   return jresult;
77269 }
77270
77271
77272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
77273   int jresult ;
77274   int result;
77275
77276   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
77277   jresult = (int)result;
77278   return jresult;
77279 }
77280
77281
77282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
77283   int jresult ;
77284   int result;
77285
77286   result = (int)Dali::Toolkit::TextField::Property::TEXT;
77287   jresult = (int)result;
77288   return jresult;
77289 }
77290
77291
77292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
77293   int jresult ;
77294   int result;
77295
77296   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
77297   jresult = (int)result;
77298   return jresult;
77299 }
77300
77301
77302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
77303   int jresult ;
77304   int result;
77305
77306   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
77307   jresult = (int)result;
77308   return jresult;
77309 }
77310
77311
77312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
77313   int jresult ;
77314   int result;
77315
77316   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
77317   jresult = (int)result;
77318   return jresult;
77319 }
77320
77321
77322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
77323   int jresult ;
77324   int result;
77325
77326   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
77327   jresult = (int)result;
77328   return jresult;
77329 }
77330
77331
77332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
77333   int jresult ;
77334   int result;
77335
77336   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
77337   jresult = (int)result;
77338   return jresult;
77339 }
77340
77341
77342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
77343   int jresult ;
77344   int result;
77345
77346   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
77347   jresult = (int)result;
77348   return jresult;
77349 }
77350
77351
77352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
77353   int jresult ;
77354   int result;
77355
77356   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
77357   jresult = (int)result;
77358   return jresult;
77359 }
77360
77361
77362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
77363   int jresult ;
77364   int result;
77365
77366   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
77367   jresult = (int)result;
77368   return jresult;
77369 }
77370
77371
77372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
77373   int jresult ;
77374   int result;
77375
77376   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
77377   jresult = (int)result;
77378   return jresult;
77379 }
77380
77381
77382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
77383   int jresult ;
77384   int result;
77385
77386   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
77387   jresult = (int)result;
77388   return jresult;
77389 }
77390
77391
77392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
77393   int jresult ;
77394   int result;
77395
77396   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
77397   jresult = (int)result;
77398   return jresult;
77399 }
77400
77401
77402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
77403   int jresult ;
77404   int result;
77405
77406   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
77407   jresult = (int)result;
77408   return jresult;
77409 }
77410
77411
77412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
77413   int jresult ;
77414   int result;
77415
77416   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
77417   jresult = (int)result;
77418   return jresult;
77419 }
77420
77421
77422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
77423   int jresult ;
77424   int result;
77425
77426   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
77427   jresult = (int)result;
77428   return jresult;
77429 }
77430
77431
77432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
77433   int jresult ;
77434   int result;
77435
77436   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
77437   jresult = (int)result;
77438   return jresult;
77439 }
77440
77441
77442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
77443   int jresult ;
77444   int result;
77445
77446   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
77447   jresult = (int)result;
77448   return jresult;
77449 }
77450
77451
77452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
77453   int jresult ;
77454   int result;
77455
77456   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
77457   jresult = (int)result;
77458   return jresult;
77459 }
77460
77461
77462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
77463   int jresult ;
77464   int result;
77465
77466   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
77467   jresult = (int)result;
77468   return jresult;
77469 }
77470
77471
77472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
77473   int jresult ;
77474   int result;
77475
77476   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
77477   jresult = (int)result;
77478   return jresult;
77479 }
77480
77481
77482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
77483   int jresult ;
77484   int result;
77485
77486   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
77487   jresult = (int)result;
77488   return jresult;
77489 }
77490
77491
77492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77493   int jresult ;
77494   int result;
77495
77496   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
77497   jresult = (int)result;
77498   return jresult;
77499 }
77500
77501
77502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
77503   int jresult ;
77504   int result;
77505
77506   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
77507   jresult = (int)result;
77508   return jresult;
77509 }
77510
77511
77512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
77513   int jresult ;
77514   int result;
77515
77516   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
77517   jresult = (int)result;
77518   return jresult;
77519 }
77520
77521
77522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77523   int jresult ;
77524   int result;
77525
77526   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
77527   jresult = (int)result;
77528   return jresult;
77529 }
77530
77531
77532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77533   int jresult ;
77534   int result;
77535
77536   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77537   jresult = (int)result;
77538   return jresult;
77539 }
77540
77541
77542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77543   int jresult ;
77544   int result;
77545
77546   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77547   jresult = (int)result;
77548   return jresult;
77549 }
77550
77551
77552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77553   int jresult ;
77554   int result;
77555
77556   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77557   jresult = (int)result;
77558   return jresult;
77559 }
77560
77561
77562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77563   int jresult ;
77564   int result;
77565
77566   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77567   jresult = (int)result;
77568   return jresult;
77569 }
77570
77571
77572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77573   int jresult ;
77574   int result;
77575
77576   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77577   jresult = (int)result;
77578   return jresult;
77579 }
77580
77581
77582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77583   int jresult ;
77584   int result;
77585
77586   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
77587   jresult = (int)result;
77588   return jresult;
77589 }
77590
77591
77592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
77593   int jresult ;
77594   int result;
77595
77596   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
77597   jresult = (int)result;
77598   return jresult;
77599 }
77600
77601
77602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
77603   int jresult ;
77604   int result;
77605
77606   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
77607   jresult = (int)result;
77608   return jresult;
77609 }
77610
77611
77612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
77613   int jresult ;
77614   int result;
77615
77616   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
77617   jresult = (int)result;
77618   return jresult;
77619 }
77620
77621
77622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
77623   int jresult ;
77624   int result;
77625
77626   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
77627   jresult = (int)result;
77628   return jresult;
77629 }
77630
77631
77632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
77633   int jresult ;
77634   int result;
77635
77636   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
77637   jresult = (int)result;
77638   return jresult;
77639 }
77640
77641
77642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
77643   int jresult ;
77644   int result;
77645
77646   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
77647   jresult = (int)result;
77648   return jresult;
77649 }
77650
77651
77652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
77653   int jresult ;
77654   int result;
77655
77656   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
77657   jresult = (int)result;
77658   return jresult;
77659 }
77660
77661
77662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
77663   int jresult ;
77664   int result;
77665
77666   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
77667   jresult = (int)result;
77668   return jresult;
77669 }
77670
77671
77672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
77673   int jresult ;
77674   int result;
77675
77676   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
77677   jresult = (int)result;
77678   return jresult;
77679 }
77680
77681
77682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
77683   int jresult ;
77684   int result;
77685
77686   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
77687   jresult = (int)result;
77688   return jresult;
77689 }
77690
77691
77692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
77693   int jresult ;
77694   int result;
77695
77696   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
77697   jresult = (int)result;
77698   return jresult;
77699 }
77700
77701
77702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
77703   int jresult ;
77704   int result;
77705
77706   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
77707   jresult = (int)result;
77708   return jresult;
77709 }
77710
77711
77712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
77713   int jresult ;
77714   int result;
77715
77716   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
77717   jresult = (int)result;
77718   return jresult;
77719 }
77720
77721
77722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
77723   int jresult ;
77724   int result;
77725
77726   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
77727   jresult = (int)result;
77728   return jresult;
77729 }
77730
77731
77732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
77733   int jresult ;
77734   int result;
77735
77736   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
77737   jresult = (int)result;
77738   return jresult;
77739 }
77740
77741
77742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
77743   void * jresult ;
77744   Dali::Toolkit::TextField::Property *result = 0 ;
77745
77746   {
77747     try {
77748       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
77749     } catch (std::out_of_range& e) {
77750       {
77751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77752       };
77753     } catch (std::exception& e) {
77754       {
77755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77756       };
77757     } catch (...) {
77758       {
77759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77760       };
77761     }
77762   }
77763   jresult = (void *)result;
77764   return jresult;
77765 }
77766
77767
77768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
77769   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
77770
77771   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
77772   {
77773     try {
77774       delete arg1;
77775     } catch (std::out_of_range& e) {
77776       {
77777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77778       };
77779     } catch (std::exception& e) {
77780       {
77781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77782       };
77783     } catch (...) {
77784       {
77785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77786       };
77787     }
77788   }
77789 }
77790
77791
77792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
77793   void * jresult ;
77794   Dali::Toolkit::TextField::InputStyle *result = 0 ;
77795
77796   {
77797     try {
77798       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
77799     } catch (std::out_of_range& e) {
77800       {
77801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77802       };
77803     } catch (std::exception& e) {
77804       {
77805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77806       };
77807     } catch (...) {
77808       {
77809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77810       };
77811     }
77812   }
77813   jresult = (void *)result;
77814   return jresult;
77815 }
77816
77817
77818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
77819   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
77820
77821   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
77822   {
77823     try {
77824       delete arg1;
77825     } catch (std::out_of_range& e) {
77826       {
77827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77828       };
77829     } catch (std::exception& e) {
77830       {
77831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77832       };
77833     } catch (...) {
77834       {
77835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77836       };
77837     }
77838   }
77839 }
77840
77841
77842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
77843   void * jresult ;
77844   Dali::Toolkit::TextField result;
77845
77846   {
77847     try {
77848       result = Dali::Toolkit::TextField::New();
77849     } catch (std::out_of_range& e) {
77850       {
77851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77852       };
77853     } catch (std::exception& e) {
77854       {
77855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77856       };
77857     } catch (...) {
77858       {
77859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77860       };
77861     }
77862   }
77863   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
77864   return jresult;
77865 }
77866
77867
77868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
77869   void * jresult ;
77870   Dali::Toolkit::TextField *result = 0 ;
77871
77872   {
77873     try {
77874       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
77875     } catch (std::out_of_range& e) {
77876       {
77877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77878       };
77879     } catch (std::exception& e) {
77880       {
77881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77882       };
77883     } catch (...) {
77884       {
77885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77886       };
77887     }
77888   }
77889   jresult = (void *)result;
77890   return jresult;
77891 }
77892
77893
77894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
77895   void * jresult ;
77896   Dali::Toolkit::TextField *arg1 = 0 ;
77897   Dali::Toolkit::TextField *result = 0 ;
77898
77899   arg1 = (Dali::Toolkit::TextField *)jarg1;
77900   if (!arg1) {
77901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
77902     return 0;
77903   }
77904   {
77905     try {
77906       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
77907     } catch (std::out_of_range& e) {
77908       {
77909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77910       };
77911     } catch (std::exception& e) {
77912       {
77913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77914       };
77915     } catch (...) {
77916       {
77917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77918       };
77919     }
77920   }
77921   jresult = (void *)result;
77922   return jresult;
77923 }
77924
77925
77926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
77927   void * jresult ;
77928   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77929   Dali::Toolkit::TextField *arg2 = 0 ;
77930   Dali::Toolkit::TextField *result = 0 ;
77931
77932   arg1 = (Dali::Toolkit::TextField *)jarg1;
77933   arg2 = (Dali::Toolkit::TextField *)jarg2;
77934   if (!arg2) {
77935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
77936     return 0;
77937   }
77938   {
77939     try {
77940       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
77941     } catch (std::out_of_range& e) {
77942       {
77943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77944       };
77945     } catch (std::exception& e) {
77946       {
77947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77948       };
77949     } catch (...) {
77950       {
77951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77952       };
77953     }
77954   }
77955   jresult = (void *)result;
77956   return jresult;
77957 }
77958
77959
77960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
77961   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77962
77963   arg1 = (Dali::Toolkit::TextField *)jarg1;
77964   {
77965     try {
77966       delete arg1;
77967     } catch (std::out_of_range& e) {
77968       {
77969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77970       };
77971     } catch (std::exception& e) {
77972       {
77973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77974       };
77975     } catch (...) {
77976       {
77977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77978       };
77979     }
77980   }
77981 }
77982
77983
77984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
77985   void * jresult ;
77986   Dali::BaseHandle arg1 ;
77987   Dali::BaseHandle *argp1 ;
77988   Dali::Toolkit::TextField result;
77989
77990   argp1 = (Dali::BaseHandle *)jarg1;
77991   if (!argp1) {
77992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77993     return 0;
77994   }
77995   arg1 = *argp1;
77996   {
77997     try {
77998       result = Dali::Toolkit::TextField::DownCast(arg1);
77999     } catch (std::out_of_range& e) {
78000       {
78001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78002       };
78003     } catch (std::exception& e) {
78004       {
78005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78006       };
78007     } catch (...) {
78008       {
78009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78010       };
78011     }
78012   }
78013   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78014   return jresult;
78015 }
78016
78017
78018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
78019   void * jresult ;
78020   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78021   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
78022
78023   arg1 = (Dali::Toolkit::TextField *)jarg1;
78024   {
78025     try {
78026       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78027     } catch (std::out_of_range& e) {
78028       {
78029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78030       };
78031     } catch (std::exception& e) {
78032       {
78033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78034       };
78035     } catch (...) {
78036       {
78037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78038       };
78039     }
78040   }
78041   jresult = (void *)result;
78042   return jresult;
78043 }
78044
78045
78046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
78047   void * jresult ;
78048   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78049   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
78050
78051   arg1 = (Dali::Toolkit::TextField *)jarg1;
78052   {
78053     try {
78054       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
78055     } catch (std::out_of_range& e) {
78056       {
78057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78058       };
78059     } catch (std::exception& e) {
78060       {
78061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78062       };
78063     } catch (...) {
78064       {
78065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78066       };
78067     }
78068   }
78069   jresult = (void *)result;
78070   return jresult;
78071 }
78072
78073
78074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
78075   void * jresult ;
78076   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78077   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
78078
78079   arg1 = (Dali::Toolkit::TextField *)jarg1;
78080   {
78081     try {
78082       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78083     } catch (std::out_of_range& e) {
78084       {
78085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78086       };
78087     } catch (std::exception& e) {
78088       {
78089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78090       };
78091     } catch (...) {
78092       {
78093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78094       };
78095     }
78096   }
78097   jresult = (void *)result;
78098   return jresult;
78099 }
78100
78101
78102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
78103   int jresult ;
78104   int result;
78105
78106   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
78107   jresult = (int)result;
78108   return jresult;
78109 }
78110
78111
78112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78113   int jresult ;
78114   int result;
78115
78116   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78117   jresult = (int)result;
78118   return jresult;
78119 }
78120
78121
78122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78123   int jresult ;
78124   int result;
78125
78126   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78127   jresult = (int)result;
78128   return jresult;
78129 }
78130
78131
78132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78133   int jresult ;
78134   int result;
78135
78136   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78137   jresult = (int)result;
78138   return jresult;
78139 }
78140
78141
78142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78143   int jresult ;
78144   int result;
78145
78146   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78147   jresult = (int)result;
78148   return jresult;
78149 }
78150
78151
78152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78153   int jresult ;
78154   int result;
78155
78156   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78157   jresult = (int)result;
78158   return jresult;
78159 }
78160
78161
78162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78163   int jresult ;
78164   int result;
78165
78166   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78167   jresult = (int)result;
78168   return jresult;
78169 }
78170
78171
78172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78173   int jresult ;
78174   int result;
78175
78176   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78177   jresult = (int)result;
78178   return jresult;
78179 }
78180
78181
78182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78183   int jresult ;
78184   int result;
78185
78186   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78187   jresult = (int)result;
78188   return jresult;
78189 }
78190
78191
78192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
78193   int jresult ;
78194   int result;
78195
78196   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
78197   jresult = (int)result;
78198   return jresult;
78199 }
78200
78201
78202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
78203   int jresult ;
78204   int result;
78205
78206   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
78207   jresult = (int)result;
78208   return jresult;
78209 }
78210
78211
78212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
78213   int jresult ;
78214   int result;
78215
78216   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
78217   jresult = (int)result;
78218   return jresult;
78219 }
78220
78221
78222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
78223   int jresult ;
78224   int result;
78225
78226   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
78227   jresult = (int)result;
78228   return jresult;
78229 }
78230
78231
78232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
78233   int jresult ;
78234   int result;
78235
78236   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
78237   jresult = (int)result;
78238   return jresult;
78239 }
78240
78241
78242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78243   int jresult ;
78244   int result;
78245
78246   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78247   jresult = (int)result;
78248   return jresult;
78249 }
78250
78251
78252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78253   int jresult ;
78254   int result;
78255
78256   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78257   jresult = (int)result;
78258   return jresult;
78259 }
78260
78261
78262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78263   int jresult ;
78264   int result;
78265
78266   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78267   jresult = (int)result;
78268   return jresult;
78269 }
78270
78271
78272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78273   int jresult ;
78274   int result;
78275
78276   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78277   jresult = (int)result;
78278   return jresult;
78279 }
78280
78281
78282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78283   int jresult ;
78284   int result;
78285
78286   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78287   jresult = (int)result;
78288   return jresult;
78289 }
78290
78291
78292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78293   int jresult ;
78294   int result;
78295
78296   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78297   jresult = (int)result;
78298   return jresult;
78299 }
78300
78301
78302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78303   int jresult ;
78304   int result;
78305
78306   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78307   jresult = (int)result;
78308   return jresult;
78309 }
78310
78311
78312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78313   int jresult ;
78314   int result;
78315
78316   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78317   jresult = (int)result;
78318   return jresult;
78319 }
78320
78321
78322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78323   int jresult ;
78324   int result;
78325
78326   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78327   jresult = (int)result;
78328   return jresult;
78329 }
78330
78331
78332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78333   int jresult ;
78334   int result;
78335
78336   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78337   jresult = (int)result;
78338   return jresult;
78339 }
78340
78341
78342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78343   void * jresult ;
78344   Dali::Toolkit::TextLabel::Property *result = 0 ;
78345
78346   {
78347     try {
78348       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78349     } catch (std::out_of_range& e) {
78350       {
78351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78352       };
78353     } catch (std::exception& e) {
78354       {
78355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78356       };
78357     } catch (...) {
78358       {
78359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78360       };
78361     }
78362   }
78363   jresult = (void *)result;
78364   return jresult;
78365 }
78366
78367
78368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78369   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78370
78371   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78372   {
78373     try {
78374       delete arg1;
78375     } catch (std::out_of_range& e) {
78376       {
78377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78378       };
78379     } catch (std::exception& e) {
78380       {
78381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78382       };
78383     } catch (...) {
78384       {
78385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78386       };
78387     }
78388   }
78389 }
78390
78391
78392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78393   void * jresult ;
78394   Dali::Toolkit::TextLabel result;
78395
78396   {
78397     try {
78398       result = Dali::Toolkit::TextLabel::New();
78399     } catch (std::out_of_range& e) {
78400       {
78401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78402       };
78403     } catch (std::exception& e) {
78404       {
78405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78406       };
78407     } catch (...) {
78408       {
78409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78410       };
78411     }
78412   }
78413   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78414   return jresult;
78415 }
78416
78417
78418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78419   void * jresult ;
78420   std::string *arg1 = 0 ;
78421   Dali::Toolkit::TextLabel result;
78422
78423   if (!jarg1) {
78424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78425     return 0;
78426   }
78427   std::string arg1_str(jarg1);
78428   arg1 = &arg1_str;
78429   {
78430     try {
78431       result = Dali::Toolkit::TextLabel::New((std::string const &)*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::TextLabel((const Dali::Toolkit::TextLabel &)result);
78447
78448   //argout typemap for const std::string&
78449
78450   return jresult;
78451 }
78452
78453
78454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78455   void * jresult ;
78456   Dali::Toolkit::TextLabel *result = 0 ;
78457
78458   {
78459     try {
78460       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78461     } catch (std::out_of_range& e) {
78462       {
78463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78464       };
78465     } catch (std::exception& e) {
78466       {
78467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78468       };
78469     } catch (...) {
78470       {
78471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78472       };
78473     }
78474   }
78475   jresult = (void *)result;
78476   return jresult;
78477 }
78478
78479
78480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78481   void * jresult ;
78482   Dali::Toolkit::TextLabel *arg1 = 0 ;
78483   Dali::Toolkit::TextLabel *result = 0 ;
78484
78485   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78486   if (!arg1) {
78487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78488     return 0;
78489   }
78490   {
78491     try {
78492       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78493     } catch (std::out_of_range& e) {
78494       {
78495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78496       };
78497     } catch (std::exception& e) {
78498       {
78499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78500       };
78501     } catch (...) {
78502       {
78503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78504       };
78505     }
78506   }
78507   jresult = (void *)result;
78508   return jresult;
78509 }
78510
78511
78512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78513   void * jresult ;
78514   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78515   Dali::Toolkit::TextLabel *arg2 = 0 ;
78516   Dali::Toolkit::TextLabel *result = 0 ;
78517
78518   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78519   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78520   if (!arg2) {
78521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78522     return 0;
78523   }
78524   {
78525     try {
78526       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78527     } catch (std::out_of_range& e) {
78528       {
78529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78530       };
78531     } catch (std::exception& e) {
78532       {
78533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78534       };
78535     } catch (...) {
78536       {
78537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78538       };
78539     }
78540   }
78541   jresult = (void *)result;
78542   return jresult;
78543 }
78544
78545
78546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78547   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78548
78549   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78550   {
78551     try {
78552       delete arg1;
78553     } catch (std::out_of_range& e) {
78554       {
78555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78556       };
78557     } catch (std::exception& e) {
78558       {
78559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78560       };
78561     } catch (...) {
78562       {
78563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78564       };
78565     }
78566   }
78567 }
78568
78569
78570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78571   void * jresult ;
78572   Dali::BaseHandle arg1 ;
78573   Dali::BaseHandle *argp1 ;
78574   Dali::Toolkit::TextLabel result;
78575
78576   argp1 = (Dali::BaseHandle *)jarg1;
78577   if (!argp1) {
78578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78579     return 0;
78580   }
78581   arg1 = *argp1;
78582   {
78583     try {
78584       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78585     } catch (std::out_of_range& e) {
78586       {
78587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78588       };
78589     } catch (std::exception& e) {
78590       {
78591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78592       };
78593     } catch (...) {
78594       {
78595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78596       };
78597     }
78598   }
78599   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78600   return jresult;
78601 }
78602
78603
78604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78605   void * jresult ;
78606   Dali::Toolkit::AccessibilityManager *result = 0 ;
78607
78608   {
78609     try {
78610       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78611     } catch (std::out_of_range& e) {
78612       {
78613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78614       };
78615     } catch (std::exception& e) {
78616       {
78617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78618       };
78619     } catch (...) {
78620       {
78621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78622       };
78623     }
78624   }
78625   jresult = (void *)result;
78626   return jresult;
78627 }
78628
78629
78630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78631   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78632
78633   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78634   {
78635     try {
78636       delete arg1;
78637     } catch (std::out_of_range& e) {
78638       {
78639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78640       };
78641     } catch (std::exception& e) {
78642       {
78643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78644       };
78645     } catch (...) {
78646       {
78647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78648       };
78649     }
78650   }
78651 }
78652
78653
78654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78655   void * jresult ;
78656   Dali::Toolkit::AccessibilityManager result;
78657
78658   {
78659     try {
78660       result = Dali::Toolkit::AccessibilityManager::Get();
78661     } catch (std::out_of_range& e) {
78662       {
78663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78664       };
78665     } catch (std::exception& e) {
78666       {
78667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78668       };
78669     } catch (...) {
78670       {
78671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78672       };
78673     }
78674   }
78675   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78676   return jresult;
78677 }
78678
78679
78680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78681   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78682   Dali::Actor arg2 ;
78683   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78684   std::string *arg4 = 0 ;
78685   Dali::Actor *argp2 ;
78686
78687   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78688   argp2 = (Dali::Actor *)jarg2;
78689   if (!argp2) {
78690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78691     return ;
78692   }
78693   arg2 = *argp2;
78694   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78695   if (!jarg4) {
78696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78697     return ;
78698   }
78699   std::string arg4_str(jarg4);
78700   arg4 = &arg4_str;
78701   {
78702     try {
78703       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
78704     } catch (std::out_of_range& e) {
78705       {
78706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78707       };
78708     } catch (std::exception& e) {
78709       {
78710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78711       };
78712     } catch (...) {
78713       {
78714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78715       };
78716     }
78717   }
78718
78719   //argout typemap for const std::string&
78720
78721 }
78722
78723
78724 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
78725   char * jresult ;
78726   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78727   Dali::Actor arg2 ;
78728   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78729   Dali::Actor *argp2 ;
78730   std::string result;
78731
78732   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78733   argp2 = (Dali::Actor *)jarg2;
78734   if (!argp2) {
78735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78736     return 0;
78737   }
78738   arg2 = *argp2;
78739   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78740   {
78741     try {
78742       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
78743     } catch (std::out_of_range& e) {
78744       {
78745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78746       };
78747     } catch (std::exception& e) {
78748       {
78749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78750       };
78751     } catch (...) {
78752       {
78753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78754       };
78755     }
78756   }
78757   jresult = SWIG_csharp_string_callback((&result)->c_str());
78758   return jresult;
78759 }
78760
78761
78762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
78763   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78764   Dali::Actor arg2 ;
78765   unsigned int arg3 ;
78766   Dali::Actor *argp2 ;
78767
78768   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78769   argp2 = (Dali::Actor *)jarg2;
78770   if (!argp2) {
78771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78772     return ;
78773   }
78774   arg2 = *argp2;
78775   arg3 = (unsigned int)jarg3;
78776   {
78777     try {
78778       (arg1)->SetFocusOrder(arg2,arg3);
78779     } catch (std::out_of_range& e) {
78780       {
78781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78782       };
78783     } catch (std::exception& e) {
78784       {
78785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78786       };
78787     } catch (...) {
78788       {
78789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78790       };
78791     }
78792   }
78793 }
78794
78795
78796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
78797   unsigned int jresult ;
78798   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78799   Dali::Actor arg2 ;
78800   Dali::Actor *argp2 ;
78801   unsigned int result;
78802
78803   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78804   argp2 = (Dali::Actor *)jarg2;
78805   if (!argp2) {
78806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78807     return 0;
78808   }
78809   arg2 = *argp2;
78810   {
78811     try {
78812       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
78813     } catch (std::out_of_range& e) {
78814       {
78815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78816       };
78817     } catch (std::exception& e) {
78818       {
78819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78820       };
78821     } catch (...) {
78822       {
78823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78824       };
78825     }
78826   }
78827   jresult = result;
78828   return jresult;
78829 }
78830
78831
78832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
78833   unsigned int jresult ;
78834   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78835   unsigned int result;
78836
78837   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78838   {
78839     try {
78840       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
78841     } catch (std::out_of_range& e) {
78842       {
78843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78844       };
78845     } catch (std::exception& e) {
78846       {
78847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78848       };
78849     } catch (...) {
78850       {
78851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78852       };
78853     }
78854   }
78855   jresult = result;
78856   return jresult;
78857 }
78858
78859
78860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
78861   void * jresult ;
78862   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78863   unsigned int arg2 ;
78864   Dali::Actor result;
78865
78866   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78867   arg2 = (unsigned int)jarg2;
78868   {
78869     try {
78870       result = (arg1)->GetActorByFocusOrder(arg2);
78871     } catch (std::out_of_range& e) {
78872       {
78873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78874       };
78875     } catch (std::exception& e) {
78876       {
78877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78878       };
78879     } catch (...) {
78880       {
78881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78882       };
78883     }
78884   }
78885   jresult = new Dali::Actor((const Dali::Actor &)result);
78886   return jresult;
78887 }
78888
78889
78890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
78891   unsigned int jresult ;
78892   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78893   Dali::Actor arg2 ;
78894   Dali::Actor *argp2 ;
78895   bool result;
78896
78897   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78898   argp2 = (Dali::Actor *)jarg2;
78899   if (!argp2) {
78900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78901     return 0;
78902   }
78903   arg2 = *argp2;
78904   {
78905     try {
78906       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
78907     } catch (std::out_of_range& e) {
78908       {
78909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78910       };
78911     } catch (std::exception& e) {
78912       {
78913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78914       };
78915     } catch (...) {
78916       {
78917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78918       };
78919     }
78920   }
78921   jresult = result;
78922   return jresult;
78923 }
78924
78925
78926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
78927   void * jresult ;
78928   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78929   Dali::Actor result;
78930
78931   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78932   {
78933     try {
78934       result = (arg1)->GetCurrentFocusActor();
78935     } catch (std::out_of_range& e) {
78936       {
78937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78938       };
78939     } catch (std::exception& e) {
78940       {
78941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78942       };
78943     } catch (...) {
78944       {
78945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78946       };
78947     }
78948   }
78949   jresult = new Dali::Actor((const Dali::Actor &)result);
78950   return jresult;
78951 }
78952
78953
78954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
78955   void * jresult ;
78956   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78957   Dali::Actor result;
78958
78959   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78960   {
78961     try {
78962       result = (arg1)->GetCurrentFocusGroup();
78963     } catch (std::out_of_range& e) {
78964       {
78965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78966       };
78967     } catch (std::exception& e) {
78968       {
78969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78970       };
78971     } catch (...) {
78972       {
78973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78974       };
78975     }
78976   }
78977   jresult = new Dali::Actor((const Dali::Actor &)result);
78978   return jresult;
78979 }
78980
78981
78982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
78983   unsigned int jresult ;
78984   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78985   unsigned int result;
78986
78987   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78988   {
78989     try {
78990       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
78991     } catch (std::out_of_range& e) {
78992       {
78993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78994       };
78995     } catch (std::exception& e) {
78996       {
78997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78998       };
78999     } catch (...) {
79000       {
79001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79002       };
79003     }
79004   }
79005   jresult = result;
79006   return jresult;
79007 }
79008
79009
79010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79011   unsigned int jresult ;
79012   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79013   bool result;
79014
79015   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79016   {
79017     try {
79018       result = (bool)(arg1)->MoveFocusForward();
79019     } catch (std::out_of_range& e) {
79020       {
79021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79022       };
79023     } catch (std::exception& e) {
79024       {
79025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79026       };
79027     } catch (...) {
79028       {
79029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79030       };
79031     }
79032   }
79033   jresult = result;
79034   return jresult;
79035 }
79036
79037
79038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79039   unsigned int jresult ;
79040   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79041   bool result;
79042
79043   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79044   {
79045     try {
79046       result = (bool)(arg1)->MoveFocusBackward();
79047     } catch (std::out_of_range& e) {
79048       {
79049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79050       };
79051     } catch (std::exception& e) {
79052       {
79053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79054       };
79055     } catch (...) {
79056       {
79057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79058       };
79059     }
79060   }
79061   jresult = result;
79062   return jresult;
79063 }
79064
79065
79066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79067   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79068
79069   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79070   {
79071     try {
79072       (arg1)->ClearFocus();
79073     } catch (std::out_of_range& e) {
79074       {
79075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79076       };
79077     } catch (std::exception& e) {
79078       {
79079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79080       };
79081     } catch (...) {
79082       {
79083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79084       };
79085     }
79086   }
79087 }
79088
79089
79090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79091   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79092
79093   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79094   {
79095     try {
79096       (arg1)->Reset();
79097     } catch (std::out_of_range& e) {
79098       {
79099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79100       };
79101     } catch (std::exception& e) {
79102       {
79103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79104       };
79105     } catch (...) {
79106       {
79107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79108       };
79109     }
79110   }
79111 }
79112
79113
79114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79115   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79116   Dali::Actor arg2 ;
79117   bool arg3 ;
79118   Dali::Actor *argp2 ;
79119
79120   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79121   argp2 = (Dali::Actor *)jarg2;
79122   if (!argp2) {
79123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79124     return ;
79125   }
79126   arg2 = *argp2;
79127   arg3 = jarg3 ? true : false;
79128   {
79129     try {
79130       (arg1)->SetFocusGroup(arg2,arg3);
79131     } catch (std::out_of_range& e) {
79132       {
79133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79134       };
79135     } catch (std::exception& e) {
79136       {
79137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79138       };
79139     } catch (...) {
79140       {
79141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79142       };
79143     }
79144   }
79145 }
79146
79147
79148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79149   unsigned int jresult ;
79150   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79151   Dali::Actor arg2 ;
79152   Dali::Actor *argp2 ;
79153   bool result;
79154
79155   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79156   argp2 = (Dali::Actor *)jarg2;
79157   if (!argp2) {
79158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79159     return 0;
79160   }
79161   arg2 = *argp2;
79162   {
79163     try {
79164       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79165     } catch (std::out_of_range& e) {
79166       {
79167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79168       };
79169     } catch (std::exception& e) {
79170       {
79171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79172       };
79173     } catch (...) {
79174       {
79175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79176       };
79177     }
79178   }
79179   jresult = result;
79180   return jresult;
79181 }
79182
79183
79184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79185   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79186   bool arg2 ;
79187
79188   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79189   arg2 = jarg2 ? true : false;
79190   {
79191     try {
79192       (arg1)->SetGroupMode(arg2);
79193     } catch (std::out_of_range& e) {
79194       {
79195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79196       };
79197     } catch (std::exception& e) {
79198       {
79199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79200       };
79201     } catch (...) {
79202       {
79203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79204       };
79205     }
79206   }
79207 }
79208
79209
79210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79211   unsigned int jresult ;
79212   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79213   bool result;
79214
79215   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79216   {
79217     try {
79218       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79219     } catch (std::out_of_range& e) {
79220       {
79221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79222       };
79223     } catch (std::exception& e) {
79224       {
79225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79226       };
79227     } catch (...) {
79228       {
79229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79230       };
79231     }
79232   }
79233   jresult = result;
79234   return jresult;
79235 }
79236
79237
79238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79239   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79240   bool arg2 ;
79241
79242   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79243   arg2 = jarg2 ? true : false;
79244   {
79245     try {
79246       (arg1)->SetWrapMode(arg2);
79247     } catch (std::out_of_range& e) {
79248       {
79249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79250       };
79251     } catch (std::exception& e) {
79252       {
79253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79254       };
79255     } catch (...) {
79256       {
79257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79258       };
79259     }
79260   }
79261 }
79262
79263
79264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79265   unsigned int jresult ;
79266   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79267   bool result;
79268
79269   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79270   {
79271     try {
79272       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79273     } catch (std::out_of_range& e) {
79274       {
79275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79276       };
79277     } catch (std::exception& e) {
79278       {
79279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79280       };
79281     } catch (...) {
79282       {
79283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79284       };
79285     }
79286   }
79287   jresult = result;
79288   return jresult;
79289 }
79290
79291
79292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79293   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79294   Dali::Actor arg2 ;
79295   Dali::Actor *argp2 ;
79296
79297   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79298   argp2 = (Dali::Actor *)jarg2;
79299   if (!argp2) {
79300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79301     return ;
79302   }
79303   arg2 = *argp2;
79304   {
79305     try {
79306       (arg1)->SetFocusIndicatorActor(arg2);
79307     } catch (std::out_of_range& e) {
79308       {
79309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79310       };
79311     } catch (std::exception& e) {
79312       {
79313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79314       };
79315     } catch (...) {
79316       {
79317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79318       };
79319     }
79320   }
79321 }
79322
79323
79324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79325   void * jresult ;
79326   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79327   Dali::Actor result;
79328
79329   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79330   {
79331     try {
79332       result = (arg1)->GetFocusIndicatorActor();
79333     } catch (std::out_of_range& e) {
79334       {
79335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79336       };
79337     } catch (std::exception& e) {
79338       {
79339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79340       };
79341     } catch (...) {
79342       {
79343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79344       };
79345     }
79346   }
79347   jresult = new Dali::Actor((const Dali::Actor &)result);
79348   return jresult;
79349 }
79350
79351
79352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79353   void * jresult ;
79354   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79355   Dali::Actor arg2 ;
79356   Dali::Actor *argp2 ;
79357   Dali::Actor result;
79358
79359   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79360   argp2 = (Dali::Actor *)jarg2;
79361   if (!argp2) {
79362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79363     return 0;
79364   }
79365   arg2 = *argp2;
79366   {
79367     try {
79368       result = (arg1)->GetFocusGroup(arg2);
79369     } catch (std::out_of_range& e) {
79370       {
79371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79372       };
79373     } catch (std::exception& e) {
79374       {
79375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79376       };
79377     } catch (...) {
79378       {
79379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79380       };
79381     }
79382   }
79383   jresult = new Dali::Actor((const Dali::Actor &)result);
79384   return jresult;
79385 }
79386
79387
79388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79389   void * jresult ;
79390   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79391   Dali::Vector2 result;
79392
79393   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79394   {
79395     try {
79396       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79397     } catch (std::out_of_range& e) {
79398       {
79399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79400       };
79401     } catch (std::exception& e) {
79402       {
79403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79404       };
79405     } catch (...) {
79406       {
79407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79408       };
79409     }
79410   }
79411   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79412   return jresult;
79413 }
79414
79415
79416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79417   void * jresult ;
79418   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79419   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79420
79421   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79422   {
79423     try {
79424       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79425     } catch (std::out_of_range& e) {
79426       {
79427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79428       };
79429     } catch (std::exception& e) {
79430       {
79431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79432       };
79433     } catch (...) {
79434       {
79435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79436       };
79437     }
79438   }
79439   jresult = (void *)result;
79440   return jresult;
79441 }
79442
79443
79444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79445   void * jresult ;
79446   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79447   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79448
79449   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79450   {
79451     try {
79452       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79453     } catch (std::out_of_range& e) {
79454       {
79455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79456       };
79457     } catch (std::exception& e) {
79458       {
79459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79460       };
79461     } catch (...) {
79462       {
79463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79464       };
79465     }
79466   }
79467   jresult = (void *)result;
79468   return jresult;
79469 }
79470
79471
79472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79473   void * jresult ;
79474   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79475   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79476
79477   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79478   {
79479     try {
79480       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79481     } catch (std::out_of_range& e) {
79482       {
79483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79484       };
79485     } catch (std::exception& e) {
79486       {
79487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79488       };
79489     } catch (...) {
79490       {
79491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79492       };
79493     }
79494   }
79495   jresult = (void *)result;
79496   return jresult;
79497 }
79498
79499
79500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79501   void * jresult ;
79502   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79503   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79504
79505   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79506   {
79507     try {
79508       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79509     } catch (std::out_of_range& e) {
79510       {
79511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79512       };
79513     } catch (std::exception& e) {
79514       {
79515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79516       };
79517     } catch (...) {
79518       {
79519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79520       };
79521     }
79522   }
79523   jresult = (void *)result;
79524   return jresult;
79525 }
79526
79527
79528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79529   void * jresult ;
79530   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79531   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79532
79533   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79534   {
79535     try {
79536       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79537     } catch (std::out_of_range& e) {
79538       {
79539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79540       };
79541     } catch (std::exception& e) {
79542       {
79543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79544       };
79545     } catch (...) {
79546       {
79547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79548       };
79549     }
79550   }
79551   jresult = (void *)result;
79552   return jresult;
79553 }
79554
79555
79556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
79557   void * jresult ;
79558   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79559   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79560
79561   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79562   {
79563     try {
79564       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
79565     } catch (std::out_of_range& e) {
79566       {
79567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79568       };
79569     } catch (std::exception& e) {
79570       {
79571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79572       };
79573     } catch (...) {
79574       {
79575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79576       };
79577     }
79578   }
79579   jresult = (void *)result;
79580   return jresult;
79581 }
79582
79583
79584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
79585   void * jresult ;
79586   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79587   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79588
79589   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79590   {
79591     try {
79592       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
79593     } catch (std::out_of_range& e) {
79594       {
79595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79596       };
79597     } catch (std::exception& e) {
79598       {
79599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79600       };
79601     } catch (...) {
79602       {
79603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79604       };
79605     }
79606   }
79607   jresult = (void *)result;
79608   return jresult;
79609 }
79610
79611
79612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
79613   void * jresult ;
79614   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79615   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79616
79617   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79618   {
79619     try {
79620       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
79621     } catch (std::out_of_range& e) {
79622       {
79623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79624       };
79625     } catch (std::exception& e) {
79626       {
79627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79628       };
79629     } catch (...) {
79630       {
79631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79632       };
79633     }
79634   }
79635   jresult = (void *)result;
79636   return jresult;
79637 }
79638
79639
79640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
79641   void * jresult ;
79642   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79643   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79644
79645   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79646   {
79647     try {
79648       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
79649     } catch (std::out_of_range& e) {
79650       {
79651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79652       };
79653     } catch (std::exception& e) {
79654       {
79655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79656       };
79657     } catch (...) {
79658       {
79659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79660       };
79661     }
79662   }
79663   jresult = (void *)result;
79664   return jresult;
79665 }
79666
79667
79668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
79669   void * jresult ;
79670   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79671   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79672
79673   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79674   {
79675     try {
79676       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
79677     } catch (std::out_of_range& e) {
79678       {
79679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79680       };
79681     } catch (std::exception& e) {
79682       {
79683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79684       };
79685     } catch (...) {
79686       {
79687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79688       };
79689     }
79690   }
79691   jresult = (void *)result;
79692   return jresult;
79693 }
79694
79695
79696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
79697   void * jresult ;
79698   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79699   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79700
79701   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79702   {
79703     try {
79704       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
79705     } catch (std::out_of_range& e) {
79706       {
79707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79708       };
79709     } catch (std::exception& e) {
79710       {
79711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79712       };
79713     } catch (...) {
79714       {
79715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79716       };
79717     }
79718   }
79719   jresult = (void *)result;
79720   return jresult;
79721 }
79722
79723
79724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
79725   void * jresult ;
79726   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79727   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79728
79729   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79730   {
79731     try {
79732       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
79733     } catch (std::out_of_range& e) {
79734       {
79735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79736       };
79737     } catch (std::exception& e) {
79738       {
79739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79740       };
79741     } catch (...) {
79742       {
79743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79744       };
79745     }
79746   }
79747   jresult = (void *)result;
79748   return jresult;
79749 }
79750
79751
79752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
79753   void * jresult ;
79754   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79755   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79756
79757   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79758   {
79759     try {
79760       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
79761     } catch (std::out_of_range& e) {
79762       {
79763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79764       };
79765     } catch (std::exception& e) {
79766       {
79767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79768       };
79769     } catch (...) {
79770       {
79771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79772       };
79773     }
79774   }
79775   jresult = (void *)result;
79776   return jresult;
79777 }
79778
79779
79780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
79781   void * jresult ;
79782   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79783   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79784
79785   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79786   {
79787     try {
79788       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
79789     } catch (std::out_of_range& e) {
79790       {
79791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79792       };
79793     } catch (std::exception& e) {
79794       {
79795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79796       };
79797     } catch (...) {
79798       {
79799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79800       };
79801     }
79802   }
79803   jresult = (void *)result;
79804   return jresult;
79805 }
79806
79807
79808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
79809   void * jresult ;
79810   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79811   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79812
79813   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79814   {
79815     try {
79816       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
79817     } catch (std::out_of_range& e) {
79818       {
79819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79820       };
79821     } catch (std::exception& e) {
79822       {
79823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79824       };
79825     } catch (...) {
79826       {
79827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79828       };
79829     }
79830   }
79831   jresult = (void *)result;
79832   return jresult;
79833 }
79834
79835
79836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
79837   void * jresult ;
79838   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79839   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79840
79841   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79842   {
79843     try {
79844       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
79845     } catch (std::out_of_range& e) {
79846       {
79847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79848       };
79849     } catch (std::exception& e) {
79850       {
79851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79852       };
79853     } catch (...) {
79854       {
79855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79856       };
79857     }
79858   }
79859   jresult = (void *)result;
79860   return jresult;
79861 }
79862
79863
79864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
79865   void * jresult ;
79866   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79867   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79868
79869   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79870   {
79871     try {
79872       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
79873     } catch (std::out_of_range& e) {
79874       {
79875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79876       };
79877     } catch (std::exception& e) {
79878       {
79879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79880       };
79881     } catch (...) {
79882       {
79883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79884       };
79885     }
79886   }
79887   jresult = (void *)result;
79888   return jresult;
79889 }
79890
79891
79892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
79893   void * jresult ;
79894   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79895   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79896
79897   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79898   {
79899     try {
79900       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
79901     } catch (std::out_of_range& e) {
79902       {
79903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79904       };
79905     } catch (std::exception& e) {
79906       {
79907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79908       };
79909     } catch (...) {
79910       {
79911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79912       };
79913     }
79914   }
79915   jresult = (void *)result;
79916   return jresult;
79917 }
79918
79919
79920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
79921   void * jresult ;
79922   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79923   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79924
79925   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79926   {
79927     try {
79928       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
79929     } catch (std::out_of_range& e) {
79930       {
79931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79932       };
79933     } catch (std::exception& e) {
79934       {
79935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79936       };
79937     } catch (...) {
79938       {
79939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79940       };
79941     }
79942   }
79943   jresult = (void *)result;
79944   return jresult;
79945 }
79946
79947
79948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
79949   void * jresult ;
79950   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79951   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79952
79953   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79954   {
79955     try {
79956       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
79957     } catch (std::out_of_range& e) {
79958       {
79959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79960       };
79961     } catch (std::exception& e) {
79962       {
79963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79964       };
79965     } catch (...) {
79966       {
79967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79968       };
79969     }
79970   }
79971   jresult = (void *)result;
79972   return jresult;
79973 }
79974
79975
79976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
79977   void * jresult ;
79978   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79979   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79980
79981   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79982   {
79983     try {
79984       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
79985     } catch (std::out_of_range& e) {
79986       {
79987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79988       };
79989     } catch (std::exception& e) {
79990       {
79991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79992       };
79993     } catch (...) {
79994       {
79995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79996       };
79997     }
79998   }
79999   jresult = (void *)result;
80000   return jresult;
80001 }
80002
80003
80004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80005   void * jresult ;
80006   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80007   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80008
80009   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80010   {
80011     try {
80012       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80013     } catch (std::out_of_range& e) {
80014       {
80015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80016       };
80017     } catch (std::exception& e) {
80018       {
80019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80020       };
80021     } catch (...) {
80022       {
80023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80024       };
80025     }
80026   }
80027   jresult = (void *)result;
80028   return jresult;
80029 }
80030
80031
80032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80033   void * jresult ;
80034   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80035   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80036
80037   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80038   {
80039     try {
80040       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80041     } catch (std::out_of_range& e) {
80042       {
80043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80044       };
80045     } catch (std::exception& e) {
80046       {
80047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80048       };
80049     } catch (...) {
80050       {
80051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80052       };
80053     }
80054   }
80055   jresult = (void *)result;
80056   return jresult;
80057 }
80058
80059
80060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80061   void * jresult ;
80062   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80063   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80064
80065   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80066   {
80067     try {
80068       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80069     } catch (std::out_of_range& e) {
80070       {
80071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80072       };
80073     } catch (std::exception& e) {
80074       {
80075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80076       };
80077     } catch (...) {
80078       {
80079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80080       };
80081     }
80082   }
80083   jresult = (void *)result;
80084   return jresult;
80085 }
80086
80087
80088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80089   void * jresult ;
80090   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80091   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80092
80093   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80094   {
80095     try {
80096       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80097     } catch (std::out_of_range& e) {
80098       {
80099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80100       };
80101     } catch (std::exception& e) {
80102       {
80103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80104       };
80105     } catch (...) {
80106       {
80107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80108       };
80109     }
80110   }
80111   jresult = (void *)result;
80112   return jresult;
80113 }
80114
80115
80116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80117   void * jresult ;
80118   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80119   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80120
80121   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80122   {
80123     try {
80124       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80125     } catch (std::out_of_range& e) {
80126       {
80127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80128       };
80129     } catch (std::exception& e) {
80130       {
80131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80132       };
80133     } catch (...) {
80134       {
80135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80136       };
80137     }
80138   }
80139   jresult = (void *)result;
80140   return jresult;
80141 }
80142
80143
80144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
80145   void * jresult ;
80146   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80147   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80148
80149   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80150   {
80151     try {
80152       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
80153     } catch (std::out_of_range& e) {
80154       {
80155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80156       };
80157     } catch (std::exception& e) {
80158       {
80159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80160       };
80161     } catch (...) {
80162       {
80163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80164       };
80165     }
80166   }
80167   jresult = (void *)result;
80168   return jresult;
80169 }
80170
80171
80172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80173   void * jresult ;
80174   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80175   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80176
80177   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80178   {
80179     try {
80180       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80181     } catch (std::out_of_range& e) {
80182       {
80183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80184       };
80185     } catch (std::exception& e) {
80186       {
80187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80188       };
80189     } catch (...) {
80190       {
80191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80192       };
80193     }
80194   }
80195   jresult = (void *)result;
80196   return jresult;
80197 }
80198
80199
80200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80201   void * jresult ;
80202   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80203   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80204
80205   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80206   {
80207     try {
80208       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80209     } catch (std::out_of_range& e) {
80210       {
80211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80212       };
80213     } catch (std::exception& e) {
80214       {
80215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80216       };
80217     } catch (...) {
80218       {
80219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80220       };
80221     }
80222   }
80223   jresult = (void *)result;
80224   return jresult;
80225 }
80226
80227
80228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80229   void * jresult ;
80230   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80231   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80232
80233   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80234   {
80235     try {
80236       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80237     } catch (std::out_of_range& e) {
80238       {
80239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80240       };
80241     } catch (std::exception& e) {
80242       {
80243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80244       };
80245     } catch (...) {
80246       {
80247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80248       };
80249     }
80250   }
80251   jresult = (void *)result;
80252   return jresult;
80253 }
80254
80255
80256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80257   void * jresult ;
80258   Dali::Toolkit::StyleManager *result = 0 ;
80259
80260   {
80261     try {
80262       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80263     } catch (std::out_of_range& e) {
80264       {
80265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80266       };
80267     } catch (std::exception& e) {
80268       {
80269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80270       };
80271     } catch (...) {
80272       {
80273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80274       };
80275     }
80276   }
80277   jresult = (void *)result;
80278   return jresult;
80279 }
80280
80281
80282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80283   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80284
80285   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80286   {
80287     try {
80288       delete arg1;
80289     } catch (std::out_of_range& e) {
80290       {
80291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80292       };
80293     } catch (std::exception& e) {
80294       {
80295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80296       };
80297     } catch (...) {
80298       {
80299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80300       };
80301     }
80302   }
80303 }
80304
80305
80306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80307   void * jresult ;
80308   Dali::Toolkit::StyleManager result;
80309
80310   {
80311     try {
80312       result = Dali::Toolkit::StyleManager::Get();
80313     } catch (std::out_of_range& e) {
80314       {
80315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80316       };
80317     } catch (std::exception& e) {
80318       {
80319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80320       };
80321     } catch (...) {
80322       {
80323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80324       };
80325     }
80326   }
80327   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80328   return jresult;
80329 }
80330
80331
80332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80333   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80334   std::string *arg2 = 0 ;
80335
80336   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80337   if (!jarg2) {
80338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80339     return ;
80340   }
80341   std::string arg2_str(jarg2);
80342   arg2 = &arg2_str;
80343   {
80344     try {
80345       (arg1)->ApplyTheme((std::string const &)*arg2);
80346     } catch (std::out_of_range& e) {
80347       {
80348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80349       };
80350     } catch (std::exception& e) {
80351       {
80352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80353       };
80354     } catch (...) {
80355       {
80356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80357       };
80358     }
80359   }
80360
80361   //argout typemap for const std::string&
80362
80363 }
80364
80365
80366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80367   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80368
80369   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80370   {
80371     try {
80372       (arg1)->ApplyDefaultTheme();
80373     } catch (std::out_of_range& e) {
80374       {
80375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80376       };
80377     } catch (std::exception& e) {
80378       {
80379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80380       };
80381     } catch (...) {
80382       {
80383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80384       };
80385     }
80386   }
80387 }
80388
80389
80390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80391   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80392   std::string *arg2 = 0 ;
80393   Dali::Property::Value *arg3 = 0 ;
80394
80395   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80396   if (!jarg2) {
80397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80398     return ;
80399   }
80400   std::string arg2_str(jarg2);
80401   arg2 = &arg2_str;
80402   arg3 = (Dali::Property::Value *)jarg3;
80403   if (!arg3) {
80404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80405     return ;
80406   }
80407   {
80408     try {
80409       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80410     } catch (std::out_of_range& e) {
80411       {
80412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80413       };
80414     } catch (std::exception& e) {
80415       {
80416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80417       };
80418     } catch (...) {
80419       {
80420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80421       };
80422     }
80423   }
80424
80425   //argout typemap for const std::string&
80426
80427 }
80428
80429
80430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80431   unsigned int jresult ;
80432   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80433   std::string *arg2 = 0 ;
80434   Dali::Property::Value *arg3 = 0 ;
80435   bool result;
80436
80437   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80438   if (!jarg2) {
80439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80440     return 0;
80441   }
80442   std::string arg2_str(jarg2);
80443   arg2 = &arg2_str;
80444   arg3 = (Dali::Property::Value *)jarg3;
80445   if (!arg3) {
80446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
80447     return 0;
80448   }
80449   {
80450     try {
80451       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
80452     } catch (std::out_of_range& e) {
80453       {
80454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80455       };
80456     } catch (std::exception& e) {
80457       {
80458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80459       };
80460     } catch (...) {
80461       {
80462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80463       };
80464     }
80465   }
80466   jresult = result;
80467
80468   //argout typemap for const std::string&
80469
80470   return jresult;
80471 }
80472
80473
80474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
80475   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80476   Dali::Toolkit::Control arg2 ;
80477   std::string *arg3 = 0 ;
80478   std::string *arg4 = 0 ;
80479   Dali::Toolkit::Control *argp2 ;
80480
80481   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80482   argp2 = (Dali::Toolkit::Control *)jarg2;
80483   if (!argp2) {
80484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
80485     return ;
80486   }
80487   arg2 = *argp2;
80488   if (!jarg3) {
80489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80490     return ;
80491   }
80492   std::string arg3_str(jarg3);
80493   arg3 = &arg3_str;
80494   if (!jarg4) {
80495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80496     return ;
80497   }
80498   std::string arg4_str(jarg4);
80499   arg4 = &arg4_str;
80500   {
80501     try {
80502       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
80503     } catch (std::out_of_range& e) {
80504       {
80505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80506       };
80507     } catch (std::exception& e) {
80508       {
80509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80510       };
80511     } catch (...) {
80512       {
80513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80514       };
80515     }
80516   }
80517
80518   //argout typemap for const std::string&
80519
80520
80521   //argout typemap for const std::string&
80522
80523 }
80524
80525
80526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
80527   void * jresult ;
80528   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80529   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
80530
80531   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80532   {
80533     try {
80534       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
80535     } catch (std::out_of_range& e) {
80536       {
80537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80538       };
80539     } catch (std::exception& e) {
80540       {
80541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80542       };
80543     } catch (...) {
80544       {
80545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80546       };
80547     }
80548   }
80549   jresult = (void *)result;
80550   return jresult;
80551 }
80552
80553
80554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
80555   int jresult ;
80556   int result;
80557
80558   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
80559   jresult = (int)result;
80560   return jresult;
80561 }
80562
80563
80564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
80565   int jresult ;
80566   int result;
80567
80568   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
80569   jresult = (int)result;
80570   return jresult;
80571 }
80572
80573
80574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
80575   int jresult ;
80576   int result;
80577
80578   result = (int)Dali::Toolkit::Slider::Property::VALUE;
80579   jresult = (int)result;
80580   return jresult;
80581 }
80582
80583
80584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
80585   int jresult ;
80586   int result;
80587
80588   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
80589   jresult = (int)result;
80590   return jresult;
80591 }
80592
80593
80594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
80595   int jresult ;
80596   int result;
80597
80598   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
80599   jresult = (int)result;
80600   return jresult;
80601 }
80602
80603
80604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
80605   int jresult ;
80606   int result;
80607
80608   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
80609   jresult = (int)result;
80610   return jresult;
80611 }
80612
80613
80614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
80615   int jresult ;
80616   int result;
80617
80618   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
80619   jresult = (int)result;
80620   return jresult;
80621 }
80622
80623
80624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
80625   int jresult ;
80626   int result;
80627
80628   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
80629   jresult = (int)result;
80630   return jresult;
80631 }
80632
80633
80634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
80635   int jresult ;
80636   int result;
80637
80638   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
80639   jresult = (int)result;
80640   return jresult;
80641 }
80642
80643
80644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
80645   int jresult ;
80646   int result;
80647
80648   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
80649   jresult = (int)result;
80650   return jresult;
80651 }
80652
80653
80654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
80655   int jresult ;
80656   int result;
80657
80658   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
80659   jresult = (int)result;
80660   return jresult;
80661 }
80662
80663
80664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
80665   int jresult ;
80666   int result;
80667
80668   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
80669   jresult = (int)result;
80670   return jresult;
80671 }
80672
80673
80674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
80675   int jresult ;
80676   int result;
80677
80678   result = (int)Dali::Toolkit::Slider::Property::MARKS;
80679   jresult = (int)result;
80680   return jresult;
80681 }
80682
80683
80684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
80685   int jresult ;
80686   int result;
80687
80688   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
80689   jresult = (int)result;
80690   return jresult;
80691 }
80692
80693
80694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
80695   int jresult ;
80696   int result;
80697
80698   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
80699   jresult = (int)result;
80700   return jresult;
80701 }
80702
80703
80704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
80705   void * jresult ;
80706   Dali::Toolkit::Slider::Property *result = 0 ;
80707
80708   {
80709     try {
80710       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
80711     } catch (std::out_of_range& e) {
80712       {
80713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80714       };
80715     } catch (std::exception& e) {
80716       {
80717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80718       };
80719     } catch (...) {
80720       {
80721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80722       };
80723     }
80724   }
80725   jresult = (void *)result;
80726   return jresult;
80727 }
80728
80729
80730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
80731   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
80732
80733   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
80734   {
80735     try {
80736       delete arg1;
80737     } catch (std::out_of_range& e) {
80738       {
80739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80740       };
80741     } catch (std::exception& e) {
80742       {
80743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80744       };
80745     } catch (...) {
80746       {
80747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80748       };
80749     }
80750   }
80751 }
80752
80753
80754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
80755   void * jresult ;
80756   Dali::Toolkit::Slider result;
80757
80758   {
80759     try {
80760       result = Dali::Toolkit::Slider::New();
80761     } catch (std::out_of_range& e) {
80762       {
80763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80764       };
80765     } catch (std::exception& e) {
80766       {
80767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80768       };
80769     } catch (...) {
80770       {
80771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80772       };
80773     }
80774   }
80775   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80776   return jresult;
80777 }
80778
80779
80780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
80781   void * jresult ;
80782   Dali::Toolkit::Slider *result = 0 ;
80783
80784   {
80785     try {
80786       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
80787     } catch (std::out_of_range& e) {
80788       {
80789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80790       };
80791     } catch (std::exception& e) {
80792       {
80793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80794       };
80795     } catch (...) {
80796       {
80797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80798       };
80799     }
80800   }
80801   jresult = (void *)result;
80802   return jresult;
80803 }
80804
80805
80806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
80807   void * jresult ;
80808   Dali::Toolkit::Slider *arg1 = 0 ;
80809   Dali::Toolkit::Slider *result = 0 ;
80810
80811   arg1 = (Dali::Toolkit::Slider *)jarg1;
80812   if (!arg1) {
80813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80814     return 0;
80815   }
80816   {
80817     try {
80818       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
80819     } catch (std::out_of_range& e) {
80820       {
80821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80822       };
80823     } catch (std::exception& e) {
80824       {
80825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80826       };
80827     } catch (...) {
80828       {
80829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80830       };
80831     }
80832   }
80833   jresult = (void *)result;
80834   return jresult;
80835 }
80836
80837
80838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
80839   void * jresult ;
80840   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80841   Dali::Toolkit::Slider *arg2 = 0 ;
80842   Dali::Toolkit::Slider *result = 0 ;
80843
80844   arg1 = (Dali::Toolkit::Slider *)jarg1;
80845   arg2 = (Dali::Toolkit::Slider *)jarg2;
80846   if (!arg2) {
80847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80848     return 0;
80849   }
80850   {
80851     try {
80852       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
80853     } catch (std::out_of_range& e) {
80854       {
80855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80856       };
80857     } catch (std::exception& e) {
80858       {
80859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80860       };
80861     } catch (...) {
80862       {
80863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80864       };
80865     }
80866   }
80867   jresult = (void *)result;
80868   return jresult;
80869 }
80870
80871
80872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
80873   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80874
80875   arg1 = (Dali::Toolkit::Slider *)jarg1;
80876   {
80877     try {
80878       delete arg1;
80879     } catch (std::out_of_range& e) {
80880       {
80881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80882       };
80883     } catch (std::exception& e) {
80884       {
80885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80886       };
80887     } catch (...) {
80888       {
80889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80890       };
80891     }
80892   }
80893 }
80894
80895
80896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
80897   void * jresult ;
80898   Dali::BaseHandle arg1 ;
80899   Dali::BaseHandle *argp1 ;
80900   Dali::Toolkit::Slider result;
80901
80902   argp1 = (Dali::BaseHandle *)jarg1;
80903   if (!argp1) {
80904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80905     return 0;
80906   }
80907   arg1 = *argp1;
80908   {
80909     try {
80910       result = Dali::Toolkit::Slider::DownCast(arg1);
80911     } catch (std::out_of_range& e) {
80912       {
80913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80914       };
80915     } catch (std::exception& e) {
80916       {
80917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80918       };
80919     } catch (...) {
80920       {
80921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80922       };
80923     }
80924   }
80925   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80926   return jresult;
80927 }
80928
80929
80930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
80931   void * jresult ;
80932   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80933   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
80934
80935   arg1 = (Dali::Toolkit::Slider *)jarg1;
80936   {
80937     try {
80938       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
80939     } catch (std::out_of_range& e) {
80940       {
80941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80942       };
80943     } catch (std::exception& e) {
80944       {
80945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80946       };
80947     } catch (...) {
80948       {
80949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80950       };
80951     }
80952   }
80953   jresult = (void *)result;
80954   return jresult;
80955 }
80956
80957
80958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
80959   void * jresult ;
80960   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80961   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
80962
80963   arg1 = (Dali::Toolkit::Slider *)jarg1;
80964   {
80965     try {
80966       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
80967     } catch (std::out_of_range& e) {
80968       {
80969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80970       };
80971     } catch (std::exception& e) {
80972       {
80973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80974       };
80975     } catch (...) {
80976       {
80977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80978       };
80979     }
80980   }
80981   jresult = (void *)result;
80982   return jresult;
80983 }
80984
80985
80986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
80987   void * jresult ;
80988   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80989   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
80990
80991   arg1 = (Dali::Toolkit::Slider *)jarg1;
80992   {
80993     try {
80994       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
80995     } catch (std::out_of_range& e) {
80996       {
80997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80998       };
80999     } catch (std::exception& e) {
81000       {
81001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81002       };
81003     } catch (...) {
81004       {
81005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81006       };
81007     }
81008   }
81009   jresult = (void *)result;
81010   return jresult;
81011 }
81012
81013
81014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81015   int jresult ;
81016   int result;
81017
81018   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81019   jresult = (int)result;
81020   return jresult;
81021 }
81022
81023
81024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81025   int jresult ;
81026   int result;
81027
81028   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81029   jresult = (int)result;
81030   return jresult;
81031 }
81032
81033
81034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81035   int jresult ;
81036   int result;
81037
81038   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81039   jresult = (int)result;
81040   return jresult;
81041 }
81042
81043
81044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81045   int jresult ;
81046   int result;
81047
81048   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81049   jresult = (int)result;
81050   return jresult;
81051 }
81052
81053
81054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81055   void * jresult ;
81056   Dali::Toolkit::VideoView::Property *result = 0 ;
81057
81058   {
81059     try {
81060       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81061     } catch (std::out_of_range& e) {
81062       {
81063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81064       };
81065     } catch (std::exception& e) {
81066       {
81067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81068       };
81069     } catch (...) {
81070       {
81071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81072       };
81073     }
81074   }
81075   jresult = (void *)result;
81076   return jresult;
81077 }
81078
81079
81080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81081   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81082
81083   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81084   {
81085     try {
81086       delete arg1;
81087     } catch (std::out_of_range& e) {
81088       {
81089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81090       };
81091     } catch (std::exception& e) {
81092       {
81093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81094       };
81095     } catch (...) {
81096       {
81097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81098       };
81099     }
81100   }
81101 }
81102
81103
81104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81105   void * jresult ;
81106   Dali::Toolkit::VideoView result;
81107
81108   {
81109     try {
81110       result = Dali::Toolkit::VideoView::New();
81111     } catch (std::out_of_range& e) {
81112       {
81113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81114       };
81115     } catch (std::exception& e) {
81116       {
81117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81118       };
81119     } catch (...) {
81120       {
81121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81122       };
81123     }
81124   }
81125   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81126   return jresult;
81127 }
81128
81129
81130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81131   void * jresult ;
81132   std::string *arg1 = 0 ;
81133   Dali::Toolkit::VideoView result;
81134
81135   if (!jarg1) {
81136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81137     return 0;
81138   }
81139   std::string arg1_str(jarg1);
81140   arg1 = &arg1_str;
81141   {
81142     try {
81143       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81144     } catch (std::out_of_range& e) {
81145       {
81146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81147       };
81148     } catch (std::exception& e) {
81149       {
81150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81151       };
81152     } catch (...) {
81153       {
81154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81155       };
81156     }
81157   }
81158   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81159
81160   //argout typemap for const std::string&
81161
81162   return jresult;
81163 }
81164
81165
81166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81167   void * jresult ;
81168   Dali::Toolkit::VideoView *result = 0 ;
81169
81170   {
81171     try {
81172       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81173     } catch (std::out_of_range& e) {
81174       {
81175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81176       };
81177     } catch (std::exception& e) {
81178       {
81179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81180       };
81181     } catch (...) {
81182       {
81183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81184       };
81185     }
81186   }
81187   jresult = (void *)result;
81188   return jresult;
81189 }
81190
81191
81192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81193   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81194
81195   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81196   {
81197     try {
81198       delete arg1;
81199     } catch (std::out_of_range& e) {
81200       {
81201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81202       };
81203     } catch (std::exception& e) {
81204       {
81205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81206       };
81207     } catch (...) {
81208       {
81209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81210       };
81211     }
81212   }
81213 }
81214
81215
81216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
81217   void * jresult ;
81218   Dali::Toolkit::VideoView *arg1 = 0 ;
81219   Dali::Toolkit::VideoView *result = 0 ;
81220
81221   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81222   if (!arg1) {
81223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81224     return 0;
81225   }
81226   {
81227     try {
81228       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
81229     } catch (std::out_of_range& e) {
81230       {
81231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81232       };
81233     } catch (std::exception& e) {
81234       {
81235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81236       };
81237     } catch (...) {
81238       {
81239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81240       };
81241     }
81242   }
81243   jresult = (void *)result;
81244   return jresult;
81245 }
81246
81247
81248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
81249   void * jresult ;
81250   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81251   Dali::Toolkit::VideoView *arg2 = 0 ;
81252   Dali::Toolkit::VideoView *result = 0 ;
81253
81254   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81255   arg2 = (Dali::Toolkit::VideoView *)jarg2;
81256   if (!arg2) {
81257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81258     return 0;
81259   }
81260   {
81261     try {
81262       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
81263     } catch (std::out_of_range& e) {
81264       {
81265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81266       };
81267     } catch (std::exception& e) {
81268       {
81269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81270       };
81271     } catch (...) {
81272       {
81273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81274       };
81275     }
81276   }
81277   jresult = (void *)result;
81278   return jresult;
81279 }
81280
81281
81282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
81283   void * jresult ;
81284   Dali::BaseHandle arg1 ;
81285   Dali::BaseHandle *argp1 ;
81286   Dali::Toolkit::VideoView result;
81287
81288   argp1 = (Dali::BaseHandle *)jarg1;
81289   if (!argp1) {
81290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81291     return 0;
81292   }
81293   arg1 = *argp1;
81294   {
81295     try {
81296       result = Dali::Toolkit::VideoView::DownCast(arg1);
81297     } catch (std::out_of_range& e) {
81298       {
81299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81300       };
81301     } catch (std::exception& e) {
81302       {
81303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81304       };
81305     } catch (...) {
81306       {
81307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81308       };
81309     }
81310   }
81311   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81312   return jresult;
81313 }
81314
81315
81316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
81317   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81318
81319   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81320   {
81321     try {
81322       (arg1)->Play();
81323     } catch (std::out_of_range& e) {
81324       {
81325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81326       };
81327     } catch (std::exception& e) {
81328       {
81329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81330       };
81331     } catch (...) {
81332       {
81333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81334       };
81335     }
81336   }
81337 }
81338
81339
81340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
81341   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81342
81343   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81344   {
81345     try {
81346       (arg1)->Pause();
81347     } catch (std::out_of_range& e) {
81348       {
81349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81350       };
81351     } catch (std::exception& e) {
81352       {
81353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81354       };
81355     } catch (...) {
81356       {
81357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81358       };
81359     }
81360   }
81361 }
81362
81363
81364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
81365   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81366
81367   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81368   {
81369     try {
81370       (arg1)->Stop();
81371     } catch (std::out_of_range& e) {
81372       {
81373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81374       };
81375     } catch (std::exception& e) {
81376       {
81377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81378       };
81379     } catch (...) {
81380       {
81381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81382       };
81383     }
81384   }
81385 }
81386
81387
81388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
81389   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81390   int arg2 ;
81391
81392   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81393   arg2 = (int)jarg2;
81394   {
81395     try {
81396       (arg1)->Forward(arg2);
81397     } catch (std::out_of_range& e) {
81398       {
81399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81400       };
81401     } catch (std::exception& e) {
81402       {
81403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81404       };
81405     } catch (...) {
81406       {
81407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81408       };
81409     }
81410   }
81411 }
81412
81413
81414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
81415   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81416   int arg2 ;
81417
81418   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81419   arg2 = (int)jarg2;
81420   {
81421     try {
81422       (arg1)->Backward(arg2);
81423     } catch (std::out_of_range& e) {
81424       {
81425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81426       };
81427     } catch (std::exception& e) {
81428       {
81429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81430       };
81431     } catch (...) {
81432       {
81433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81434       };
81435     }
81436   }
81437 }
81438
81439
81440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
81441   void * jresult ;
81442   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81443   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
81444
81445   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81446   {
81447     try {
81448       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
81449     } catch (std::out_of_range& e) {
81450       {
81451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81452       };
81453     } catch (std::exception& e) {
81454       {
81455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81456       };
81457     } catch (...) {
81458       {
81459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81460       };
81461     }
81462   }
81463   jresult = (void *)result;
81464   return jresult;
81465 }
81466
81467
81468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
81469   int jresult ;
81470   int result;
81471
81472   result = (int)Dali::Toolkit::Popup::Property::TITLE;
81473   jresult = (int)result;
81474   return jresult;
81475 }
81476
81477
81478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
81479   int jresult ;
81480   int result;
81481
81482   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
81483   jresult = (int)result;
81484   return jresult;
81485 }
81486
81487
81488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
81489   int jresult ;
81490   int result;
81491
81492   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
81493   jresult = (int)result;
81494   return jresult;
81495 }
81496
81497
81498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
81499   int jresult ;
81500   int result;
81501
81502   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
81503   jresult = (int)result;
81504   return jresult;
81505 }
81506
81507
81508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
81509   int jresult ;
81510   int result;
81511
81512   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
81513   jresult = (int)result;
81514   return jresult;
81515 }
81516
81517
81518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
81519   int jresult ;
81520   int result;
81521
81522   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
81523   jresult = (int)result;
81524   return jresult;
81525 }
81526
81527
81528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
81529   int jresult ;
81530   int result;
81531
81532   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
81533   jresult = (int)result;
81534   return jresult;
81535 }
81536
81537
81538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
81539   int jresult ;
81540   int result;
81541
81542   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
81543   jresult = (int)result;
81544   return jresult;
81545 }
81546
81547
81548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
81549   int jresult ;
81550   int result;
81551
81552   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
81553   jresult = (int)result;
81554   return jresult;
81555 }
81556
81557
81558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
81559   int jresult ;
81560   int result;
81561
81562   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
81563   jresult = (int)result;
81564   return jresult;
81565 }
81566
81567
81568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
81569   int jresult ;
81570   int result;
81571
81572   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
81573   jresult = (int)result;
81574   return jresult;
81575 }
81576
81577
81578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
81579   int jresult ;
81580   int result;
81581
81582   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
81583   jresult = (int)result;
81584   return jresult;
81585 }
81586
81587
81588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
81589   int jresult ;
81590   int result;
81591
81592   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
81593   jresult = (int)result;
81594   return jresult;
81595 }
81596
81597
81598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
81599   int jresult ;
81600   int result;
81601
81602   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
81603   jresult = (int)result;
81604   return jresult;
81605 }
81606
81607
81608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
81609   int jresult ;
81610   int result;
81611
81612   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
81613   jresult = (int)result;
81614   return jresult;
81615 }
81616
81617
81618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
81619   int jresult ;
81620   int result;
81621
81622   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
81623   jresult = (int)result;
81624   return jresult;
81625 }
81626
81627
81628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
81629   int jresult ;
81630   int result;
81631
81632   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
81633   jresult = (int)result;
81634   return jresult;
81635 }
81636
81637
81638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
81639   int jresult ;
81640   int result;
81641
81642   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
81643   jresult = (int)result;
81644   return jresult;
81645 }
81646
81647
81648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
81649   int jresult ;
81650   int result;
81651
81652   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
81653   jresult = (int)result;
81654   return jresult;
81655 }
81656
81657
81658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
81659   int jresult ;
81660   int result;
81661
81662   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
81663   jresult = (int)result;
81664   return jresult;
81665 }
81666
81667
81668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
81669   int jresult ;
81670   int result;
81671
81672   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
81673   jresult = (int)result;
81674   return jresult;
81675 }
81676
81677
81678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
81679   void * jresult ;
81680   Dali::Toolkit::Popup::Property *result = 0 ;
81681
81682   {
81683     try {
81684       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
81685     } catch (std::out_of_range& e) {
81686       {
81687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81688       };
81689     } catch (std::exception& e) {
81690       {
81691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81692       };
81693     } catch (...) {
81694       {
81695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81696       };
81697     }
81698   }
81699   jresult = (void *)result;
81700   return jresult;
81701 }
81702
81703
81704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
81705   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
81706
81707   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
81708   {
81709     try {
81710       delete arg1;
81711     } catch (std::out_of_range& e) {
81712       {
81713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81714       };
81715     } catch (std::exception& e) {
81716       {
81717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81718       };
81719     } catch (...) {
81720       {
81721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81722       };
81723     }
81724   }
81725 }
81726
81727
81728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
81729   void * jresult ;
81730   Dali::Toolkit::Popup *result = 0 ;
81731
81732   {
81733     try {
81734       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
81735     } catch (std::out_of_range& e) {
81736       {
81737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81738       };
81739     } catch (std::exception& e) {
81740       {
81741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81742       };
81743     } catch (...) {
81744       {
81745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81746       };
81747     }
81748   }
81749   jresult = (void *)result;
81750   return jresult;
81751 }
81752
81753
81754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
81755   void * jresult ;
81756   Dali::Toolkit::Popup result;
81757
81758   {
81759     try {
81760       result = Dali::Toolkit::Popup::New();
81761     } catch (std::out_of_range& e) {
81762       {
81763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81764       };
81765     } catch (std::exception& e) {
81766       {
81767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81768       };
81769     } catch (...) {
81770       {
81771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81772       };
81773     }
81774   }
81775   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81776   return jresult;
81777 }
81778
81779
81780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
81781   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81782
81783   arg1 = (Dali::Toolkit::Popup *)jarg1;
81784   {
81785     try {
81786       delete arg1;
81787     } catch (std::out_of_range& e) {
81788       {
81789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81790       };
81791     } catch (std::exception& e) {
81792       {
81793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81794       };
81795     } catch (...) {
81796       {
81797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81798       };
81799     }
81800   }
81801 }
81802
81803
81804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
81805   void * jresult ;
81806   Dali::Toolkit::Popup *arg1 = 0 ;
81807   Dali::Toolkit::Popup *result = 0 ;
81808
81809   arg1 = (Dali::Toolkit::Popup *)jarg1;
81810   if (!arg1) {
81811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81812     return 0;
81813   }
81814   {
81815     try {
81816       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
81817     } catch (std::out_of_range& e) {
81818       {
81819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81820       };
81821     } catch (std::exception& e) {
81822       {
81823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81824       };
81825     } catch (...) {
81826       {
81827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81828       };
81829     }
81830   }
81831   jresult = (void *)result;
81832   return jresult;
81833 }
81834
81835
81836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
81837   void * jresult ;
81838   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81839   Dali::Toolkit::Popup *arg2 = 0 ;
81840   Dali::Toolkit::Popup *result = 0 ;
81841
81842   arg1 = (Dali::Toolkit::Popup *)jarg1;
81843   arg2 = (Dali::Toolkit::Popup *)jarg2;
81844   if (!arg2) {
81845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81846     return 0;
81847   }
81848   {
81849     try {
81850       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
81851     } catch (std::out_of_range& e) {
81852       {
81853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81854       };
81855     } catch (std::exception& e) {
81856       {
81857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81858       };
81859     } catch (...) {
81860       {
81861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81862       };
81863     }
81864   }
81865   jresult = (void *)result;
81866   return jresult;
81867 }
81868
81869
81870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
81871   void * jresult ;
81872   Dali::BaseHandle arg1 ;
81873   Dali::BaseHandle *argp1 ;
81874   Dali::Toolkit::Popup result;
81875
81876   argp1 = (Dali::BaseHandle *)jarg1;
81877   if (!argp1) {
81878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81879     return 0;
81880   }
81881   arg1 = *argp1;
81882   {
81883     try {
81884       result = Dali::Toolkit::Popup::DownCast(arg1);
81885     } catch (std::out_of_range& e) {
81886       {
81887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81888       };
81889     } catch (std::exception& e) {
81890       {
81891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81892       };
81893     } catch (...) {
81894       {
81895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81896       };
81897     }
81898   }
81899   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81900   return jresult;
81901 }
81902
81903
81904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
81905   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81906   Dali::Actor arg2 ;
81907   Dali::Actor *argp2 ;
81908
81909   arg1 = (Dali::Toolkit::Popup *)jarg1;
81910   argp2 = (Dali::Actor *)jarg2;
81911   if (!argp2) {
81912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81913     return ;
81914   }
81915   arg2 = *argp2;
81916   {
81917     try {
81918       (arg1)->SetTitle(arg2);
81919     } catch (std::out_of_range& e) {
81920       {
81921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81922       };
81923     } catch (std::exception& e) {
81924       {
81925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81926       };
81927     } catch (...) {
81928       {
81929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81930       };
81931     }
81932   }
81933 }
81934
81935
81936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
81937   void * jresult ;
81938   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81939   Dali::Actor result;
81940
81941   arg1 = (Dali::Toolkit::Popup *)jarg1;
81942   {
81943     try {
81944       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
81945     } catch (std::out_of_range& e) {
81946       {
81947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81948       };
81949     } catch (std::exception& e) {
81950       {
81951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81952       };
81953     } catch (...) {
81954       {
81955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81956       };
81957     }
81958   }
81959   jresult = new Dali::Actor((const Dali::Actor &)result);
81960   return jresult;
81961 }
81962
81963
81964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
81965   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81966   Dali::Actor arg2 ;
81967   Dali::Actor *argp2 ;
81968
81969   arg1 = (Dali::Toolkit::Popup *)jarg1;
81970   argp2 = (Dali::Actor *)jarg2;
81971   if (!argp2) {
81972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81973     return ;
81974   }
81975   arg2 = *argp2;
81976   {
81977     try {
81978       (arg1)->SetContent(arg2);
81979     } catch (std::out_of_range& e) {
81980       {
81981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81982       };
81983     } catch (std::exception& e) {
81984       {
81985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81986       };
81987     } catch (...) {
81988       {
81989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81990       };
81991     }
81992   }
81993 }
81994
81995
81996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
81997   void * jresult ;
81998   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81999   Dali::Actor result;
82000
82001   arg1 = (Dali::Toolkit::Popup *)jarg1;
82002   {
82003     try {
82004       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82005     } catch (std::out_of_range& e) {
82006       {
82007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82008       };
82009     } catch (std::exception& e) {
82010       {
82011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82012       };
82013     } catch (...) {
82014       {
82015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82016       };
82017     }
82018   }
82019   jresult = new Dali::Actor((const Dali::Actor &)result);
82020   return jresult;
82021 }
82022
82023
82024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82025   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82026   Dali::Actor arg2 ;
82027   Dali::Actor *argp2 ;
82028
82029   arg1 = (Dali::Toolkit::Popup *)jarg1;
82030   argp2 = (Dali::Actor *)jarg2;
82031   if (!argp2) {
82032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82033     return ;
82034   }
82035   arg2 = *argp2;
82036   {
82037     try {
82038       (arg1)->SetFooter(arg2);
82039     } catch (std::out_of_range& e) {
82040       {
82041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82042       };
82043     } catch (std::exception& e) {
82044       {
82045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82046       };
82047     } catch (...) {
82048       {
82049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82050       };
82051     }
82052   }
82053 }
82054
82055
82056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
82057   void * jresult ;
82058   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82059   Dali::Actor result;
82060
82061   arg1 = (Dali::Toolkit::Popup *)jarg1;
82062   {
82063     try {
82064       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82065     } catch (std::out_of_range& e) {
82066       {
82067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82068       };
82069     } catch (std::exception& e) {
82070       {
82071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82072       };
82073     } catch (...) {
82074       {
82075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82076       };
82077     }
82078   }
82079   jresult = new Dali::Actor((const Dali::Actor &)result);
82080   return jresult;
82081 }
82082
82083
82084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
82085   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82086   Dali::Toolkit::Popup::DisplayState arg2 ;
82087
82088   arg1 = (Dali::Toolkit::Popup *)jarg1;
82089   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82090   {
82091     try {
82092       (arg1)->SetDisplayState(arg2);
82093     } catch (std::out_of_range& e) {
82094       {
82095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82096       };
82097     } catch (std::exception& e) {
82098       {
82099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82100       };
82101     } catch (...) {
82102       {
82103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82104       };
82105     }
82106   }
82107 }
82108
82109
82110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
82111   int jresult ;
82112   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82113   Dali::Toolkit::Popup::DisplayState result;
82114
82115   arg1 = (Dali::Toolkit::Popup *)jarg1;
82116   {
82117     try {
82118       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
82119     } catch (std::out_of_range& e) {
82120       {
82121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82122       };
82123     } catch (std::exception& e) {
82124       {
82125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82126       };
82127     } catch (...) {
82128       {
82129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82130       };
82131     }
82132   }
82133   jresult = (int)result;
82134   return jresult;
82135 }
82136
82137
82138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
82139   void * jresult ;
82140   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82141   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
82142
82143   arg1 = (Dali::Toolkit::Popup *)jarg1;
82144   {
82145     try {
82146       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
82147     } catch (std::out_of_range& e) {
82148       {
82149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82150       };
82151     } catch (std::exception& e) {
82152       {
82153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82154       };
82155     } catch (...) {
82156       {
82157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82158       };
82159     }
82160   }
82161   jresult = (void *)result;
82162   return jresult;
82163 }
82164
82165
82166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
82167   void * jresult ;
82168   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82169   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82170
82171   arg1 = (Dali::Toolkit::Popup *)jarg1;
82172   {
82173     try {
82174       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
82175     } catch (std::out_of_range& e) {
82176       {
82177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82178       };
82179     } catch (std::exception& e) {
82180       {
82181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82182       };
82183     } catch (...) {
82184       {
82185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82186       };
82187     }
82188   }
82189   jresult = (void *)result;
82190   return jresult;
82191 }
82192
82193
82194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
82195   void * jresult ;
82196   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82197   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82198
82199   arg1 = (Dali::Toolkit::Popup *)jarg1;
82200   {
82201     try {
82202       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
82203     } catch (std::out_of_range& e) {
82204       {
82205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82206       };
82207     } catch (std::exception& e) {
82208       {
82209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82210       };
82211     } catch (...) {
82212       {
82213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82214       };
82215     }
82216   }
82217   jresult = (void *)result;
82218   return jresult;
82219 }
82220
82221
82222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
82223   void * jresult ;
82224   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82225   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82226
82227   arg1 = (Dali::Toolkit::Popup *)jarg1;
82228   {
82229     try {
82230       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
82231     } catch (std::out_of_range& e) {
82232       {
82233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82234       };
82235     } catch (std::exception& e) {
82236       {
82237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82238       };
82239     } catch (...) {
82240       {
82241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82242       };
82243     }
82244   }
82245   jresult = (void *)result;
82246   return jresult;
82247 }
82248
82249
82250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
82251   void * jresult ;
82252   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82253   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82254
82255   arg1 = (Dali::Toolkit::Popup *)jarg1;
82256   {
82257     try {
82258       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
82259     } catch (std::out_of_range& e) {
82260       {
82261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82262       };
82263     } catch (std::exception& e) {
82264       {
82265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82266       };
82267     } catch (...) {
82268       {
82269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82270       };
82271     }
82272   }
82273   jresult = (void *)result;
82274   return jresult;
82275 }
82276
82277
82278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
82279   int jresult ;
82280   int result;
82281
82282   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
82283   jresult = (int)result;
82284   return jresult;
82285 }
82286
82287
82288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
82289   int jresult ;
82290   int result;
82291
82292   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
82293   jresult = (int)result;
82294   return jresult;
82295 }
82296
82297
82298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
82299   int jresult ;
82300   int result;
82301
82302   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
82303   jresult = (int)result;
82304   return jresult;
82305 }
82306
82307
82308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
82309   int jresult ;
82310   int result;
82311
82312   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
82313   jresult = (int)result;
82314   return jresult;
82315 }
82316
82317
82318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
82319   int jresult ;
82320   int result;
82321
82322   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
82323   jresult = (int)result;
82324   return jresult;
82325 }
82326
82327
82328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
82329   int jresult ;
82330   int result;
82331
82332   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
82333   jresult = (int)result;
82334   return jresult;
82335 }
82336
82337
82338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
82339   int jresult ;
82340   int result;
82341
82342   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
82343   jresult = (int)result;
82344   return jresult;
82345 }
82346
82347
82348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
82349   int jresult ;
82350   int result;
82351
82352   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
82353   jresult = (int)result;
82354   return jresult;
82355 }
82356
82357
82358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
82359   int jresult ;
82360   int result;
82361
82362   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
82363   jresult = (int)result;
82364   return jresult;
82365 }
82366
82367
82368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
82369   void * jresult ;
82370   Dali::Toolkit::ProgressBar::Property *result = 0 ;
82371
82372   {
82373     try {
82374       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
82375     } catch (std::out_of_range& e) {
82376       {
82377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82378       };
82379     } catch (std::exception& e) {
82380       {
82381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82382       };
82383     } catch (...) {
82384       {
82385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82386       };
82387     }
82388   }
82389   jresult = (void *)result;
82390   return jresult;
82391 }
82392
82393
82394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
82395   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
82396
82397   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
82398   {
82399     try {
82400       delete arg1;
82401     } catch (std::out_of_range& e) {
82402       {
82403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82404       };
82405     } catch (std::exception& e) {
82406       {
82407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82408       };
82409     } catch (...) {
82410       {
82411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82412       };
82413     }
82414   }
82415 }
82416
82417
82418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
82419   void * jresult ;
82420   Dali::Toolkit::ProgressBar result;
82421
82422   {
82423     try {
82424       result = Dali::Toolkit::ProgressBar::New();
82425     } catch (std::out_of_range& e) {
82426       {
82427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82428       };
82429     } catch (std::exception& e) {
82430       {
82431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82432       };
82433     } catch (...) {
82434       {
82435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82436       };
82437     }
82438   }
82439   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82440   return jresult;
82441 }
82442
82443
82444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
82445   void * jresult ;
82446   Dali::Toolkit::ProgressBar *result = 0 ;
82447
82448   {
82449     try {
82450       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
82451     } catch (std::out_of_range& e) {
82452       {
82453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82454       };
82455     } catch (std::exception& e) {
82456       {
82457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82458       };
82459     } catch (...) {
82460       {
82461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82462       };
82463     }
82464   }
82465   jresult = (void *)result;
82466   return jresult;
82467 }
82468
82469
82470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
82471   void * jresult ;
82472   Dali::Toolkit::ProgressBar *arg1 = 0 ;
82473   Dali::Toolkit::ProgressBar *result = 0 ;
82474
82475   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82476   if (!arg1) {
82477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82478     return 0;
82479   }
82480   {
82481     try {
82482       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
82483     } catch (std::out_of_range& e) {
82484       {
82485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82486       };
82487     } catch (std::exception& e) {
82488       {
82489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82490       };
82491     } catch (...) {
82492       {
82493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82494       };
82495     }
82496   }
82497   jresult = (void *)result;
82498   return jresult;
82499 }
82500
82501
82502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
82503   void * jresult ;
82504   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82505   Dali::Toolkit::ProgressBar *arg2 = 0 ;
82506   Dali::Toolkit::ProgressBar *result = 0 ;
82507
82508   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82509   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
82510   if (!arg2) {
82511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82512     return 0;
82513   }
82514   {
82515     try {
82516       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
82517     } catch (std::out_of_range& e) {
82518       {
82519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82520       };
82521     } catch (std::exception& e) {
82522       {
82523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82524       };
82525     } catch (...) {
82526       {
82527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82528       };
82529     }
82530   }
82531   jresult = (void *)result;
82532   return jresult;
82533 }
82534
82535
82536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
82537   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82538
82539   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82540   {
82541     try {
82542       delete arg1;
82543     } catch (std::out_of_range& e) {
82544       {
82545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82546       };
82547     } catch (std::exception& e) {
82548       {
82549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82550       };
82551     } catch (...) {
82552       {
82553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82554       };
82555     }
82556   }
82557 }
82558
82559
82560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
82561   void * jresult ;
82562   Dali::BaseHandle arg1 ;
82563   Dali::BaseHandle *argp1 ;
82564   Dali::Toolkit::ProgressBar result;
82565
82566   argp1 = (Dali::BaseHandle *)jarg1;
82567   if (!argp1) {
82568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82569     return 0;
82570   }
82571   arg1 = *argp1;
82572   {
82573     try {
82574       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
82575     } catch (std::out_of_range& e) {
82576       {
82577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82578       };
82579     } catch (std::exception& e) {
82580       {
82581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82582       };
82583     } catch (...) {
82584       {
82585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82586       };
82587     }
82588   }
82589   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82590   return jresult;
82591 }
82592
82593
82594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
82595   void * jresult ;
82596   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82597   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
82598
82599   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82600   {
82601     try {
82602       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82603     } catch (std::out_of_range& e) {
82604       {
82605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82606       };
82607     } catch (std::exception& e) {
82608       {
82609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82610       };
82611     } catch (...) {
82612       {
82613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82614       };
82615     }
82616   }
82617   jresult = (void *)result;
82618   return jresult;
82619 }
82620
82621
82622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
82623   void * jresult ;
82624   Dali::Toolkit::GaussianBlurView *result = 0 ;
82625
82626   {
82627     try {
82628       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
82629     } catch (std::out_of_range& e) {
82630       {
82631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82632       };
82633     } catch (std::exception& e) {
82634       {
82635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82636       };
82637     } catch (...) {
82638       {
82639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82640       };
82641     }
82642   }
82643   jresult = (void *)result;
82644   return jresult;
82645 }
82646
82647
82648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
82649   void * jresult ;
82650   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
82651   Dali::Toolkit::GaussianBlurView *result = 0 ;
82652
82653   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82654   if (!arg1) {
82655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82656     return 0;
82657   }
82658   {
82659     try {
82660       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
82661     } catch (std::out_of_range& e) {
82662       {
82663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82664       };
82665     } catch (std::exception& e) {
82666       {
82667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82668       };
82669     } catch (...) {
82670       {
82671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82672       };
82673     }
82674   }
82675   jresult = (void *)result;
82676   return jresult;
82677 }
82678
82679
82680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
82681   void * jresult ;
82682   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82683   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
82684   Dali::Toolkit::GaussianBlurView *result = 0 ;
82685
82686   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82687   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
82688   if (!arg2) {
82689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82690     return 0;
82691   }
82692   {
82693     try {
82694       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
82695     } catch (std::out_of_range& e) {
82696       {
82697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82698       };
82699     } catch (std::exception& e) {
82700       {
82701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82702       };
82703     } catch (...) {
82704       {
82705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82706       };
82707     }
82708   }
82709   jresult = (void *)result;
82710   return jresult;
82711 }
82712
82713
82714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
82715   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82716
82717   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82718   {
82719     try {
82720       delete arg1;
82721     } catch (std::out_of_range& e) {
82722       {
82723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82724       };
82725     } catch (std::exception& e) {
82726       {
82727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82728       };
82729     } catch (...) {
82730       {
82731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82732       };
82733     }
82734   }
82735 }
82736
82737
82738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
82739   void * jresult ;
82740   Dali::BaseHandle arg1 ;
82741   Dali::BaseHandle *argp1 ;
82742   Dali::Toolkit::GaussianBlurView result;
82743
82744   argp1 = (Dali::BaseHandle *)jarg1;
82745   if (!argp1) {
82746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82747     return 0;
82748   }
82749   arg1 = *argp1;
82750   {
82751     try {
82752       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
82753     } catch (std::out_of_range& e) {
82754       {
82755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82756       };
82757     } catch (std::exception& e) {
82758       {
82759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82760       };
82761     } catch (...) {
82762       {
82763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82764       };
82765     }
82766   }
82767   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82768   return jresult;
82769 }
82770
82771
82772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
82773   void * jresult ;
82774   Dali::Toolkit::GaussianBlurView result;
82775
82776   {
82777     try {
82778       result = Dali::Toolkit::GaussianBlurView::New();
82779     } catch (std::out_of_range& e) {
82780       {
82781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82782       };
82783     } catch (std::exception& e) {
82784       {
82785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82786       };
82787     } catch (...) {
82788       {
82789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82790       };
82791     }
82792   }
82793   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82794   return jresult;
82795 }
82796
82797
82798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
82799   void * jresult ;
82800   unsigned int arg1 ;
82801   float arg2 ;
82802   Dali::Pixel::Format arg3 ;
82803   float arg4 ;
82804   float arg5 ;
82805   bool arg6 ;
82806   Dali::Toolkit::GaussianBlurView result;
82807
82808   arg1 = (unsigned int)jarg1;
82809   arg2 = (float)jarg2;
82810   arg3 = (Dali::Pixel::Format)jarg3;
82811   arg4 = (float)jarg4;
82812   arg5 = (float)jarg5;
82813   arg6 = jarg6 ? true : false;
82814   {
82815     try {
82816       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
82817     } catch (std::out_of_range& e) {
82818       {
82819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82820       };
82821     } catch (std::exception& e) {
82822       {
82823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82824       };
82825     } catch (...) {
82826       {
82827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82828       };
82829     }
82830   }
82831   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82832   return jresult;
82833 }
82834
82835
82836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
82837   void * jresult ;
82838   unsigned int arg1 ;
82839   float arg2 ;
82840   Dali::Pixel::Format arg3 ;
82841   float arg4 ;
82842   float arg5 ;
82843   Dali::Toolkit::GaussianBlurView result;
82844
82845   arg1 = (unsigned int)jarg1;
82846   arg2 = (float)jarg2;
82847   arg3 = (Dali::Pixel::Format)jarg3;
82848   arg4 = (float)jarg4;
82849   arg5 = (float)jarg5;
82850   {
82851     try {
82852       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
82853     } catch (std::out_of_range& e) {
82854       {
82855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82856       };
82857     } catch (std::exception& e) {
82858       {
82859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82860       };
82861     } catch (...) {
82862       {
82863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82864       };
82865     }
82866   }
82867   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82868   return jresult;
82869 }
82870
82871
82872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
82873   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82874   Dali::Actor arg2 ;
82875   Dali::Actor *argp2 ;
82876
82877   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82878   argp2 = (Dali::Actor *)jarg2;
82879   if (!argp2) {
82880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82881     return ;
82882   }
82883   arg2 = *argp2;
82884   {
82885     try {
82886       (arg1)->Add(arg2);
82887     } catch (std::out_of_range& e) {
82888       {
82889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82890       };
82891     } catch (std::exception& e) {
82892       {
82893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82894       };
82895     } catch (...) {
82896       {
82897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82898       };
82899     }
82900   }
82901 }
82902
82903
82904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
82905   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82906   Dali::Actor arg2 ;
82907   Dali::Actor *argp2 ;
82908
82909   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82910   argp2 = (Dali::Actor *)jarg2;
82911   if (!argp2) {
82912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82913     return ;
82914   }
82915   arg2 = *argp2;
82916   {
82917     try {
82918       (arg1)->Remove(arg2);
82919     } catch (std::out_of_range& e) {
82920       {
82921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82922       };
82923     } catch (std::exception& e) {
82924       {
82925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82926       };
82927     } catch (...) {
82928       {
82929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82930       };
82931     }
82932   }
82933 }
82934
82935
82936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
82937   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82938
82939   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82940   {
82941     try {
82942       (arg1)->Activate();
82943     } catch (std::out_of_range& e) {
82944       {
82945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82946       };
82947     } catch (std::exception& e) {
82948       {
82949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82950       };
82951     } catch (...) {
82952       {
82953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82954       };
82955     }
82956   }
82957 }
82958
82959
82960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
82961   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82962
82963   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82964   {
82965     try {
82966       (arg1)->ActivateOnce();
82967     } catch (std::out_of_range& e) {
82968       {
82969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82970       };
82971     } catch (std::exception& e) {
82972       {
82973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82974       };
82975     } catch (...) {
82976       {
82977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82978       };
82979     }
82980   }
82981 }
82982
82983
82984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
82985   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82986
82987   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82988   {
82989     try {
82990       (arg1)->Deactivate();
82991     } catch (std::out_of_range& e) {
82992       {
82993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82994       };
82995     } catch (std::exception& e) {
82996       {
82997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82998       };
82999     } catch (...) {
83000       {
83001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83002       };
83003     }
83004   }
83005 }
83006
83007
83008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
83009   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83010   Dali::Image arg2 ;
83011   Dali::FrameBufferImage arg3 ;
83012   Dali::Image *argp2 ;
83013   Dali::FrameBufferImage *argp3 ;
83014
83015   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83016   argp2 = (Dali::Image *)jarg2;
83017   if (!argp2) {
83018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
83019     return ;
83020   }
83021   arg2 = *argp2;
83022   argp3 = (Dali::FrameBufferImage *)jarg3;
83023   if (!argp3) {
83024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
83025     return ;
83026   }
83027   arg3 = *argp3;
83028   {
83029     try {
83030       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
83031     } catch (std::out_of_range& e) {
83032       {
83033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83034       };
83035     } catch (std::exception& e) {
83036       {
83037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83038       };
83039     } catch (...) {
83040       {
83041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83042       };
83043     }
83044   }
83045 }
83046
83047
83048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
83049   int jresult ;
83050   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83051   Dali::Property::Index result;
83052
83053   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83054   {
83055     try {
83056       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
83057     } catch (std::out_of_range& e) {
83058       {
83059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83060       };
83061     } catch (std::exception& e) {
83062       {
83063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83064       };
83065     } catch (...) {
83066       {
83067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83068       };
83069     }
83070   }
83071   jresult = result;
83072   return jresult;
83073 }
83074
83075
83076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
83077   void * jresult ;
83078   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83079   Dali::FrameBufferImage result;
83080
83081   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83082   {
83083     try {
83084       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
83085     } catch (std::out_of_range& e) {
83086       {
83087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83088       };
83089     } catch (std::exception& e) {
83090       {
83091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83092       };
83093     } catch (...) {
83094       {
83095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83096       };
83097     }
83098   }
83099   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
83100   return jresult;
83101 }
83102
83103
83104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
83105   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83106   Dali::Vector4 *arg2 = 0 ;
83107
83108   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83109   arg2 = (Dali::Vector4 *)jarg2;
83110   if (!arg2) {
83111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
83112     return ;
83113   }
83114   {
83115     try {
83116       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
83117     } catch (std::out_of_range& e) {
83118       {
83119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83120       };
83121     } catch (std::exception& e) {
83122       {
83123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83124       };
83125     } catch (...) {
83126       {
83127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83128       };
83129     }
83130   }
83131 }
83132
83133
83134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
83135   void * jresult ;
83136   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83137   Dali::Vector4 result;
83138
83139   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83140   {
83141     try {
83142       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
83143     } catch (std::out_of_range& e) {
83144       {
83145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83146       };
83147     } catch (std::exception& e) {
83148       {
83149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83150       };
83151     } catch (...) {
83152       {
83153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83154       };
83155     }
83156   }
83157   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
83158   return jresult;
83159 }
83160
83161
83162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
83163   void * jresult ;
83164   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83165   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
83166
83167   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83168   {
83169     try {
83170       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
83171     } catch (std::out_of_range& e) {
83172       {
83173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83174       };
83175     } catch (std::exception& e) {
83176       {
83177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83178       };
83179     } catch (...) {
83180       {
83181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83182       };
83183     }
83184   }
83185   jresult = (void *)result;
83186   return jresult;
83187 }
83188
83189
83190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
83191   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83192
83193   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83194   {
83195     try {
83196       delete arg1;
83197     } catch (std::out_of_range& e) {
83198       {
83199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83200       };
83201     } catch (std::exception& e) {
83202       {
83203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83204       };
83205     } catch (...) {
83206       {
83207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83208       };
83209     }
83210   }
83211 }
83212
83213
83214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
83215   unsigned int jresult ;
83216   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83217   unsigned int result;
83218
83219   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83220   {
83221     try {
83222       result = (unsigned int)(arg1)->GetNumberOfPages();
83223     } catch (std::out_of_range& e) {
83224       {
83225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83226       };
83227     } catch (std::exception& e) {
83228       {
83229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83230       };
83231     } catch (...) {
83232       {
83233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83234       };
83235     }
83236   }
83237   jresult = result;
83238   return jresult;
83239 }
83240
83241
83242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
83243   void * jresult ;
83244   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83245   unsigned int arg2 ;
83246   Dali::Texture result;
83247
83248   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83249   arg2 = (unsigned int)jarg2;
83250   {
83251     try {
83252       result = (arg1)->NewPage(arg2);
83253     } catch (std::out_of_range& e) {
83254       {
83255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83256       };
83257     } catch (std::exception& e) {
83258       {
83259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83260       };
83261     } catch (...) {
83262       {
83263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83264       };
83265     }
83266   }
83267   jresult = new Dali::Texture((const Dali::Texture &)result);
83268   return jresult;
83269 }
83270
83271
83272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
83273   int jresult ;
83274   int result;
83275
83276   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
83277   jresult = (int)result;
83278   return jresult;
83279 }
83280
83281
83282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
83283   int jresult ;
83284   int result;
83285
83286   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
83287   jresult = (int)result;
83288   return jresult;
83289 }
83290
83291
83292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
83293   int jresult ;
83294   int result;
83295
83296   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
83297   jresult = (int)result;
83298   return jresult;
83299 }
83300
83301
83302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
83303   void * jresult ;
83304   Dali::Toolkit::PageTurnView::Property *result = 0 ;
83305
83306   {
83307     try {
83308       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
83309     } catch (std::out_of_range& e) {
83310       {
83311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83312       };
83313     } catch (std::exception& e) {
83314       {
83315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83316       };
83317     } catch (...) {
83318       {
83319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83320       };
83321     }
83322   }
83323   jresult = (void *)result;
83324   return jresult;
83325 }
83326
83327
83328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
83329   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
83330
83331   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
83332   {
83333     try {
83334       delete arg1;
83335     } catch (std::out_of_range& e) {
83336       {
83337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83338       };
83339     } catch (std::exception& e) {
83340       {
83341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83342       };
83343     } catch (...) {
83344       {
83345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83346       };
83347     }
83348   }
83349 }
83350
83351
83352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
83353   void * jresult ;
83354   Dali::Toolkit::PageTurnView *result = 0 ;
83355
83356   {
83357     try {
83358       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
83359     } catch (std::out_of_range& e) {
83360       {
83361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83362       };
83363     } catch (std::exception& e) {
83364       {
83365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83366       };
83367     } catch (...) {
83368       {
83369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83370       };
83371     }
83372   }
83373   jresult = (void *)result;
83374   return jresult;
83375 }
83376
83377
83378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
83379   void * jresult ;
83380   Dali::Toolkit::PageTurnView *arg1 = 0 ;
83381   Dali::Toolkit::PageTurnView *result = 0 ;
83382
83383   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83384   if (!arg1) {
83385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83386     return 0;
83387   }
83388   {
83389     try {
83390       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
83391     } catch (std::out_of_range& e) {
83392       {
83393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83394       };
83395     } catch (std::exception& e) {
83396       {
83397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83398       };
83399     } catch (...) {
83400       {
83401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83402       };
83403     }
83404   }
83405   jresult = (void *)result;
83406   return jresult;
83407 }
83408
83409
83410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
83411   void * jresult ;
83412   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83413   Dali::Toolkit::PageTurnView *arg2 = 0 ;
83414   Dali::Toolkit::PageTurnView *result = 0 ;
83415
83416   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83417   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
83418   if (!arg2) {
83419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83420     return 0;
83421   }
83422   {
83423     try {
83424       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
83425     } catch (std::out_of_range& e) {
83426       {
83427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83428       };
83429     } catch (std::exception& e) {
83430       {
83431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83432       };
83433     } catch (...) {
83434       {
83435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83436       };
83437     }
83438   }
83439   jresult = (void *)result;
83440   return jresult;
83441 }
83442
83443
83444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
83445   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83446
83447   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83448   {
83449     try {
83450       delete arg1;
83451     } catch (std::out_of_range& e) {
83452       {
83453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83454       };
83455     } catch (std::exception& e) {
83456       {
83457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83458       };
83459     } catch (...) {
83460       {
83461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83462       };
83463     }
83464   }
83465 }
83466
83467
83468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
83469   void * jresult ;
83470   Dali::BaseHandle arg1 ;
83471   Dali::BaseHandle *argp1 ;
83472   Dali::Toolkit::PageTurnView result;
83473
83474   argp1 = (Dali::BaseHandle *)jarg1;
83475   if (!argp1) {
83476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83477     return 0;
83478   }
83479   arg1 = *argp1;
83480   {
83481     try {
83482       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
83483     } catch (std::out_of_range& e) {
83484       {
83485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83486       };
83487     } catch (std::exception& e) {
83488       {
83489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83490       };
83491     } catch (...) {
83492       {
83493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83494       };
83495     }
83496   }
83497   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
83498   return jresult;
83499 }
83500
83501
83502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
83503   void * jresult ;
83504   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83505   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83506
83507   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83508   {
83509     try {
83510       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
83511     } catch (std::out_of_range& e) {
83512       {
83513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83514       };
83515     } catch (std::exception& e) {
83516       {
83517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83518       };
83519     } catch (...) {
83520       {
83521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83522       };
83523     }
83524   }
83525   jresult = (void *)result;
83526   return jresult;
83527 }
83528
83529
83530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
83531   void * jresult ;
83532   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83533   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83534
83535   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83536   {
83537     try {
83538       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
83539     } catch (std::out_of_range& e) {
83540       {
83541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83542       };
83543     } catch (std::exception& e) {
83544       {
83545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83546       };
83547     } catch (...) {
83548       {
83549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83550       };
83551     }
83552   }
83553   jresult = (void *)result;
83554   return jresult;
83555 }
83556
83557
83558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
83559   void * jresult ;
83560   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83561   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83562
83563   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83564   {
83565     try {
83566       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
83567     } catch (std::out_of_range& e) {
83568       {
83569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83570       };
83571     } catch (std::exception& e) {
83572       {
83573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83574       };
83575     } catch (...) {
83576       {
83577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83578       };
83579     }
83580   }
83581   jresult = (void *)result;
83582   return jresult;
83583 }
83584
83585
83586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
83587   void * jresult ;
83588   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83589   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83590
83591   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83592   {
83593     try {
83594       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
83595     } catch (std::out_of_range& e) {
83596       {
83597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83598       };
83599     } catch (std::exception& e) {
83600       {
83601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83602       };
83603     } catch (...) {
83604       {
83605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83606       };
83607     }
83608   }
83609   jresult = (void *)result;
83610   return jresult;
83611 }
83612
83613
83614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
83615   void * jresult ;
83616   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83617
83618   {
83619     try {
83620       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
83621     } catch (std::out_of_range& e) {
83622       {
83623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83624       };
83625     } catch (std::exception& e) {
83626       {
83627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83628       };
83629     } catch (...) {
83630       {
83631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83632       };
83633     }
83634   }
83635   jresult = (void *)result;
83636   return jresult;
83637 }
83638
83639
83640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
83641   void * jresult ;
83642   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
83643   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83644
83645   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83646   if (!arg1) {
83647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83648     return 0;
83649   }
83650   {
83651     try {
83652       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
83653     } catch (std::out_of_range& e) {
83654       {
83655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83656       };
83657     } catch (std::exception& e) {
83658       {
83659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83660       };
83661     } catch (...) {
83662       {
83663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83664       };
83665     }
83666   }
83667   jresult = (void *)result;
83668   return jresult;
83669 }
83670
83671
83672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
83673   void * jresult ;
83674   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83675   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
83676   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83677
83678   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83679   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
83680   if (!arg2) {
83681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83682     return 0;
83683   }
83684   {
83685     try {
83686       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
83687     } catch (std::out_of_range& e) {
83688       {
83689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83690       };
83691     } catch (std::exception& e) {
83692       {
83693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83694       };
83695     } catch (...) {
83696       {
83697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83698       };
83699     }
83700   }
83701   jresult = (void *)result;
83702   return jresult;
83703 }
83704
83705
83706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
83707   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83708
83709   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83710   {
83711     try {
83712       delete arg1;
83713     } catch (std::out_of_range& e) {
83714       {
83715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83716       };
83717     } catch (std::exception& e) {
83718       {
83719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83720       };
83721     } catch (...) {
83722       {
83723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83724       };
83725     }
83726   }
83727 }
83728
83729
83730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
83731   void * jresult ;
83732   Dali::Toolkit::PageFactory *arg1 = 0 ;
83733   Dali::Vector2 *arg2 = 0 ;
83734   Dali::Toolkit::PageTurnLandscapeView result;
83735
83736   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83737   if (!arg1) {
83738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83739     return 0;
83740   }
83741   arg2 = (Dali::Vector2 *)jarg2;
83742   if (!arg2) {
83743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83744     return 0;
83745   }
83746   {
83747     try {
83748       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
83749     } catch (std::out_of_range& e) {
83750       {
83751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83752       };
83753     } catch (std::exception& e) {
83754       {
83755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83756       };
83757     } catch (...) {
83758       {
83759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83760       };
83761     }
83762   }
83763   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83764   return jresult;
83765 }
83766
83767
83768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
83769   void * jresult ;
83770   Dali::BaseHandle arg1 ;
83771   Dali::BaseHandle *argp1 ;
83772   Dali::Toolkit::PageTurnLandscapeView result;
83773
83774   argp1 = (Dali::BaseHandle *)jarg1;
83775   if (!argp1) {
83776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83777     return 0;
83778   }
83779   arg1 = *argp1;
83780   {
83781     try {
83782       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
83783     } catch (std::out_of_range& e) {
83784       {
83785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83786       };
83787     } catch (std::exception& e) {
83788       {
83789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83790       };
83791     } catch (...) {
83792       {
83793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83794       };
83795     }
83796   }
83797   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83798   return jresult;
83799 }
83800
83801
83802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
83803   void * jresult ;
83804   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83805
83806   {
83807     try {
83808       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
83809     } catch (std::out_of_range& e) {
83810       {
83811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83812       };
83813     } catch (std::exception& e) {
83814       {
83815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83816       };
83817     } catch (...) {
83818       {
83819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83820       };
83821     }
83822   }
83823   jresult = (void *)result;
83824   return jresult;
83825 }
83826
83827
83828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
83829   void * jresult ;
83830   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
83831   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83832
83833   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83834   if (!arg1) {
83835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83836     return 0;
83837   }
83838   {
83839     try {
83840       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
83841     } catch (std::out_of_range& e) {
83842       {
83843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83844       };
83845     } catch (std::exception& e) {
83846       {
83847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83848       };
83849     } catch (...) {
83850       {
83851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83852       };
83853     }
83854   }
83855   jresult = (void *)result;
83856   return jresult;
83857 }
83858
83859
83860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
83861   void * jresult ;
83862   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83863   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
83864   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83865
83866   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83867   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
83868   if (!arg2) {
83869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83870     return 0;
83871   }
83872   {
83873     try {
83874       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
83875     } catch (std::out_of_range& e) {
83876       {
83877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83878       };
83879     } catch (std::exception& e) {
83880       {
83881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83882       };
83883     } catch (...) {
83884       {
83885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83886       };
83887     }
83888   }
83889   jresult = (void *)result;
83890   return jresult;
83891 }
83892
83893
83894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
83895   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83896
83897   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83898   {
83899     try {
83900       delete arg1;
83901     } catch (std::out_of_range& e) {
83902       {
83903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83904       };
83905     } catch (std::exception& e) {
83906       {
83907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83908       };
83909     } catch (...) {
83910       {
83911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83912       };
83913     }
83914   }
83915 }
83916
83917
83918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
83919   void * jresult ;
83920   Dali::Toolkit::PageFactory *arg1 = 0 ;
83921   Dali::Vector2 *arg2 = 0 ;
83922   Dali::Toolkit::PageTurnPortraitView result;
83923
83924   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83925   if (!arg1) {
83926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83927     return 0;
83928   }
83929   arg2 = (Dali::Vector2 *)jarg2;
83930   if (!arg2) {
83931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83932     return 0;
83933   }
83934   {
83935     try {
83936       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
83937     } catch (std::out_of_range& e) {
83938       {
83939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83940       };
83941     } catch (std::exception& e) {
83942       {
83943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83944       };
83945     } catch (...) {
83946       {
83947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83948       };
83949     }
83950   }
83951   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
83952   return jresult;
83953 }
83954
83955
83956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
83957   void * jresult ;
83958   Dali::BaseHandle arg1 ;
83959   Dali::BaseHandle *argp1 ;
83960   Dali::Toolkit::PageTurnPortraitView result;
83961
83962   argp1 = (Dali::BaseHandle *)jarg1;
83963   if (!argp1) {
83964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83965     return 0;
83966   }
83967   arg1 = *argp1;
83968   {
83969     try {
83970       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
83971     } catch (std::out_of_range& e) {
83972       {
83973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83974       };
83975     } catch (std::exception& e) {
83976       {
83977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83978       };
83979     } catch (...) {
83980       {
83981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83982       };
83983     }
83984   }
83985   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
83986   return jresult;
83987 }
83988
83989
83990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
83991   int jresult ;
83992   int result;
83993
83994   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
83995   jresult = (int)result;
83996   return jresult;
83997 }
83998
83999
84000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
84001   int jresult ;
84002   int result;
84003
84004   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
84005   jresult = (int)result;
84006   return jresult;
84007 }
84008
84009
84010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
84011   int jresult ;
84012   int result;
84013
84014   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
84015   jresult = (int)result;
84016   return jresult;
84017 }
84018
84019
84020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
84021   void * jresult ;
84022   Dali::Toolkit::ToggleButton::Property *result = 0 ;
84023
84024   {
84025     try {
84026       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
84027     } catch (std::out_of_range& e) {
84028       {
84029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84030       };
84031     } catch (std::exception& e) {
84032       {
84033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84034       };
84035     } catch (...) {
84036       {
84037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84038       };
84039     }
84040   }
84041   jresult = (void *)result;
84042   return jresult;
84043 }
84044
84045
84046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
84047   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
84048
84049   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
84050   {
84051     try {
84052       delete arg1;
84053     } catch (std::out_of_range& e) {
84054       {
84055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84056       };
84057     } catch (std::exception& e) {
84058       {
84059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84060       };
84061     } catch (...) {
84062       {
84063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84064       };
84065     }
84066   }
84067 }
84068
84069
84070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
84071   void * jresult ;
84072   Dali::Toolkit::ToggleButton *result = 0 ;
84073
84074   {
84075     try {
84076       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
84077     } catch (std::out_of_range& e) {
84078       {
84079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84080       };
84081     } catch (std::exception& e) {
84082       {
84083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84084       };
84085     } catch (...) {
84086       {
84087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84088       };
84089     }
84090   }
84091   jresult = (void *)result;
84092   return jresult;
84093 }
84094
84095
84096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
84097   void * jresult ;
84098   Dali::Toolkit::ToggleButton *arg1 = 0 ;
84099   Dali::Toolkit::ToggleButton *result = 0 ;
84100
84101   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84102   if (!arg1) {
84103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84104     return 0;
84105   }
84106   {
84107     try {
84108       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
84109     } catch (std::out_of_range& e) {
84110       {
84111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84112       };
84113     } catch (std::exception& e) {
84114       {
84115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84116       };
84117     } catch (...) {
84118       {
84119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84120       };
84121     }
84122   }
84123   jresult = (void *)result;
84124   return jresult;
84125 }
84126
84127
84128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
84129   void * jresult ;
84130   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84131   Dali::Toolkit::ToggleButton *arg2 = 0 ;
84132   Dali::Toolkit::ToggleButton *result = 0 ;
84133
84134   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84135   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
84136   if (!arg2) {
84137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84138     return 0;
84139   }
84140   {
84141     try {
84142       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
84143     } catch (std::out_of_range& e) {
84144       {
84145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84146       };
84147     } catch (std::exception& e) {
84148       {
84149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84150       };
84151     } catch (...) {
84152       {
84153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84154       };
84155     }
84156   }
84157   jresult = (void *)result;
84158   return jresult;
84159 }
84160
84161
84162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
84163   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84164
84165   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84166   {
84167     try {
84168       delete arg1;
84169     } catch (std::out_of_range& e) {
84170       {
84171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84172       };
84173     } catch (std::exception& e) {
84174       {
84175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84176       };
84177     } catch (...) {
84178       {
84179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84180       };
84181     }
84182   }
84183 }
84184
84185
84186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
84187   void * jresult ;
84188   Dali::Toolkit::ToggleButton result;
84189
84190   {
84191     try {
84192       result = Dali::Toolkit::ToggleButton::New();
84193     } catch (std::out_of_range& e) {
84194       {
84195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84196       };
84197     } catch (std::exception& e) {
84198       {
84199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84200       };
84201     } catch (...) {
84202       {
84203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84204       };
84205     }
84206   }
84207   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84208   return jresult;
84209 }
84210
84211
84212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
84213   void * jresult ;
84214   Dali::BaseHandle arg1 ;
84215   Dali::BaseHandle *argp1 ;
84216   Dali::Toolkit::ToggleButton result;
84217
84218   argp1 = (Dali::BaseHandle *)jarg1;
84219   if (!argp1) {
84220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84221     return 0;
84222   }
84223   arg1 = *argp1;
84224   {
84225     try {
84226       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
84227     } catch (std::out_of_range& e) {
84228       {
84229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84230       };
84231     } catch (std::exception& e) {
84232       {
84233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84234       };
84235     } catch (...) {
84236       {
84237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84238       };
84239     }
84240   }
84241   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84242   return jresult;
84243 }
84244
84245
84246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
84247   void * jresult ;
84248   Dali::Toolkit::Visual::Base *result = 0 ;
84249
84250   {
84251     try {
84252       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
84253     } catch (std::out_of_range& e) {
84254       {
84255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84256       };
84257     } catch (std::exception& e) {
84258       {
84259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84260       };
84261     } catch (...) {
84262       {
84263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84264       };
84265     }
84266   }
84267   jresult = (void *)result;
84268   return jresult;
84269 }
84270
84271
84272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
84273   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84274
84275   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84276   {
84277     try {
84278       delete arg1;
84279     } catch (std::out_of_range& e) {
84280       {
84281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84282       };
84283     } catch (std::exception& e) {
84284       {
84285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84286       };
84287     } catch (...) {
84288       {
84289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84290       };
84291     }
84292   }
84293 }
84294
84295
84296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
84297   void * jresult ;
84298   Dali::Toolkit::Visual::Base *arg1 = 0 ;
84299   Dali::Toolkit::Visual::Base *result = 0 ;
84300
84301   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84302   if (!arg1) {
84303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84304     return 0;
84305   }
84306   {
84307     try {
84308       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
84309     } catch (std::out_of_range& e) {
84310       {
84311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84312       };
84313     } catch (std::exception& e) {
84314       {
84315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84316       };
84317     } catch (...) {
84318       {
84319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84320       };
84321     }
84322   }
84323   jresult = (void *)result;
84324   return jresult;
84325 }
84326
84327
84328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
84329   void * jresult ;
84330   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84331   Dali::Toolkit::Visual::Base *arg2 = 0 ;
84332   Dali::Toolkit::Visual::Base *result = 0 ;
84333
84334   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84335   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
84336   if (!arg2) {
84337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84338     return 0;
84339   }
84340   {
84341     try {
84342       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
84343     } catch (std::out_of_range& e) {
84344       {
84345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84346       };
84347     } catch (std::exception& e) {
84348       {
84349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84350       };
84351     } catch (...) {
84352       {
84353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84354       };
84355     }
84356   }
84357   jresult = (void *)result;
84358   return jresult;
84359 }
84360
84361
84362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
84363   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84364   std::string *arg2 = 0 ;
84365
84366   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84367   if (!jarg2) {
84368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84369     return ;
84370   }
84371   std::string arg2_str(jarg2);
84372   arg2 = &arg2_str;
84373   {
84374     try {
84375       (arg1)->SetName((std::string const &)*arg2);
84376     } catch (std::out_of_range& e) {
84377       {
84378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84379       };
84380     } catch (std::exception& e) {
84381       {
84382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84383       };
84384     } catch (...) {
84385       {
84386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84387       };
84388     }
84389   }
84390
84391   //argout typemap for const std::string&
84392
84393 }
84394
84395
84396 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
84397   char * jresult ;
84398   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84399   std::string *result = 0 ;
84400
84401   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84402   {
84403     try {
84404       result = (std::string *) &(arg1)->GetName();
84405     } catch (std::out_of_range& e) {
84406       {
84407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84408       };
84409     } catch (std::exception& e) {
84410       {
84411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84412       };
84413     } catch (...) {
84414       {
84415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84416       };
84417     }
84418   }
84419   jresult = SWIG_csharp_string_callback(result->c_str());
84420   return jresult;
84421 }
84422
84423
84424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
84425   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84426   Dali::Property::Map *arg2 = 0 ;
84427   Dali::Size arg3 ;
84428   Dali::Size *argp3 ;
84429
84430   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84431   arg2 = (Dali::Property::Map *)jarg2;
84432   if (!arg2) {
84433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84434     return ;
84435   }
84436   argp3 = (Dali::Size *)jarg3;
84437   if (!argp3) {
84438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
84439     return ;
84440   }
84441   arg3 = *argp3;
84442   {
84443     try {
84444       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
84445     } catch (std::out_of_range& e) {
84446       {
84447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84448       };
84449     } catch (std::exception& e) {
84450       {
84451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84452       };
84453     } catch (...) {
84454       {
84455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84456       };
84457     }
84458   }
84459 }
84460
84461
84462 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
84463   float jresult ;
84464   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84465   float arg2 ;
84466   float result;
84467
84468   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84469   arg2 = (float)jarg2;
84470   {
84471     try {
84472       result = (float)(arg1)->GetHeightForWidth(arg2);
84473     } catch (std::out_of_range& e) {
84474       {
84475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84476       };
84477     } catch (std::exception& e) {
84478       {
84479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84480       };
84481     } catch (...) {
84482       {
84483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84484       };
84485     }
84486   }
84487   jresult = result;
84488   return jresult;
84489 }
84490
84491
84492 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
84493   float jresult ;
84494   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84495   float arg2 ;
84496   float result;
84497
84498   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84499   arg2 = (float)jarg2;
84500   {
84501     try {
84502       result = (float)(arg1)->GetWidthForHeight(arg2);
84503     } catch (std::out_of_range& e) {
84504       {
84505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84506       };
84507     } catch (std::exception& e) {
84508       {
84509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84510       };
84511     } catch (...) {
84512       {
84513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84514       };
84515     }
84516   }
84517   jresult = result;
84518   return jresult;
84519 }
84520
84521
84522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
84523   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84524   Dali::Vector2 *arg2 = 0 ;
84525
84526   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84527   arg2 = (Dali::Vector2 *)jarg2;
84528   if (!arg2) {
84529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
84530     return ;
84531   }
84532   {
84533     try {
84534       (arg1)->GetNaturalSize(*arg2);
84535     } catch (std::out_of_range& e) {
84536       {
84537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84538       };
84539     } catch (std::exception& e) {
84540       {
84541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84542       };
84543     } catch (...) {
84544       {
84545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84546       };
84547     }
84548   }
84549 }
84550
84551
84552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
84553   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84554   float arg2 ;
84555
84556   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84557   arg2 = (float)jarg2;
84558   {
84559     try {
84560       (arg1)->SetDepthIndex(arg2);
84561     } catch (std::out_of_range& e) {
84562       {
84563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84564       };
84565     } catch (std::exception& e) {
84566       {
84567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84568       };
84569     } catch (...) {
84570       {
84571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84572       };
84573     }
84574   }
84575 }
84576
84577
84578 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
84579   float jresult ;
84580   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84581   float result;
84582
84583   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84584   {
84585     try {
84586       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
84587     } catch (std::out_of_range& e) {
84588       {
84589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84590       };
84591     } catch (std::exception& e) {
84592       {
84593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84594       };
84595     } catch (...) {
84596       {
84597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84598       };
84599     }
84600   }
84601   jresult = result;
84602   return jresult;
84603 }
84604
84605
84606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
84607   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84608   Dali::Property::Map *arg2 = 0 ;
84609
84610   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84611   arg2 = (Dali::Property::Map *)jarg2;
84612   if (!arg2) {
84613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
84614     return ;
84615   }
84616   {
84617     try {
84618       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
84619     } catch (std::out_of_range& e) {
84620       {
84621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84622       };
84623     } catch (std::exception& e) {
84624       {
84625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84626       };
84627     } catch (...) {
84628       {
84629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84630       };
84631     }
84632   }
84633 }
84634
84635
84636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
84637   void * jresult ;
84638   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
84639   Dali::Toolkit::Visual::Base *result = 0 ;
84640
84641   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
84642   {
84643     try {
84644       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
84645     } catch (std::out_of_range& e) {
84646       {
84647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84648       };
84649     } catch (std::exception& e) {
84650       {
84651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84652       };
84653     } catch (...) {
84654       {
84655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84656       };
84657     }
84658   }
84659   jresult = (void *)result;
84660   return jresult;
84661 }
84662
84663
84664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
84665   void * jresult ;
84666   Dali::Toolkit::VisualFactory result;
84667
84668   {
84669     try {
84670       result = Dali::Toolkit::VisualFactory::Get();
84671     } catch (std::out_of_range& e) {
84672       {
84673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84674       };
84675     } catch (std::exception& e) {
84676       {
84677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84678       };
84679     } catch (...) {
84680       {
84681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84682       };
84683     }
84684   }
84685   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
84686   return jresult;
84687 }
84688
84689
84690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
84691   void * jresult ;
84692   Dali::Toolkit::VisualFactory *result = 0 ;
84693
84694   {
84695     try {
84696       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
84697     } catch (std::out_of_range& e) {
84698       {
84699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84700       };
84701     } catch (std::exception& e) {
84702       {
84703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84704       };
84705     } catch (...) {
84706       {
84707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84708       };
84709     }
84710   }
84711   jresult = (void *)result;
84712   return jresult;
84713 }
84714
84715
84716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
84717   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84718
84719   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84720   {
84721     try {
84722       delete arg1;
84723     } catch (std::out_of_range& e) {
84724       {
84725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84726       };
84727     } catch (std::exception& e) {
84728       {
84729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84730       };
84731     } catch (...) {
84732       {
84733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84734       };
84735     }
84736   }
84737 }
84738
84739
84740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
84741   void * jresult ;
84742   Dali::Toolkit::VisualFactory *arg1 = 0 ;
84743   Dali::Toolkit::VisualFactory *result = 0 ;
84744
84745   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84746   if (!arg1) {
84747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84748     return 0;
84749   }
84750   {
84751     try {
84752       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
84753     } catch (std::out_of_range& e) {
84754       {
84755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84756       };
84757     } catch (std::exception& e) {
84758       {
84759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84760       };
84761     } catch (...) {
84762       {
84763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84764       };
84765     }
84766   }
84767   jresult = (void *)result;
84768   return jresult;
84769 }
84770
84771
84772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
84773   void * jresult ;
84774   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84775   Dali::Toolkit::VisualFactory *arg2 = 0 ;
84776   Dali::Toolkit::VisualFactory *result = 0 ;
84777
84778   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84779   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
84780   if (!arg2) {
84781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84782     return 0;
84783   }
84784   {
84785     try {
84786       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
84787     } catch (std::out_of_range& e) {
84788       {
84789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84790       };
84791     } catch (std::exception& e) {
84792       {
84793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84794       };
84795     } catch (...) {
84796       {
84797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84798       };
84799     }
84800   }
84801   jresult = (void *)result;
84802   return jresult;
84803 }
84804
84805
84806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
84807   void * jresult ;
84808   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84809   Dali::Property::Map *arg2 = 0 ;
84810   Dali::Toolkit::Visual::Base result;
84811
84812   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84813   arg2 = (Dali::Property::Map *)jarg2;
84814   if (!arg2) {
84815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84816     return 0;
84817   }
84818   {
84819     try {
84820       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
84821     } catch (std::out_of_range& e) {
84822       {
84823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84824       };
84825     } catch (std::exception& e) {
84826       {
84827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84828       };
84829     } catch (...) {
84830       {
84831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84832       };
84833     }
84834   }
84835   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84836   return jresult;
84837 }
84838
84839
84840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
84841   void * jresult ;
84842   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84843   Dali::Image *arg2 = 0 ;
84844   Dali::Toolkit::Visual::Base result;
84845
84846   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84847   arg2 = (Dali::Image *)jarg2;
84848   if (!arg2) {
84849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
84850     return 0;
84851   }
84852   {
84853     try {
84854       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
84855     } catch (std::out_of_range& e) {
84856       {
84857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84858       };
84859     } catch (std::exception& e) {
84860       {
84861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84862       };
84863     } catch (...) {
84864       {
84865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84866       };
84867     }
84868   }
84869   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84870   return jresult;
84871 }
84872
84873
84874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
84875   void * jresult ;
84876   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84877   std::string *arg2 = 0 ;
84878   Dali::ImageDimensions arg3 ;
84879   Dali::ImageDimensions *argp3 ;
84880   Dali::Toolkit::Visual::Base result;
84881
84882   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84883   if (!jarg2) {
84884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84885     return 0;
84886   }
84887   std::string arg2_str(jarg2);
84888   arg2 = &arg2_str;
84889   argp3 = (Dali::ImageDimensions *)jarg3;
84890   if (!argp3) {
84891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
84892     return 0;
84893   }
84894   arg3 = *argp3;
84895   {
84896     try {
84897       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
84898     } catch (std::out_of_range& e) {
84899       {
84900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84901       };
84902     } catch (std::exception& e) {
84903       {
84904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84905       };
84906     } catch (...) {
84907       {
84908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84909       };
84910     }
84911   }
84912   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84913
84914   //argout typemap for const std::string&
84915
84916   return jresult;
84917 }
84918
84919
84920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
84921   void * jresult ;
84922   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84923
84924   {
84925     try {
84926       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
84927     } catch (std::out_of_range& e) {
84928       {
84929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84930       };
84931     } catch (std::exception& e) {
84932       {
84933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84934       };
84935     } catch (...) {
84936       {
84937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84938       };
84939     }
84940   }
84941   jresult = (void *)result;
84942   return jresult;
84943 }
84944
84945
84946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
84947   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84948
84949   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84950   {
84951     try {
84952       delete arg1;
84953     } catch (std::out_of_range& e) {
84954       {
84955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84956       };
84957     } catch (std::exception& e) {
84958       {
84959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84960       };
84961     } catch (...) {
84962       {
84963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84964       };
84965     }
84966   }
84967 }
84968
84969
84970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
84971   void * jresult ;
84972   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
84973   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84974
84975   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84976   if (!arg1) {
84977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
84978     return 0;
84979   }
84980   {
84981     try {
84982       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
84983     } catch (std::out_of_range& e) {
84984       {
84985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84986       };
84987     } catch (std::exception& e) {
84988       {
84989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84990       };
84991     } catch (...) {
84992       {
84993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84994       };
84995     }
84996   }
84997   jresult = (void *)result;
84998   return jresult;
84999 }
85000
85001
85002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
85003   void * jresult ;
85004   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85005   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
85006   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85007
85008   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85009   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
85010   if (!arg2) {
85011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85012     return 0;
85013   }
85014   {
85015     try {
85016       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
85017     } catch (std::out_of_range& e) {
85018       {
85019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85020       };
85021     } catch (std::exception& e) {
85022       {
85023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85024       };
85025     } catch (...) {
85026       {
85027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85028       };
85029     }
85030   }
85031   jresult = (void *)result;
85032   return jresult;
85033 }
85034
85035
85036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
85037   void * jresult ;
85038   Dali::Toolkit::AsyncImageLoader result;
85039
85040   {
85041     try {
85042       result = Dali::Toolkit::AsyncImageLoader::New();
85043     } catch (std::out_of_range& e) {
85044       {
85045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85046       };
85047     } catch (std::exception& e) {
85048       {
85049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85050       };
85051     } catch (...) {
85052       {
85053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85054       };
85055     }
85056   }
85057   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85058   return jresult;
85059 }
85060
85061
85062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
85063   void * jresult ;
85064   Dali::BaseHandle arg1 ;
85065   Dali::BaseHandle *argp1 ;
85066   Dali::Toolkit::AsyncImageLoader result;
85067
85068   argp1 = (Dali::BaseHandle *)jarg1;
85069   if (!argp1) {
85070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85071     return 0;
85072   }
85073   arg1 = *argp1;
85074   {
85075     try {
85076       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
85077     } catch (std::out_of_range& e) {
85078       {
85079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85080       };
85081     } catch (std::exception& e) {
85082       {
85083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85084       };
85085     } catch (...) {
85086       {
85087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85088       };
85089     }
85090   }
85091   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85092   return jresult;
85093 }
85094
85095
85096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
85097   unsigned int jresult ;
85098   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85099   std::string *arg2 = 0 ;
85100   uint32_t result;
85101
85102   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85103   if (!jarg2) {
85104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85105     return 0;
85106   }
85107   std::string arg2_str(jarg2);
85108   arg2 = &arg2_str;
85109   {
85110     try {
85111       result = (arg1)->Load((std::string const &)*arg2);
85112     } catch (std::out_of_range& e) {
85113       {
85114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85115       };
85116     } catch (std::exception& e) {
85117       {
85118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85119       };
85120     } catch (...) {
85121       {
85122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85123       };
85124     }
85125   }
85126   jresult = result;
85127
85128   //argout typemap for const std::string&
85129
85130   return jresult;
85131 }
85132
85133
85134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
85135   unsigned int jresult ;
85136   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85137   std::string *arg2 = 0 ;
85138   Dali::ImageDimensions arg3 ;
85139   Dali::ImageDimensions *argp3 ;
85140   uint32_t result;
85141
85142   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85143   if (!jarg2) {
85144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85145     return 0;
85146   }
85147   std::string arg2_str(jarg2);
85148   arg2 = &arg2_str;
85149   argp3 = (Dali::ImageDimensions *)jarg3;
85150   if (!argp3) {
85151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85152     return 0;
85153   }
85154   arg3 = *argp3;
85155   {
85156     try {
85157       result = (arg1)->Load((std::string const &)*arg2,arg3);
85158     } catch (std::out_of_range& e) {
85159       {
85160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85161       };
85162     } catch (std::exception& e) {
85163       {
85164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85165       };
85166     } catch (...) {
85167       {
85168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85169       };
85170     }
85171   }
85172   jresult = result;
85173
85174   //argout typemap for const std::string&
85175
85176   return jresult;
85177 }
85178
85179
85180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
85181   unsigned int jresult ;
85182   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85183   std::string *arg2 = 0 ;
85184   Dali::ImageDimensions arg3 ;
85185   Dali::FittingMode::Type arg4 ;
85186   Dali::SamplingMode::Type arg5 ;
85187   bool arg6 ;
85188   Dali::ImageDimensions *argp3 ;
85189   uint32_t result;
85190
85191   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85192   if (!jarg2) {
85193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85194     return 0;
85195   }
85196   std::string arg2_str(jarg2);
85197   arg2 = &arg2_str;
85198   argp3 = (Dali::ImageDimensions *)jarg3;
85199   if (!argp3) {
85200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85201     return 0;
85202   }
85203   arg3 = *argp3;
85204   arg4 = (Dali::FittingMode::Type)jarg4;
85205   arg5 = (Dali::SamplingMode::Type)jarg5;
85206   arg6 = jarg6 ? true : false;
85207   {
85208     try {
85209       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
85210     } catch (std::out_of_range& e) {
85211       {
85212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85213       };
85214     } catch (std::exception& e) {
85215       {
85216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85217       };
85218     } catch (...) {
85219       {
85220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85221       };
85222     }
85223   }
85224   jresult = result;
85225
85226   //argout typemap for const std::string&
85227
85228   return jresult;
85229 }
85230
85231
85232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
85233   unsigned int jresult ;
85234   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85235   uint32_t arg2 ;
85236   bool result;
85237
85238   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85239   arg2 = (uint32_t)jarg2;
85240   {
85241     try {
85242       result = (bool)(arg1)->Cancel(arg2);
85243     } catch (std::out_of_range& e) {
85244       {
85245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85246       };
85247     } catch (std::exception& e) {
85248       {
85249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85250       };
85251     } catch (...) {
85252       {
85253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85254       };
85255     }
85256   }
85257   jresult = result;
85258   return jresult;
85259 }
85260
85261
85262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
85263   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85264
85265   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85266   {
85267     try {
85268       (arg1)->CancelAll();
85269     } catch (std::out_of_range& e) {
85270       {
85271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85272       };
85273     } catch (std::exception& e) {
85274       {
85275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85276       };
85277     } catch (...) {
85278       {
85279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85280       };
85281     }
85282   }
85283 }
85284
85285
85286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
85287   void * jresult ;
85288   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85289   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
85290
85291   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85292   {
85293     try {
85294       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
85295     } catch (std::out_of_range& e) {
85296       {
85297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85298       };
85299     } catch (std::exception& e) {
85300       {
85301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85302       };
85303     } catch (...) {
85304       {
85305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85306       };
85307     }
85308   }
85309   jresult = (void *)result;
85310   return jresult;
85311 }
85312
85313
85314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
85315   void * jresult ;
85316   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
85317   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85318
85319   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
85320   {
85321     try {
85322       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
85323     } catch (std::out_of_range& e) {
85324       {
85325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85326       };
85327     } catch (std::exception& e) {
85328       {
85329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85330       };
85331     } catch (...) {
85332       {
85333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85334       };
85335     }
85336   }
85337   jresult = (void *)result;
85338   return jresult;
85339 }
85340
85341
85342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
85343   void * jresult ;
85344   std::string *arg1 = 0 ;
85345   Dali::PixelData result;
85346
85347   if (!jarg1) {
85348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85349     return 0;
85350   }
85351   std::string arg1_str(jarg1);
85352   arg1 = &arg1_str;
85353   {
85354     try {
85355       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
85356     } catch (std::out_of_range& e) {
85357       {
85358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85359       };
85360     } catch (std::exception& e) {
85361       {
85362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85363       };
85364     } catch (...) {
85365       {
85366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85367       };
85368     }
85369   }
85370   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85371
85372   //argout typemap for const std::string&
85373
85374   return jresult;
85375 }
85376
85377
85378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
85379   void * jresult ;
85380   std::string *arg1 = 0 ;
85381   Dali::ImageDimensions arg2 ;
85382   Dali::ImageDimensions *argp2 ;
85383   Dali::PixelData result;
85384
85385   if (!jarg1) {
85386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85387     return 0;
85388   }
85389   std::string arg1_str(jarg1);
85390   arg1 = &arg1_str;
85391   argp2 = (Dali::ImageDimensions *)jarg2;
85392   if (!argp2) {
85393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85394     return 0;
85395   }
85396   arg2 = *argp2;
85397   {
85398     try {
85399       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
85400     } catch (std::out_of_range& e) {
85401       {
85402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85403       };
85404     } catch (std::exception& e) {
85405       {
85406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85407       };
85408     } catch (...) {
85409       {
85410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85411       };
85412     }
85413   }
85414   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85415
85416   //argout typemap for const std::string&
85417
85418   return jresult;
85419 }
85420
85421
85422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
85423   void * jresult ;
85424   std::string *arg1 = 0 ;
85425   Dali::ImageDimensions arg2 ;
85426   Dali::FittingMode::Type arg3 ;
85427   Dali::SamplingMode::Type arg4 ;
85428   bool arg5 ;
85429   Dali::ImageDimensions *argp2 ;
85430   Dali::PixelData result;
85431
85432   if (!jarg1) {
85433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85434     return 0;
85435   }
85436   std::string arg1_str(jarg1);
85437   arg1 = &arg1_str;
85438   argp2 = (Dali::ImageDimensions *)jarg2;
85439   if (!argp2) {
85440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85441     return 0;
85442   }
85443   arg2 = *argp2;
85444   arg3 = (Dali::FittingMode::Type)jarg3;
85445   arg4 = (Dali::SamplingMode::Type)jarg4;
85446   arg5 = jarg5 ? true : false;
85447   {
85448     try {
85449       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
85450     } catch (std::out_of_range& e) {
85451       {
85452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85453       };
85454     } catch (std::exception& e) {
85455       {
85456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85457       };
85458     } catch (...) {
85459       {
85460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85461       };
85462     }
85463   }
85464   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85465
85466   //argout typemap for const std::string&
85467
85468   return jresult;
85469 }
85470
85471
85472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
85473   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85474
85475   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85476   {
85477     try {
85478       delete arg1;
85479     } catch (std::out_of_range& e) {
85480       {
85481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85482       };
85483     } catch (std::exception& e) {
85484       {
85485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85486       };
85487     } catch (...) {
85488       {
85489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85490       };
85491     }
85492   }
85493 }
85494
85495
85496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
85497   void * jresult ;
85498   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85499   Dali::Actor arg2 ;
85500   Dali::Actor arg3 ;
85501   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
85502   Dali::Actor *argp2 ;
85503   Dali::Actor *argp3 ;
85504   Dali::Actor result;
85505
85506   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85507   argp2 = (Dali::Actor *)jarg2;
85508   if (!argp2) {
85509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85510     return 0;
85511   }
85512   arg2 = *argp2;
85513   argp3 = (Dali::Actor *)jarg3;
85514   if (!argp3) {
85515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85516     return 0;
85517   }
85518   arg3 = *argp3;
85519   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
85520   {
85521     try {
85522       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
85523     } catch (std::out_of_range& e) {
85524       {
85525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85526       };
85527     } catch (std::exception& e) {
85528       {
85529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85530       };
85531     } catch (...) {
85532       {
85533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85534       };
85535     }
85536   }
85537   jresult = new Dali::Actor((const Dali::Actor &)result);
85538   return jresult;
85539 }
85540
85541
85542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
85543   void * jresult ;
85544   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
85545
85546   {
85547     try {
85548       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
85549     } catch (std::out_of_range& e) {
85550       {
85551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85552       };
85553     } catch (std::exception& e) {
85554       {
85555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85556       };
85557     } catch (...) {
85558       {
85559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85560       };
85561     }
85562   }
85563   jresult = (void *)result;
85564   return jresult;
85565 }
85566
85567
85568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
85569   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
85570   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
85571   if (director) {
85572     director->swig_connect_director(callback0);
85573   }
85574 }
85575
85576
85577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
85578   KeyboardFocusManager arg1 ;
85579   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
85580   KeyboardFocusManager *argp1 ;
85581
85582   argp1 = (KeyboardFocusManager *)jarg1;
85583   if (!argp1) {
85584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
85585     return ;
85586   }
85587   arg1 = *argp1;
85588   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
85589   if (!arg2) {
85590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
85591     return ;
85592   }
85593   {
85594     try {
85595       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
85596     } catch (std::out_of_range& e) {
85597       {
85598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85599       };
85600     } catch (std::exception& e) {
85601       {
85602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85603       };
85604     } catch (...) {
85605       {
85606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85607       };
85608     }
85609   }
85610 }
85611
85612
85613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
85614   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85615
85616   arg1 = (std::vector< unsigned int > *)jarg1;
85617   {
85618     try {
85619       (arg1)->clear();
85620     } catch (std::out_of_range& e) {
85621       {
85622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85623       };
85624     } catch (std::exception& e) {
85625       {
85626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85627       };
85628     } catch (...) {
85629       {
85630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85631       };
85632     }
85633   }
85634 }
85635
85636
85637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
85638   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85639   unsigned int *arg2 = 0 ;
85640   unsigned int temp2 ;
85641
85642   arg1 = (std::vector< unsigned int > *)jarg1;
85643   temp2 = (unsigned int)jarg2;
85644   arg2 = &temp2;
85645   {
85646     try {
85647       (arg1)->push_back((unsigned int const &)*arg2);
85648     } catch (std::out_of_range& e) {
85649       {
85650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85651       };
85652     } catch (std::exception& e) {
85653       {
85654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85655       };
85656     } catch (...) {
85657       {
85658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85659       };
85660     }
85661   }
85662 }
85663
85664
85665 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
85666   unsigned long jresult ;
85667   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85668   std::vector< unsigned int >::size_type result;
85669
85670   arg1 = (std::vector< unsigned int > *)jarg1;
85671   {
85672     try {
85673       result = ((std::vector< unsigned int > const *)arg1)->size();
85674     } catch (std::out_of_range& e) {
85675       {
85676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85677       };
85678     } catch (std::exception& e) {
85679       {
85680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85681       };
85682     } catch (...) {
85683       {
85684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85685       };
85686     }
85687   }
85688   jresult = (unsigned long)result;
85689   return jresult;
85690 }
85691
85692
85693 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
85694   unsigned long jresult ;
85695   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85696   std::vector< unsigned int >::size_type result;
85697
85698   arg1 = (std::vector< unsigned int > *)jarg1;
85699   {
85700     try {
85701       result = ((std::vector< unsigned int > const *)arg1)->capacity();
85702     } catch (std::out_of_range& e) {
85703       {
85704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85705       };
85706     } catch (std::exception& e) {
85707       {
85708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85709       };
85710     } catch (...) {
85711       {
85712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85713       };
85714     }
85715   }
85716   jresult = (unsigned long)result;
85717   return jresult;
85718 }
85719
85720
85721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
85722   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85723   std::vector< unsigned int >::size_type arg2 ;
85724
85725   arg1 = (std::vector< unsigned int > *)jarg1;
85726   arg2 = (std::vector< unsigned int >::size_type)jarg2;
85727   {
85728     try {
85729       (arg1)->reserve(arg2);
85730     } catch (std::out_of_range& e) {
85731       {
85732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85733       };
85734     } catch (std::exception& e) {
85735       {
85736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85737       };
85738     } catch (...) {
85739       {
85740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85741       };
85742     }
85743   }
85744 }
85745
85746
85747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
85748   void * jresult ;
85749   std::vector< unsigned int > *result = 0 ;
85750
85751   {
85752     try {
85753       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
85754     } catch (std::out_of_range& e) {
85755       {
85756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85757       };
85758     } catch (std::exception& e) {
85759       {
85760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85761       };
85762     } catch (...) {
85763       {
85764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85765       };
85766     }
85767   }
85768   jresult = (void *)result;
85769   return jresult;
85770 }
85771
85772
85773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
85774   void * jresult ;
85775   std::vector< unsigned int > *arg1 = 0 ;
85776   std::vector< unsigned int > *result = 0 ;
85777
85778   arg1 = (std::vector< unsigned int > *)jarg1;
85779   if (!arg1) {
85780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85781     return 0;
85782   }
85783   {
85784     try {
85785       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
85786     } catch (std::out_of_range& e) {
85787       {
85788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85789       };
85790     } catch (std::exception& e) {
85791       {
85792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85793       };
85794     } catch (...) {
85795       {
85796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85797       };
85798     }
85799   }
85800   jresult = (void *)result;
85801   return jresult;
85802 }
85803
85804
85805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
85806   void * jresult ;
85807   int arg1 ;
85808   std::vector< unsigned int > *result = 0 ;
85809
85810   arg1 = (int)jarg1;
85811   {
85812     try {
85813       try {
85814         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
85815       }
85816       catch(std::out_of_range &_e) {
85817         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85818         return 0;
85819       }
85820
85821     } catch (std::out_of_range& e) {
85822       {
85823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85824       };
85825     } catch (std::exception& e) {
85826       {
85827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85828       };
85829     } catch (...) {
85830       {
85831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85832       };
85833     }
85834   }
85835   jresult = (void *)result;
85836   return jresult;
85837 }
85838
85839
85840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
85841   unsigned int jresult ;
85842   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85843   int arg2 ;
85844   unsigned int result;
85845
85846   arg1 = (std::vector< unsigned int > *)jarg1;
85847   arg2 = (int)jarg2;
85848   {
85849     try {
85850       try {
85851         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
85852       }
85853       catch(std::out_of_range &_e) {
85854         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85855         return 0;
85856       }
85857
85858     } catch (std::out_of_range& e) {
85859       {
85860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85861       };
85862     } catch (std::exception& e) {
85863       {
85864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85865       };
85866     } catch (...) {
85867       {
85868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85869       };
85870     }
85871   }
85872   jresult = result;
85873   return jresult;
85874 }
85875
85876
85877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
85878   unsigned int jresult ;
85879   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85880   int arg2 ;
85881   unsigned int *result = 0 ;
85882
85883   arg1 = (std::vector< unsigned int > *)jarg1;
85884   arg2 = (int)jarg2;
85885   {
85886     try {
85887       try {
85888         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
85889       }
85890       catch(std::out_of_range &_e) {
85891         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85892         return 0;
85893       }
85894
85895     } catch (std::out_of_range& e) {
85896       {
85897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85898       };
85899     } catch (std::exception& e) {
85900       {
85901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85902       };
85903     } catch (...) {
85904       {
85905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85906       };
85907     }
85908   }
85909   jresult = *result;
85910   return jresult;
85911 }
85912
85913
85914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
85915   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85916   int arg2 ;
85917   unsigned int *arg3 = 0 ;
85918   unsigned int temp3 ;
85919
85920   arg1 = (std::vector< unsigned int > *)jarg1;
85921   arg2 = (int)jarg2;
85922   temp3 = (unsigned int)jarg3;
85923   arg3 = &temp3;
85924   {
85925     try {
85926       try {
85927         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
85928       }
85929       catch(std::out_of_range &_e) {
85930         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85931         return ;
85932       }
85933
85934     } catch (std::out_of_range& e) {
85935       {
85936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85937       };
85938     } catch (std::exception& e) {
85939       {
85940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85941       };
85942     } catch (...) {
85943       {
85944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85945       };
85946     }
85947   }
85948 }
85949
85950
85951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
85952   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85953   std::vector< unsigned int > *arg2 = 0 ;
85954
85955   arg1 = (std::vector< unsigned int > *)jarg1;
85956   arg2 = (std::vector< unsigned int > *)jarg2;
85957   if (!arg2) {
85958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85959     return ;
85960   }
85961   {
85962     try {
85963       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
85964     } catch (std::out_of_range& e) {
85965       {
85966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85967       };
85968     } catch (std::exception& e) {
85969       {
85970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85971       };
85972     } catch (...) {
85973       {
85974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85975       };
85976     }
85977   }
85978 }
85979
85980
85981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
85982   void * jresult ;
85983   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85984   int arg2 ;
85985   int arg3 ;
85986   std::vector< unsigned int > *result = 0 ;
85987
85988   arg1 = (std::vector< unsigned int > *)jarg1;
85989   arg2 = (int)jarg2;
85990   arg3 = (int)jarg3;
85991   {
85992     try {
85993       try {
85994         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
85995       }
85996       catch(std::out_of_range &_e) {
85997         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85998         return 0;
85999       }
86000       catch(std::invalid_argument &_e) {
86001         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86002         return 0;
86003       }
86004
86005     } catch (std::out_of_range& e) {
86006       {
86007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86008       };
86009     } catch (std::exception& e) {
86010       {
86011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86012       };
86013     } catch (...) {
86014       {
86015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86016       };
86017     }
86018   }
86019   jresult = (void *)result;
86020   return jresult;
86021 }
86022
86023
86024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
86025   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86026   int arg2 ;
86027   unsigned int *arg3 = 0 ;
86028   unsigned int temp3 ;
86029
86030   arg1 = (std::vector< unsigned int > *)jarg1;
86031   arg2 = (int)jarg2;
86032   temp3 = (unsigned int)jarg3;
86033   arg3 = &temp3;
86034   {
86035     try {
86036       try {
86037         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
86038       }
86039       catch(std::out_of_range &_e) {
86040         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86041         return ;
86042       }
86043
86044     } catch (std::out_of_range& e) {
86045       {
86046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86047       };
86048     } catch (std::exception& e) {
86049       {
86050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86051       };
86052     } catch (...) {
86053       {
86054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86055       };
86056     }
86057   }
86058 }
86059
86060
86061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
86062   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86063   int arg2 ;
86064   std::vector< unsigned int > *arg3 = 0 ;
86065
86066   arg1 = (std::vector< unsigned int > *)jarg1;
86067   arg2 = (int)jarg2;
86068   arg3 = (std::vector< unsigned int > *)jarg3;
86069   if (!arg3) {
86070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86071     return ;
86072   }
86073   {
86074     try {
86075       try {
86076         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86077       }
86078       catch(std::out_of_range &_e) {
86079         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86080         return ;
86081       }
86082
86083     } catch (std::out_of_range& e) {
86084       {
86085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86086       };
86087     } catch (std::exception& e) {
86088       {
86089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86090       };
86091     } catch (...) {
86092       {
86093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86094       };
86095     }
86096   }
86097 }
86098
86099
86100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
86101   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86102   int arg2 ;
86103
86104   arg1 = (std::vector< unsigned int > *)jarg1;
86105   arg2 = (int)jarg2;
86106   {
86107     try {
86108       try {
86109         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
86110       }
86111       catch(std::out_of_range &_e) {
86112         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86113         return ;
86114       }
86115
86116     } catch (std::out_of_range& e) {
86117       {
86118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86119       };
86120     } catch (std::exception& e) {
86121       {
86122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86123       };
86124     } catch (...) {
86125       {
86126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86127       };
86128     }
86129   }
86130 }
86131
86132
86133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
86134   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86135   int arg2 ;
86136   int arg3 ;
86137
86138   arg1 = (std::vector< unsigned int > *)jarg1;
86139   arg2 = (int)jarg2;
86140   arg3 = (int)jarg3;
86141   {
86142     try {
86143       try {
86144         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
86145       }
86146       catch(std::out_of_range &_e) {
86147         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86148         return ;
86149       }
86150       catch(std::invalid_argument &_e) {
86151         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86152         return ;
86153       }
86154
86155     } catch (std::out_of_range& e) {
86156       {
86157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86158       };
86159     } catch (std::exception& e) {
86160       {
86161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86162       };
86163     } catch (...) {
86164       {
86165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86166       };
86167     }
86168   }
86169 }
86170
86171
86172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
86173   void * jresult ;
86174   unsigned int *arg1 = 0 ;
86175   int arg2 ;
86176   unsigned int temp1 ;
86177   std::vector< unsigned int > *result = 0 ;
86178
86179   temp1 = (unsigned int)jarg1;
86180   arg1 = &temp1;
86181   arg2 = (int)jarg2;
86182   {
86183     try {
86184       try {
86185         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
86186       }
86187       catch(std::out_of_range &_e) {
86188         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86189         return 0;
86190       }
86191
86192     } catch (std::out_of_range& e) {
86193       {
86194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86195       };
86196     } catch (std::exception& e) {
86197       {
86198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86199       };
86200     } catch (...) {
86201       {
86202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86203       };
86204     }
86205   }
86206   jresult = (void *)result;
86207   return jresult;
86208 }
86209
86210
86211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
86212   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86213
86214   arg1 = (std::vector< unsigned int > *)jarg1;
86215   {
86216     try {
86217       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
86218     } catch (std::out_of_range& e) {
86219       {
86220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86221       };
86222     } catch (std::exception& e) {
86223       {
86224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86225       };
86226     } catch (...) {
86227       {
86228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86229       };
86230     }
86231   }
86232 }
86233
86234
86235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
86236   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86237   int arg2 ;
86238   int arg3 ;
86239
86240   arg1 = (std::vector< unsigned int > *)jarg1;
86241   arg2 = (int)jarg2;
86242   arg3 = (int)jarg3;
86243   {
86244     try {
86245       try {
86246         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
86247       }
86248       catch(std::out_of_range &_e) {
86249         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86250         return ;
86251       }
86252       catch(std::invalid_argument &_e) {
86253         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86254         return ;
86255       }
86256
86257     } catch (std::out_of_range& e) {
86258       {
86259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86260       };
86261     } catch (std::exception& e) {
86262       {
86263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86264       };
86265     } catch (...) {
86266       {
86267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86268       };
86269     }
86270   }
86271 }
86272
86273
86274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
86275   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86276   int arg2 ;
86277   std::vector< unsigned int > *arg3 = 0 ;
86278
86279   arg1 = (std::vector< unsigned int > *)jarg1;
86280   arg2 = (int)jarg2;
86281   arg3 = (std::vector< unsigned int > *)jarg3;
86282   if (!arg3) {
86283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86284     return ;
86285   }
86286   {
86287     try {
86288       try {
86289         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86290       }
86291       catch(std::out_of_range &_e) {
86292         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86293         return ;
86294       }
86295
86296     } catch (std::out_of_range& e) {
86297       {
86298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86299       };
86300     } catch (std::exception& e) {
86301       {
86302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86303       };
86304     } catch (...) {
86305       {
86306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86307       };
86308     }
86309   }
86310 }
86311
86312
86313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
86314   unsigned int jresult ;
86315   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86316   unsigned int *arg2 = 0 ;
86317   unsigned int temp2 ;
86318   bool result;
86319
86320   arg1 = (std::vector< unsigned int > *)jarg1;
86321   temp2 = (unsigned int)jarg2;
86322   arg2 = &temp2;
86323   {
86324     try {
86325       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
86326     } catch (std::out_of_range& e) {
86327       {
86328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86329       };
86330     } catch (std::exception& e) {
86331       {
86332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86333       };
86334     } catch (...) {
86335       {
86336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86337       };
86338     }
86339   }
86340   jresult = result;
86341   return jresult;
86342 }
86343
86344
86345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
86346   int jresult ;
86347   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86348   unsigned int *arg2 = 0 ;
86349   unsigned int temp2 ;
86350   int result;
86351
86352   arg1 = (std::vector< unsigned int > *)jarg1;
86353   temp2 = (unsigned int)jarg2;
86354   arg2 = &temp2;
86355   {
86356     try {
86357       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
86358     } catch (std::out_of_range& e) {
86359       {
86360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86361       };
86362     } catch (std::exception& e) {
86363       {
86364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86365       };
86366     } catch (...) {
86367       {
86368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86369       };
86370     }
86371   }
86372   jresult = result;
86373   return jresult;
86374 }
86375
86376
86377 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
86378   int jresult ;
86379   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86380   unsigned int *arg2 = 0 ;
86381   unsigned int temp2 ;
86382   int result;
86383
86384   arg1 = (std::vector< unsigned int > *)jarg1;
86385   temp2 = (unsigned int)jarg2;
86386   arg2 = &temp2;
86387   {
86388     try {
86389       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
86390     } catch (std::out_of_range& e) {
86391       {
86392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86393       };
86394     } catch (std::exception& e) {
86395       {
86396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86397       };
86398     } catch (...) {
86399       {
86400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86401       };
86402     }
86403   }
86404   jresult = result;
86405   return jresult;
86406 }
86407
86408
86409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
86410   unsigned int jresult ;
86411   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86412   unsigned int *arg2 = 0 ;
86413   unsigned int temp2 ;
86414   bool result;
86415
86416   arg1 = (std::vector< unsigned int > *)jarg1;
86417   temp2 = (unsigned int)jarg2;
86418   arg2 = &temp2;
86419   {
86420     try {
86421       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
86422     } catch (std::out_of_range& e) {
86423       {
86424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86425       };
86426     } catch (std::exception& e) {
86427       {
86428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86429       };
86430     } catch (...) {
86431       {
86432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86433       };
86434     }
86435   }
86436   jresult = result;
86437   return jresult;
86438 }
86439
86440
86441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
86442   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86443
86444   arg1 = (std::vector< unsigned int > *)jarg1;
86445   {
86446     try {
86447       delete arg1;
86448     } catch (std::out_of_range& e) {
86449       {
86450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86451       };
86452     } catch (std::exception& e) {
86453       {
86454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86455       };
86456     } catch (...) {
86457       {
86458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86459       };
86460     }
86461   }
86462 }
86463
86464
86465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
86466   void * jresult ;
86467   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86468
86469   {
86470     try {
86471       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
86472     } catch (std::out_of_range& e) {
86473       {
86474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86475       };
86476     } catch (std::exception& e) {
86477       {
86478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86479       };
86480     } catch (...) {
86481       {
86482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86483       };
86484     }
86485   }
86486   jresult = (void *)result;
86487   return jresult;
86488 }
86489
86490
86491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
86492   void * jresult ;
86493   unsigned int arg1 ;
86494   Dali::Actor arg2 ;
86495   Dali::Actor *argp2 ;
86496   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86497
86498   arg1 = (unsigned int)jarg1;
86499   argp2 = (Dali::Actor *)jarg2;
86500   if (!argp2) {
86501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86502     return 0;
86503   }
86504   arg2 = *argp2;
86505   {
86506     try {
86507       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
86508     } catch (std::out_of_range& e) {
86509       {
86510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86511       };
86512     } catch (std::exception& e) {
86513       {
86514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86515       };
86516     } catch (...) {
86517       {
86518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86519       };
86520     }
86521   }
86522   jresult = (void *)result;
86523   return jresult;
86524 }
86525
86526
86527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
86528   void * jresult ;
86529   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86530   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86531
86532   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86533   if (!arg1) {
86534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86535     return 0;
86536   }
86537   {
86538     try {
86539       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
86540     } catch (std::out_of_range& e) {
86541       {
86542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86543       };
86544     } catch (std::exception& e) {
86545       {
86546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86547       };
86548     } catch (...) {
86549       {
86550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86551       };
86552     }
86553   }
86554   jresult = (void *)result;
86555   return jresult;
86556 }
86557
86558
86559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
86560   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86561   unsigned int arg2 ;
86562
86563   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86564   arg2 = (unsigned int)jarg2;
86565   if (arg1) (arg1)->first = arg2;
86566 }
86567
86568
86569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
86570   unsigned int jresult ;
86571   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86572   unsigned int result;
86573
86574   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86575   result = (unsigned int) ((arg1)->first);
86576   jresult = result;
86577   return jresult;
86578 }
86579
86580
86581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
86582   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86583   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
86584
86585   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86586   arg2 = (Dali::Actor *)jarg2;
86587   if (arg1) (arg1)->second = *arg2;
86588 }
86589
86590
86591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
86592   void * jresult ;
86593   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86594   Dali::Actor *result = 0 ;
86595
86596   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86597   result = (Dali::Actor *)& ((arg1)->second);
86598   jresult = (void *)result;
86599   return jresult;
86600 }
86601
86602
86603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
86604   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86605
86606   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86607   {
86608     try {
86609       delete arg1;
86610     } catch (std::out_of_range& e) {
86611       {
86612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86613       };
86614     } catch (std::exception& e) {
86615       {
86616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86617       };
86618     } catch (...) {
86619       {
86620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86621       };
86622     }
86623   }
86624 }
86625
86626
86627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
86628   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86629
86630   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86631   {
86632     try {
86633       (arg1)->clear();
86634     } catch (std::out_of_range& e) {
86635       {
86636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86637       };
86638     } catch (std::exception& e) {
86639       {
86640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86641       };
86642     } catch (...) {
86643       {
86644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86645       };
86646     }
86647   }
86648 }
86649
86650
86651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
86652   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86653   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
86654
86655   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86656   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
86657   if (!arg2) {
86658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86659     return ;
86660   }
86661   {
86662     try {
86663       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
86664     } catch (std::out_of_range& e) {
86665       {
86666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86667       };
86668     } catch (std::exception& e) {
86669       {
86670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86671       };
86672     } catch (...) {
86673       {
86674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86675       };
86676     }
86677   }
86678 }
86679
86680
86681 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
86682   unsigned long jresult ;
86683   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86684   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86685
86686   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86687   {
86688     try {
86689       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
86690     } catch (std::out_of_range& e) {
86691       {
86692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86693       };
86694     } catch (std::exception& e) {
86695       {
86696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86697       };
86698     } catch (...) {
86699       {
86700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86701       };
86702     }
86703   }
86704   jresult = (unsigned long)result;
86705   return jresult;
86706 }
86707
86708
86709 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
86710   unsigned long jresult ;
86711   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86712   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86713
86714   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86715   {
86716     try {
86717       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
86718     } catch (std::out_of_range& e) {
86719       {
86720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86721       };
86722     } catch (std::exception& e) {
86723       {
86724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86725       };
86726     } catch (...) {
86727       {
86728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86729       };
86730     }
86731   }
86732   jresult = (unsigned long)result;
86733   return jresult;
86734 }
86735
86736
86737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
86738   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86739   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
86740
86741   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86742   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
86743   {
86744     try {
86745       (arg1)->reserve(arg2);
86746     } catch (std::out_of_range& e) {
86747       {
86748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86749       };
86750     } catch (std::exception& e) {
86751       {
86752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86753       };
86754     } catch (...) {
86755       {
86756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86757       };
86758     }
86759   }
86760 }
86761
86762
86763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
86764   void * jresult ;
86765   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86766
86767   {
86768     try {
86769       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
86770     } catch (std::out_of_range& e) {
86771       {
86772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86773       };
86774     } catch (std::exception& e) {
86775       {
86776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86777       };
86778     } catch (...) {
86779       {
86780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86781       };
86782     }
86783   }
86784   jresult = (void *)result;
86785   return jresult;
86786 }
86787
86788
86789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
86790   void * jresult ;
86791   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
86792   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86793
86794   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86795   if (!arg1) {
86796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86797     return 0;
86798   }
86799   {
86800     try {
86801       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);
86802     } catch (std::out_of_range& e) {
86803       {
86804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86805       };
86806     } catch (std::exception& e) {
86807       {
86808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86809       };
86810     } catch (...) {
86811       {
86812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86813       };
86814     }
86815   }
86816   jresult = (void *)result;
86817   return jresult;
86818 }
86819
86820
86821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
86822   void * jresult ;
86823   int arg1 ;
86824   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86825
86826   arg1 = (int)jarg1;
86827   {
86828     try {
86829       try {
86830         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);
86831       }
86832       catch(std::out_of_range &_e) {
86833         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86834         return 0;
86835       }
86836
86837     } catch (std::out_of_range& e) {
86838       {
86839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86840       };
86841     } catch (std::exception& e) {
86842       {
86843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86844       };
86845     } catch (...) {
86846       {
86847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86848       };
86849     }
86850   }
86851   jresult = (void *)result;
86852   return jresult;
86853 }
86854
86855
86856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
86857   void * jresult ;
86858   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86859   int arg2 ;
86860   std::pair< unsigned int,Dali::Actor > result;
86861
86862   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86863   arg2 = (int)jarg2;
86864   {
86865     try {
86866       try {
86867         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
86868       }
86869       catch(std::out_of_range &_e) {
86870         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86871         return 0;
86872       }
86873
86874     } catch (std::out_of_range& e) {
86875       {
86876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86877       };
86878     } catch (std::exception& e) {
86879       {
86880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86881       };
86882     } catch (...) {
86883       {
86884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86885       };
86886     }
86887   }
86888   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
86889   return jresult;
86890 }
86891
86892
86893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
86894   void * jresult ;
86895   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86896   int arg2 ;
86897   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86898
86899   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86900   arg2 = (int)jarg2;
86901   {
86902     try {
86903       try {
86904         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
86905       }
86906       catch(std::out_of_range &_e) {
86907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86908         return 0;
86909       }
86910
86911     } catch (std::out_of_range& e) {
86912       {
86913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86914       };
86915     } catch (std::exception& e) {
86916       {
86917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86918       };
86919     } catch (...) {
86920       {
86921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86922       };
86923     }
86924   }
86925   jresult = (void *)result;
86926   return jresult;
86927 }
86928
86929
86930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
86931   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86932   int arg2 ;
86933   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
86934
86935   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86936   arg2 = (int)jarg2;
86937   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
86938   if (!arg3) {
86939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86940     return ;
86941   }
86942   {
86943     try {
86944       try {
86945         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);
86946       }
86947       catch(std::out_of_range &_e) {
86948         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86949         return ;
86950       }
86951
86952     } catch (std::out_of_range& e) {
86953       {
86954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86955       };
86956     } catch (std::exception& e) {
86957       {
86958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86959       };
86960     } catch (...) {
86961       {
86962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86963       };
86964     }
86965   }
86966 }
86967
86968
86969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
86970   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86971   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
86972
86973   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86974   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
86975   if (!arg2) {
86976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86977     return ;
86978   }
86979   {
86980     try {
86981       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);
86982     } catch (std::out_of_range& e) {
86983       {
86984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86985       };
86986     } catch (std::exception& e) {
86987       {
86988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86989       };
86990     } catch (...) {
86991       {
86992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86993       };
86994     }
86995   }
86996 }
86997
86998
86999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87000   void * jresult ;
87001   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87002   int arg2 ;
87003   int arg3 ;
87004   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87005
87006   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87007   arg2 = (int)jarg2;
87008   arg3 = (int)jarg3;
87009   {
87010     try {
87011       try {
87012         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);
87013       }
87014       catch(std::out_of_range &_e) {
87015         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87016         return 0;
87017       }
87018       catch(std::invalid_argument &_e) {
87019         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87020         return 0;
87021       }
87022
87023     } catch (std::out_of_range& e) {
87024       {
87025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87026       };
87027     } catch (std::exception& e) {
87028       {
87029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87030       };
87031     } catch (...) {
87032       {
87033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87034       };
87035     }
87036   }
87037   jresult = (void *)result;
87038   return jresult;
87039 }
87040
87041
87042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87043   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87044   int arg2 ;
87045   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87046
87047   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87048   arg2 = (int)jarg2;
87049   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87050   if (!arg3) {
87051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87052     return ;
87053   }
87054   {
87055     try {
87056       try {
87057         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);
87058       }
87059       catch(std::out_of_range &_e) {
87060         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87061         return ;
87062       }
87063
87064     } catch (std::out_of_range& e) {
87065       {
87066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87067       };
87068     } catch (std::exception& e) {
87069       {
87070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87071       };
87072     } catch (...) {
87073       {
87074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87075       };
87076     }
87077   }
87078 }
87079
87080
87081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87082   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87083   int arg2 ;
87084   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87085
87086   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87087   arg2 = (int)jarg2;
87088   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87089   if (!arg3) {
87090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87091     return ;
87092   }
87093   {
87094     try {
87095       try {
87096         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);
87097       }
87098       catch(std::out_of_range &_e) {
87099         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87100         return ;
87101       }
87102
87103     } catch (std::out_of_range& e) {
87104       {
87105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87106       };
87107     } catch (std::exception& e) {
87108       {
87109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87110       };
87111     } catch (...) {
87112       {
87113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87114       };
87115     }
87116   }
87117 }
87118
87119
87120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
87121   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87122   int arg2 ;
87123
87124   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87125   arg2 = (int)jarg2;
87126   {
87127     try {
87128       try {
87129         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
87130       }
87131       catch(std::out_of_range &_e) {
87132         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87133         return ;
87134       }
87135
87136     } catch (std::out_of_range& e) {
87137       {
87138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87139       };
87140     } catch (std::exception& e) {
87141       {
87142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87143       };
87144     } catch (...) {
87145       {
87146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87147       };
87148     }
87149   }
87150 }
87151
87152
87153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87154   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87155   int arg2 ;
87156   int arg3 ;
87157
87158   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87159   arg2 = (int)jarg2;
87160   arg3 = (int)jarg3;
87161   {
87162     try {
87163       try {
87164         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
87165       }
87166       catch(std::out_of_range &_e) {
87167         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87168         return ;
87169       }
87170       catch(std::invalid_argument &_e) {
87171         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87172         return ;
87173       }
87174
87175     } catch (std::out_of_range& e) {
87176       {
87177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87178       };
87179     } catch (std::exception& e) {
87180       {
87181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87182       };
87183     } catch (...) {
87184       {
87185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87186       };
87187     }
87188   }
87189 }
87190
87191
87192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
87193   void * jresult ;
87194   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87195   int arg2 ;
87196   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87197
87198   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87199   if (!arg1) {
87200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87201     return 0;
87202   }
87203   arg2 = (int)jarg2;
87204   {
87205     try {
87206       try {
87207         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);
87208       }
87209       catch(std::out_of_range &_e) {
87210         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87211         return 0;
87212       }
87213
87214     } catch (std::out_of_range& e) {
87215       {
87216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87217       };
87218     } catch (std::exception& e) {
87219       {
87220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87221       };
87222     } catch (...) {
87223       {
87224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87225       };
87226     }
87227   }
87228   jresult = (void *)result;
87229   return jresult;
87230 }
87231
87232
87233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
87234   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87235
87236   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87237   {
87238     try {
87239       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
87240     } catch (std::out_of_range& e) {
87241       {
87242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87243       };
87244     } catch (std::exception& e) {
87245       {
87246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87247       };
87248     } catch (...) {
87249       {
87250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87251       };
87252     }
87253   }
87254 }
87255
87256
87257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87258   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87259   int arg2 ;
87260   int arg3 ;
87261
87262   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87263   arg2 = (int)jarg2;
87264   arg3 = (int)jarg3;
87265   {
87266     try {
87267       try {
87268         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87269       }
87270       catch(std::out_of_range &_e) {
87271         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87272         return ;
87273       }
87274       catch(std::invalid_argument &_e) {
87275         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87276         return ;
87277       }
87278
87279     } catch (std::out_of_range& e) {
87280       {
87281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87282       };
87283     } catch (std::exception& e) {
87284       {
87285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87286       };
87287     } catch (...) {
87288       {
87289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87290       };
87291     }
87292   }
87293 }
87294
87295
87296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87297   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87298   int arg2 ;
87299   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87300
87301   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87302   arg2 = (int)jarg2;
87303   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87304   if (!arg3) {
87305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87306     return ;
87307   }
87308   {
87309     try {
87310       try {
87311         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);
87312       }
87313       catch(std::out_of_range &_e) {
87314         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87315         return ;
87316       }
87317
87318     } catch (std::out_of_range& e) {
87319       {
87320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87321       };
87322     } catch (std::exception& e) {
87323       {
87324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87325       };
87326     } catch (...) {
87327       {
87328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87329       };
87330     }
87331   }
87332 }
87333
87334
87335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
87336   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87337
87338   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87339   {
87340     try {
87341       delete arg1;
87342     } catch (std::out_of_range& e) {
87343       {
87344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87345       };
87346     } catch (std::exception& e) {
87347       {
87348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87349       };
87350     } catch (...) {
87351       {
87352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87353       };
87354     }
87355   }
87356 }
87357
87358
87359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
87360   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87361
87362   arg1 = (std::vector< Dali::Actor > *)jarg1;
87363   {
87364     try {
87365       (arg1)->clear();
87366     } catch (std::out_of_range& e) {
87367       {
87368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87369       };
87370     } catch (std::exception& e) {
87371       {
87372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87373       };
87374     } catch (...) {
87375       {
87376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87377       };
87378     }
87379   }
87380 }
87381
87382
87383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
87384   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87385   Dali::Actor *arg2 = 0 ;
87386
87387   arg1 = (std::vector< Dali::Actor > *)jarg1;
87388   arg2 = (Dali::Actor *)jarg2;
87389   if (!arg2) {
87390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87391     return ;
87392   }
87393   {
87394     try {
87395       (arg1)->push_back((Dali::Actor const &)*arg2);
87396     } catch (std::out_of_range& e) {
87397       {
87398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87399       };
87400     } catch (std::exception& e) {
87401       {
87402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87403       };
87404     } catch (...) {
87405       {
87406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87407       };
87408     }
87409   }
87410 }
87411
87412
87413 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
87414   unsigned long jresult ;
87415   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87416   std::vector< Dali::Actor >::size_type result;
87417
87418   arg1 = (std::vector< Dali::Actor > *)jarg1;
87419   {
87420     try {
87421       result = ((std::vector< Dali::Actor > const *)arg1)->size();
87422     } catch (std::out_of_range& e) {
87423       {
87424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87425       };
87426     } catch (std::exception& e) {
87427       {
87428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87429       };
87430     } catch (...) {
87431       {
87432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87433       };
87434     }
87435   }
87436   jresult = (unsigned long)result;
87437   return jresult;
87438 }
87439
87440
87441 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
87442   unsigned long jresult ;
87443   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87444   std::vector< Dali::Actor >::size_type result;
87445
87446   arg1 = (std::vector< Dali::Actor > *)jarg1;
87447   {
87448     try {
87449       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
87450     } catch (std::out_of_range& e) {
87451       {
87452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87453       };
87454     } catch (std::exception& e) {
87455       {
87456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87457       };
87458     } catch (...) {
87459       {
87460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87461       };
87462     }
87463   }
87464   jresult = (unsigned long)result;
87465   return jresult;
87466 }
87467
87468
87469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
87470   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87471   std::vector< Dali::Actor >::size_type arg2 ;
87472
87473   arg1 = (std::vector< Dali::Actor > *)jarg1;
87474   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
87475   {
87476     try {
87477       (arg1)->reserve(arg2);
87478     } catch (std::out_of_range& e) {
87479       {
87480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87481       };
87482     } catch (std::exception& e) {
87483       {
87484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87485       };
87486     } catch (...) {
87487       {
87488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87489       };
87490     }
87491   }
87492 }
87493
87494
87495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
87496   void * jresult ;
87497   std::vector< Dali::Actor > *result = 0 ;
87498
87499   {
87500     try {
87501       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
87502     } catch (std::out_of_range& e) {
87503       {
87504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87505       };
87506     } catch (std::exception& e) {
87507       {
87508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87509       };
87510     } catch (...) {
87511       {
87512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87513       };
87514     }
87515   }
87516   jresult = (void *)result;
87517   return jresult;
87518 }
87519
87520
87521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
87522   void * jresult ;
87523   std::vector< Dali::Actor > *arg1 = 0 ;
87524   std::vector< Dali::Actor > *result = 0 ;
87525
87526   arg1 = (std::vector< Dali::Actor > *)jarg1;
87527   if (!arg1) {
87528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87529     return 0;
87530   }
87531   {
87532     try {
87533       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
87534     } catch (std::out_of_range& e) {
87535       {
87536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87537       };
87538     } catch (std::exception& e) {
87539       {
87540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87541       };
87542     } catch (...) {
87543       {
87544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87545       };
87546     }
87547   }
87548   jresult = (void *)result;
87549   return jresult;
87550 }
87551
87552
87553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
87554   void * jresult ;
87555   int arg1 ;
87556   std::vector< Dali::Actor > *result = 0 ;
87557
87558   arg1 = (int)jarg1;
87559   {
87560     try {
87561       try {
87562         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
87563       }
87564       catch(std::out_of_range &_e) {
87565         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87566         return 0;
87567       }
87568
87569     } catch (std::out_of_range& e) {
87570       {
87571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87572       };
87573     } catch (std::exception& e) {
87574       {
87575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87576       };
87577     } catch (...) {
87578       {
87579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87580       };
87581     }
87582   }
87583   jresult = (void *)result;
87584   return jresult;
87585 }
87586
87587
87588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
87589   void * jresult ;
87590   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87591   int arg2 ;
87592   Dali::Actor result;
87593
87594   arg1 = (std::vector< Dali::Actor > *)jarg1;
87595   arg2 = (int)jarg2;
87596   {
87597     try {
87598       try {
87599         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
87600       }
87601       catch(std::out_of_range &_e) {
87602         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87603         return 0;
87604       }
87605
87606     } catch (std::out_of_range& e) {
87607       {
87608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87609       };
87610     } catch (std::exception& e) {
87611       {
87612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87613       };
87614     } catch (...) {
87615       {
87616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87617       };
87618     }
87619   }
87620   jresult = new Dali::Actor((const Dali::Actor &)result);
87621   return jresult;
87622 }
87623
87624
87625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
87626   void * jresult ;
87627   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87628   int arg2 ;
87629   Dali::Actor *result = 0 ;
87630
87631   arg1 = (std::vector< Dali::Actor > *)jarg1;
87632   arg2 = (int)jarg2;
87633   {
87634     try {
87635       try {
87636         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
87637       }
87638       catch(std::out_of_range &_e) {
87639         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87640         return 0;
87641       }
87642
87643     } catch (std::out_of_range& e) {
87644       {
87645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87646       };
87647     } catch (std::exception& e) {
87648       {
87649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87650       };
87651     } catch (...) {
87652       {
87653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87654       };
87655     }
87656   }
87657   jresult = (void *)result;
87658   return jresult;
87659 }
87660
87661
87662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87663   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87664   int arg2 ;
87665   Dali::Actor *arg3 = 0 ;
87666
87667   arg1 = (std::vector< Dali::Actor > *)jarg1;
87668   arg2 = (int)jarg2;
87669   arg3 = (Dali::Actor *)jarg3;
87670   if (!arg3) {
87671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87672     return ;
87673   }
87674   {
87675     try {
87676       try {
87677         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
87678       }
87679       catch(std::out_of_range &_e) {
87680         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87681         return ;
87682       }
87683
87684     } catch (std::out_of_range& e) {
87685       {
87686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87687       };
87688     } catch (std::exception& e) {
87689       {
87690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87691       };
87692     } catch (...) {
87693       {
87694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87695       };
87696     }
87697   }
87698 }
87699
87700
87701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
87702   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87703   std::vector< Dali::Actor > *arg2 = 0 ;
87704
87705   arg1 = (std::vector< Dali::Actor > *)jarg1;
87706   arg2 = (std::vector< Dali::Actor > *)jarg2;
87707   if (!arg2) {
87708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87709     return ;
87710   }
87711   {
87712     try {
87713       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
87714     } catch (std::out_of_range& e) {
87715       {
87716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87717       };
87718     } catch (std::exception& e) {
87719       {
87720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87721       };
87722     } catch (...) {
87723       {
87724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87725       };
87726     }
87727   }
87728 }
87729
87730
87731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87732   void * jresult ;
87733   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87734   int arg2 ;
87735   int arg3 ;
87736   std::vector< Dali::Actor > *result = 0 ;
87737
87738   arg1 = (std::vector< Dali::Actor > *)jarg1;
87739   arg2 = (int)jarg2;
87740   arg3 = (int)jarg3;
87741   {
87742     try {
87743       try {
87744         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
87745       }
87746       catch(std::out_of_range &_e) {
87747         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87748         return 0;
87749       }
87750       catch(std::invalid_argument &_e) {
87751         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87752         return 0;
87753       }
87754
87755     } catch (std::out_of_range& e) {
87756       {
87757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87758       };
87759     } catch (std::exception& e) {
87760       {
87761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87762       };
87763     } catch (...) {
87764       {
87765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87766       };
87767     }
87768   }
87769   jresult = (void *)result;
87770   return jresult;
87771 }
87772
87773
87774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87775   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87776   int arg2 ;
87777   Dali::Actor *arg3 = 0 ;
87778
87779   arg1 = (std::vector< Dali::Actor > *)jarg1;
87780   arg2 = (int)jarg2;
87781   arg3 = (Dali::Actor *)jarg3;
87782   if (!arg3) {
87783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87784     return ;
87785   }
87786   {
87787     try {
87788       try {
87789         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
87790       }
87791       catch(std::out_of_range &_e) {
87792         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87793         return ;
87794       }
87795
87796     } catch (std::out_of_range& e) {
87797       {
87798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87799       };
87800     } catch (std::exception& e) {
87801       {
87802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87803       };
87804     } catch (...) {
87805       {
87806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87807       };
87808     }
87809   }
87810 }
87811
87812
87813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87814   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87815   int arg2 ;
87816   std::vector< Dali::Actor > *arg3 = 0 ;
87817
87818   arg1 = (std::vector< Dali::Actor > *)jarg1;
87819   arg2 = (int)jarg2;
87820   arg3 = (std::vector< Dali::Actor > *)jarg3;
87821   if (!arg3) {
87822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87823     return ;
87824   }
87825   {
87826     try {
87827       try {
87828         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
87829       }
87830       catch(std::out_of_range &_e) {
87831         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87832         return ;
87833       }
87834
87835     } catch (std::out_of_range& e) {
87836       {
87837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87838       };
87839     } catch (std::exception& e) {
87840       {
87841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87842       };
87843     } catch (...) {
87844       {
87845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87846       };
87847     }
87848   }
87849 }
87850
87851
87852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
87853   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87854   int arg2 ;
87855
87856   arg1 = (std::vector< Dali::Actor > *)jarg1;
87857   arg2 = (int)jarg2;
87858   {
87859     try {
87860       try {
87861         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
87862       }
87863       catch(std::out_of_range &_e) {
87864         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87865         return ;
87866       }
87867
87868     } catch (std::out_of_range& e) {
87869       {
87870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87871       };
87872     } catch (std::exception& e) {
87873       {
87874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87875       };
87876     } catch (...) {
87877       {
87878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87879       };
87880     }
87881   }
87882 }
87883
87884
87885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87886   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87887   int arg2 ;
87888   int arg3 ;
87889
87890   arg1 = (std::vector< Dali::Actor > *)jarg1;
87891   arg2 = (int)jarg2;
87892   arg3 = (int)jarg3;
87893   {
87894     try {
87895       try {
87896         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
87897       }
87898       catch(std::out_of_range &_e) {
87899         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87900         return ;
87901       }
87902       catch(std::invalid_argument &_e) {
87903         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87904         return ;
87905       }
87906
87907     } catch (std::out_of_range& e) {
87908       {
87909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87910       };
87911     } catch (std::exception& e) {
87912       {
87913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87914       };
87915     } catch (...) {
87916       {
87917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87918       };
87919     }
87920   }
87921 }
87922
87923
87924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
87925   void * jresult ;
87926   Dali::Actor *arg1 = 0 ;
87927   int arg2 ;
87928   std::vector< Dali::Actor > *result = 0 ;
87929
87930   arg1 = (Dali::Actor *)jarg1;
87931   if (!arg1) {
87932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87933     return 0;
87934   }
87935   arg2 = (int)jarg2;
87936   {
87937     try {
87938       try {
87939         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
87940       }
87941       catch(std::out_of_range &_e) {
87942         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87943         return 0;
87944       }
87945
87946     } catch (std::out_of_range& e) {
87947       {
87948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87949       };
87950     } catch (std::exception& e) {
87951       {
87952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87953       };
87954     } catch (...) {
87955       {
87956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87957       };
87958     }
87959   }
87960   jresult = (void *)result;
87961   return jresult;
87962 }
87963
87964
87965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
87966   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87967
87968   arg1 = (std::vector< Dali::Actor > *)jarg1;
87969   {
87970     try {
87971       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
87972     } catch (std::out_of_range& e) {
87973       {
87974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87975       };
87976     } catch (std::exception& e) {
87977       {
87978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87979       };
87980     } catch (...) {
87981       {
87982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87983       };
87984     }
87985   }
87986 }
87987
87988
87989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87990   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87991   int arg2 ;
87992   int arg3 ;
87993
87994   arg1 = (std::vector< Dali::Actor > *)jarg1;
87995   arg2 = (int)jarg2;
87996   arg3 = (int)jarg3;
87997   {
87998     try {
87999       try {
88000         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88001       }
88002       catch(std::out_of_range &_e) {
88003         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88004         return ;
88005       }
88006       catch(std::invalid_argument &_e) {
88007         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88008         return ;
88009       }
88010
88011     } catch (std::out_of_range& e) {
88012       {
88013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88014       };
88015     } catch (std::exception& e) {
88016       {
88017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88018       };
88019     } catch (...) {
88020       {
88021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88022       };
88023     }
88024   }
88025 }
88026
88027
88028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88029   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88030   int arg2 ;
88031   std::vector< Dali::Actor > *arg3 = 0 ;
88032
88033   arg1 = (std::vector< Dali::Actor > *)jarg1;
88034   arg2 = (int)jarg2;
88035   arg3 = (std::vector< Dali::Actor > *)jarg3;
88036   if (!arg3) {
88037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88038     return ;
88039   }
88040   {
88041     try {
88042       try {
88043         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88044       }
88045       catch(std::out_of_range &_e) {
88046         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88047         return ;
88048       }
88049
88050     } catch (std::out_of_range& e) {
88051       {
88052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88053       };
88054     } catch (std::exception& e) {
88055       {
88056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88057       };
88058     } catch (...) {
88059       {
88060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88061       };
88062     }
88063   }
88064 }
88065
88066
88067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
88068   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88069
88070   arg1 = (std::vector< Dali::Actor > *)jarg1;
88071   {
88072     try {
88073       delete arg1;
88074     } catch (std::out_of_range& e) {
88075       {
88076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88077       };
88078     } catch (std::exception& e) {
88079       {
88080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88081       };
88082     } catch (...) {
88083       {
88084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88085       };
88086     }
88087   }
88088 }
88089
88090
88091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
88092   unsigned int jresult ;
88093   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88094   bool result;
88095
88096   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88097   {
88098     try {
88099       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88100     } catch (std::out_of_range& e) {
88101       {
88102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88103       };
88104     } catch (std::exception& e) {
88105       {
88106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88107       };
88108     } catch (...) {
88109       {
88110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88111       };
88112     }
88113   }
88114   jresult = result;
88115   return jresult;
88116 }
88117
88118
88119 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
88120   unsigned long jresult ;
88121   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88122   std::size_t result;
88123
88124   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88125   {
88126     try {
88127       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88128     } catch (std::out_of_range& e) {
88129       {
88130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88131       };
88132     } catch (std::exception& e) {
88133       {
88134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88135       };
88136     } catch (...) {
88137       {
88138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88139       };
88140     }
88141   }
88142   jresult = (unsigned long)result;
88143   return jresult;
88144 }
88145
88146
88147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
88148   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88149   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88150
88151   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88152   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88153   {
88154     try {
88155       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
88156     } catch (std::out_of_range& e) {
88157       {
88158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88159       };
88160     } catch (std::exception& e) {
88161       {
88162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88163       };
88164     } catch (...) {
88165       {
88166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88167       };
88168     }
88169   }
88170 }
88171
88172
88173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
88174   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88175   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88176
88177   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88178   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88179   {
88180     try {
88181       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
88182     } catch (std::out_of_range& e) {
88183       {
88184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88185       };
88186     } catch (std::exception& e) {
88187       {
88188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88189       };
88190     } catch (...) {
88191       {
88192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88193       };
88194     }
88195   }
88196 }
88197
88198
88199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
88200   unsigned int jresult ;
88201   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88202   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
88203   bool result;
88204
88205   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88206   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
88207   if (!arg2) {
88208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
88209     return 0;
88210   }
88211   {
88212     try {
88213       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
88214     } catch (std::out_of_range& e) {
88215       {
88216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88217       };
88218     } catch (std::exception& e) {
88219       {
88220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88221       };
88222     } catch (...) {
88223       {
88224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88225       };
88226     }
88227   }
88228   jresult = result;
88229   return jresult;
88230 }
88231
88232
88233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
88234   void * jresult ;
88235   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
88236
88237   {
88238     try {
88239       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
88240     } catch (std::out_of_range& e) {
88241       {
88242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88243       };
88244     } catch (std::exception& e) {
88245       {
88246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88247       };
88248     } catch (...) {
88249       {
88250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88251       };
88252     }
88253   }
88254   jresult = (void *)result;
88255   return jresult;
88256 }
88257
88258
88259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
88260   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88261
88262   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88263   {
88264     try {
88265       delete arg1;
88266     } catch (std::out_of_range& e) {
88267       {
88268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88269       };
88270     } catch (std::exception& e) {
88271       {
88272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88273       };
88274     } catch (...) {
88275       {
88276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88277       };
88278     }
88279   }
88280 }
88281
88282
88283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
88284   unsigned int jresult ;
88285   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88286   bool result;
88287
88288   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88289   {
88290     try {
88291       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);
88292     } catch (std::out_of_range& e) {
88293       {
88294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88295       };
88296     } catch (std::exception& e) {
88297       {
88298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88299       };
88300     } catch (...) {
88301       {
88302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88303       };
88304     }
88305   }
88306   jresult = result;
88307   return jresult;
88308 }
88309
88310
88311 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
88312   unsigned long jresult ;
88313   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88314   std::size_t result;
88315
88316   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88317   {
88318     try {
88319       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);
88320     } catch (std::out_of_range& e) {
88321       {
88322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88323       };
88324     } catch (std::exception& e) {
88325       {
88326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88327       };
88328     } catch (...) {
88329       {
88330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88331       };
88332     }
88333   }
88334   jresult = (unsigned long)result;
88335   return jresult;
88336 }
88337
88338
88339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
88340   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88341   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88342
88343   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88344   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88345   {
88346     try {
88347       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
88348     } catch (std::out_of_range& e) {
88349       {
88350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88351       };
88352     } catch (std::exception& e) {
88353       {
88354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88355       };
88356     } catch (...) {
88357       {
88358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88359       };
88360     }
88361   }
88362 }
88363
88364
88365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
88366   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88367   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88368
88369   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88370   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88371   {
88372     try {
88373       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
88374     } catch (std::out_of_range& e) {
88375       {
88376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88377       };
88378     } catch (std::exception& e) {
88379       {
88380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88381       };
88382     } catch (...) {
88383       {
88384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88385       };
88386     }
88387   }
88388 }
88389
88390
88391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88392   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88393   Dali::Actor arg2 ;
88394   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
88395   Dali::Actor *argp2 ;
88396
88397   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88398   argp2 = (Dali::Actor *)jarg2;
88399   if (!argp2) {
88400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88401     return ;
88402   }
88403   arg2 = *argp2;
88404   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
88405   {
88406     try {
88407       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
88408     } catch (std::out_of_range& e) {
88409       {
88410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88411       };
88412     } catch (std::exception& e) {
88413       {
88414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88415       };
88416     } catch (...) {
88417       {
88418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88419       };
88420     }
88421   }
88422 }
88423
88424
88425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
88426   void * jresult ;
88427   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
88428
88429   {
88430     try {
88431       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
88432     } catch (std::out_of_range& e) {
88433       {
88434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88435       };
88436     } catch (std::exception& e) {
88437       {
88438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88439       };
88440     } catch (...) {
88441       {
88442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88443       };
88444     }
88445   }
88446   jresult = (void *)result;
88447   return jresult;
88448 }
88449
88450
88451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
88452   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88453
88454   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88455   {
88456     try {
88457       delete arg1;
88458     } catch (std::out_of_range& e) {
88459       {
88460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88461       };
88462     } catch (std::exception& e) {
88463       {
88464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88465       };
88466     } catch (...) {
88467       {
88468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88469       };
88470     }
88471   }
88472 }
88473
88474
88475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
88476   unsigned int jresult ;
88477   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88478   bool result;
88479
88480   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88481   {
88482     try {
88483       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88484     } catch (std::out_of_range& e) {
88485       {
88486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88487       };
88488     } catch (std::exception& e) {
88489       {
88490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88491       };
88492     } catch (...) {
88493       {
88494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88495       };
88496     }
88497   }
88498   jresult = result;
88499   return jresult;
88500 }
88501
88502
88503 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
88504   unsigned long jresult ;
88505   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88506   std::size_t result;
88507
88508   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88509   {
88510     try {
88511       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88512     } catch (std::out_of_range& e) {
88513       {
88514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88515       };
88516     } catch (std::exception& e) {
88517       {
88518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88519       };
88520     } catch (...) {
88521       {
88522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88523       };
88524     }
88525   }
88526   jresult = (unsigned long)result;
88527   return jresult;
88528 }
88529
88530
88531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
88532   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88533   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88534
88535   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88536   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88537   {
88538     try {
88539       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
88540     } catch (std::out_of_range& e) {
88541       {
88542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88543       };
88544     } catch (std::exception& e) {
88545       {
88546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88547       };
88548     } catch (...) {
88549       {
88550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88551       };
88552     }
88553   }
88554 }
88555
88556
88557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88558   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88559   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88560
88561   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88562   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88563   {
88564     try {
88565       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
88566     } catch (std::out_of_range& e) {
88567       {
88568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88569       };
88570     } catch (std::exception& e) {
88571       {
88572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88573       };
88574     } catch (...) {
88575       {
88576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88577       };
88578     }
88579   }
88580 }
88581
88582
88583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
88584   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88585   Dali::Actor arg2 ;
88586   Dali::Actor arg3 ;
88587   Dali::Actor *argp2 ;
88588   Dali::Actor *argp3 ;
88589
88590   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88591   argp2 = (Dali::Actor *)jarg2;
88592   if (!argp2) {
88593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88594     return ;
88595   }
88596   arg2 = *argp2;
88597   argp3 = (Dali::Actor *)jarg3;
88598   if (!argp3) {
88599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88600     return ;
88601   }
88602   arg3 = *argp3;
88603   {
88604     try {
88605       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
88606     } catch (std::out_of_range& e) {
88607       {
88608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88609       };
88610     } catch (std::exception& e) {
88611       {
88612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88613       };
88614     } catch (...) {
88615       {
88616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88617       };
88618     }
88619   }
88620 }
88621
88622
88623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
88624   void * jresult ;
88625   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
88626
88627   {
88628     try {
88629       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
88630     } catch (std::out_of_range& e) {
88631       {
88632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88633       };
88634     } catch (std::exception& e) {
88635       {
88636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88637       };
88638     } catch (...) {
88639       {
88640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88641       };
88642     }
88643   }
88644   jresult = (void *)result;
88645   return jresult;
88646 }
88647
88648
88649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
88650   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88651
88652   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88653   {
88654     try {
88655       delete arg1;
88656     } catch (std::out_of_range& e) {
88657       {
88658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88659       };
88660     } catch (std::exception& e) {
88661       {
88662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88663       };
88664     } catch (...) {
88665       {
88666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88667       };
88668     }
88669   }
88670 }
88671
88672
88673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
88674   unsigned int jresult ;
88675   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88676   bool result;
88677
88678   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88679   {
88680     try {
88681       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88682     } catch (std::out_of_range& e) {
88683       {
88684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88685       };
88686     } catch (std::exception& e) {
88687       {
88688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88689       };
88690     } catch (...) {
88691       {
88692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88693       };
88694     }
88695   }
88696   jresult = result;
88697   return jresult;
88698 }
88699
88700
88701 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
88702   unsigned long jresult ;
88703   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88704   std::size_t result;
88705
88706   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88707   {
88708     try {
88709       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88710     } catch (std::out_of_range& e) {
88711       {
88712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88713       };
88714     } catch (std::exception& e) {
88715       {
88716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88717       };
88718     } catch (...) {
88719       {
88720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88721       };
88722     }
88723   }
88724   jresult = (unsigned long)result;
88725   return jresult;
88726 }
88727
88728
88729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
88730   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88731   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88732
88733   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88734   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88735   {
88736     try {
88737       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
88738     } catch (std::out_of_range& e) {
88739       {
88740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88741       };
88742     } catch (std::exception& e) {
88743       {
88744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88745       };
88746     } catch (...) {
88747       {
88748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88749       };
88750     }
88751   }
88752 }
88753
88754
88755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88756   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88757   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88758
88759   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88760   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88761   {
88762     try {
88763       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
88764     } catch (std::out_of_range& e) {
88765       {
88766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88767       };
88768     } catch (std::exception& e) {
88769       {
88770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88771       };
88772     } catch (...) {
88773       {
88774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88775       };
88776     }
88777   }
88778 }
88779
88780
88781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
88782   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88783   Dali::Actor arg2 ;
88784   bool arg3 ;
88785   Dali::Actor *argp2 ;
88786
88787   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88788   argp2 = (Dali::Actor *)jarg2;
88789   if (!argp2) {
88790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88791     return ;
88792   }
88793   arg2 = *argp2;
88794   arg3 = jarg3 ? true : false;
88795   {
88796     try {
88797       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
88798     } catch (std::out_of_range& e) {
88799       {
88800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88801       };
88802     } catch (std::exception& e) {
88803       {
88804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88805       };
88806     } catch (...) {
88807       {
88808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88809       };
88810     }
88811   }
88812 }
88813
88814
88815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
88816   void * jresult ;
88817   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
88818
88819   {
88820     try {
88821       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
88822     } catch (std::out_of_range& e) {
88823       {
88824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88825       };
88826     } catch (std::exception& e) {
88827       {
88828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88829       };
88830     } catch (...) {
88831       {
88832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88833       };
88834     }
88835   }
88836   jresult = (void *)result;
88837   return jresult;
88838 }
88839
88840
88841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
88842   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88843
88844   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88845   {
88846     try {
88847       delete arg1;
88848     } catch (std::out_of_range& e) {
88849       {
88850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88851       };
88852     } catch (std::exception& e) {
88853       {
88854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88855       };
88856     } catch (...) {
88857       {
88858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88859       };
88860     }
88861   }
88862 }
88863
88864
88865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
88866   unsigned int jresult ;
88867   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88868   bool result;
88869
88870   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88871   {
88872     try {
88873       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);
88874     } catch (std::out_of_range& e) {
88875       {
88876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88877       };
88878     } catch (std::exception& e) {
88879       {
88880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88881       };
88882     } catch (...) {
88883       {
88884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88885       };
88886     }
88887   }
88888   jresult = result;
88889   return jresult;
88890 }
88891
88892
88893 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
88894   unsigned long jresult ;
88895   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88896   std::size_t result;
88897
88898   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88899   {
88900     try {
88901       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);
88902     } catch (std::out_of_range& e) {
88903       {
88904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88905       };
88906     } catch (std::exception& e) {
88907       {
88908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88909       };
88910     } catch (...) {
88911       {
88912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88913       };
88914     }
88915   }
88916   jresult = (unsigned long)result;
88917   return jresult;
88918 }
88919
88920
88921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
88922   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88923   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
88924
88925   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88926   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
88927   {
88928     try {
88929       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
88930     } catch (std::out_of_range& e) {
88931       {
88932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88933       };
88934     } catch (std::exception& e) {
88935       {
88936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88937       };
88938     } catch (...) {
88939       {
88940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88941       };
88942     }
88943   }
88944 }
88945
88946
88947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88948   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88949   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
88950
88951   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88952   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
88953   {
88954     try {
88955       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
88956     } catch (std::out_of_range& e) {
88957       {
88958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88959       };
88960     } catch (std::exception& e) {
88961       {
88962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88963       };
88964     } catch (...) {
88965       {
88966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88967       };
88968     }
88969   }
88970 }
88971
88972
88973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88974   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88975   Dali::Toolkit::StyleManager arg2 ;
88976   Dali::StyleChange::Type arg3 ;
88977   Dali::Toolkit::StyleManager *argp2 ;
88978
88979   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88980   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
88981   if (!argp2) {
88982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
88983     return ;
88984   }
88985   arg2 = *argp2;
88986   arg3 = (Dali::StyleChange::Type)jarg3;
88987   {
88988     try {
88989       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
88990     } catch (std::out_of_range& e) {
88991       {
88992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88993       };
88994     } catch (std::exception& e) {
88995       {
88996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88997       };
88998     } catch (...) {
88999       {
89000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89001       };
89002     }
89003   }
89004 }
89005
89006
89007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
89008   void * jresult ;
89009   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
89010
89011   {
89012     try {
89013       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
89014     } catch (std::out_of_range& e) {
89015       {
89016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89017       };
89018     } catch (std::exception& e) {
89019       {
89020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89021       };
89022     } catch (...) {
89023       {
89024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89025       };
89026     }
89027   }
89028   jresult = (void *)result;
89029   return jresult;
89030 }
89031
89032
89033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
89034   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89035
89036   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89037   {
89038     try {
89039       delete arg1;
89040     } catch (std::out_of_range& e) {
89041       {
89042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89043       };
89044     } catch (std::exception& e) {
89045       {
89046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89047       };
89048     } catch (...) {
89049       {
89050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89051       };
89052     }
89053   }
89054 }
89055
89056
89057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
89058   unsigned int jresult ;
89059   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89060   bool result;
89061
89062   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89063   {
89064     try {
89065       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89066     } catch (std::out_of_range& e) {
89067       {
89068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89069       };
89070     } catch (std::exception& e) {
89071       {
89072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89073       };
89074     } catch (...) {
89075       {
89076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89077       };
89078     }
89079   }
89080   jresult = result;
89081   return jresult;
89082 }
89083
89084
89085 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
89086   unsigned long jresult ;
89087   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89088   std::size_t result;
89089
89090   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89091   {
89092     try {
89093       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89094     } catch (std::out_of_range& e) {
89095       {
89096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89097       };
89098     } catch (std::exception& e) {
89099       {
89100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89101       };
89102     } catch (...) {
89103       {
89104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89105       };
89106     }
89107   }
89108   jresult = (unsigned long)result;
89109   return jresult;
89110 }
89111
89112
89113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
89114   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89115   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89116
89117   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89118   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89119   {
89120     try {
89121       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
89122     } catch (std::out_of_range& e) {
89123       {
89124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89125       };
89126     } catch (std::exception& e) {
89127       {
89128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89129       };
89130     } catch (...) {
89131       {
89132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89133       };
89134     }
89135   }
89136 }
89137
89138
89139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
89140   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89141   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89142
89143   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89144   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89145   {
89146     try {
89147       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
89148     } catch (std::out_of_range& e) {
89149       {
89150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89151       };
89152     } catch (std::exception& e) {
89153       {
89154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89155       };
89156     } catch (...) {
89157       {
89158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89159       };
89160     }
89161   }
89162 }
89163
89164
89165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
89166   unsigned int jresult ;
89167   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89168   Dali::Toolkit::Button arg2 ;
89169   Dali::Toolkit::Button *argp2 ;
89170   bool result;
89171
89172   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89173   argp2 = (Dali::Toolkit::Button *)jarg2;
89174   if (!argp2) {
89175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
89176     return 0;
89177   }
89178   arg2 = *argp2;
89179   {
89180     try {
89181       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
89182     } catch (std::out_of_range& e) {
89183       {
89184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89185       };
89186     } catch (std::exception& e) {
89187       {
89188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89189       };
89190     } catch (...) {
89191       {
89192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89193       };
89194     }
89195   }
89196   jresult = result;
89197   return jresult;
89198 }
89199
89200
89201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
89202   void * jresult ;
89203   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
89204
89205   {
89206     try {
89207       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
89208     } catch (std::out_of_range& e) {
89209       {
89210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89211       };
89212     } catch (std::exception& e) {
89213       {
89214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89215       };
89216     } catch (...) {
89217       {
89218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89219       };
89220     }
89221   }
89222   jresult = (void *)result;
89223   return jresult;
89224 }
89225
89226
89227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
89228   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89229
89230   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89231   {
89232     try {
89233       delete arg1;
89234     } catch (std::out_of_range& e) {
89235       {
89236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89237       };
89238     } catch (std::exception& e) {
89239       {
89240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89241       };
89242     } catch (...) {
89243       {
89244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89245       };
89246     }
89247   }
89248 }
89249
89250
89251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
89252   unsigned int jresult ;
89253   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89254   bool result;
89255
89256   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89257   {
89258     try {
89259       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89260     } catch (std::out_of_range& e) {
89261       {
89262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89263       };
89264     } catch (std::exception& e) {
89265       {
89266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89267       };
89268     } catch (...) {
89269       {
89270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89271       };
89272     }
89273   }
89274   jresult = result;
89275   return jresult;
89276 }
89277
89278
89279 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
89280   unsigned long jresult ;
89281   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89282   std::size_t result;
89283
89284   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89285   {
89286     try {
89287       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89288     } catch (std::out_of_range& e) {
89289       {
89290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89291       };
89292     } catch (std::exception& e) {
89293       {
89294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89295       };
89296     } catch (...) {
89297       {
89298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89299       };
89300     }
89301   }
89302   jresult = (unsigned long)result;
89303   return jresult;
89304 }
89305
89306
89307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
89308   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89309   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89310
89311   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89312   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89313   {
89314     try {
89315       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
89316     } catch (std::out_of_range& e) {
89317       {
89318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89319       };
89320     } catch (std::exception& e) {
89321       {
89322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89323       };
89324     } catch (...) {
89325       {
89326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89327       };
89328     }
89329   }
89330 }
89331
89332
89333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
89334   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89335   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89336
89337   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89338   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89339   {
89340     try {
89341       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
89342     } catch (std::out_of_range& e) {
89343       {
89344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89345       };
89346     } catch (std::exception& e) {
89347       {
89348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89349       };
89350     } catch (...) {
89351       {
89352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89353       };
89354     }
89355   }
89356 }
89357
89358
89359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
89360   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89361   Dali::Toolkit::GaussianBlurView arg2 ;
89362   Dali::Toolkit::GaussianBlurView *argp2 ;
89363
89364   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89365   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89366   if (!argp2) {
89367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
89368     return ;
89369   }
89370   arg2 = *argp2;
89371   {
89372     try {
89373       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
89374     } catch (std::out_of_range& e) {
89375       {
89376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89377       };
89378     } catch (std::exception& e) {
89379       {
89380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89381       };
89382     } catch (...) {
89383       {
89384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89385       };
89386     }
89387   }
89388 }
89389
89390
89391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
89392   void * jresult ;
89393   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
89394
89395   {
89396     try {
89397       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
89398     } catch (std::out_of_range& e) {
89399       {
89400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89401       };
89402     } catch (std::exception& e) {
89403       {
89404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89405       };
89406     } catch (...) {
89407       {
89408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89409       };
89410     }
89411   }
89412   jresult = (void *)result;
89413   return jresult;
89414 }
89415
89416
89417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
89418   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89419
89420   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89421   {
89422     try {
89423       delete arg1;
89424     } catch (std::out_of_range& e) {
89425       {
89426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89427       };
89428     } catch (std::exception& e) {
89429       {
89430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89431       };
89432     } catch (...) {
89433       {
89434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89435       };
89436     }
89437   }
89438 }
89439
89440
89441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
89442   unsigned int jresult ;
89443   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89444   bool result;
89445
89446   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89447   {
89448     try {
89449       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);
89450     } catch (std::out_of_range& e) {
89451       {
89452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89453       };
89454     } catch (std::exception& e) {
89455       {
89456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89457       };
89458     } catch (...) {
89459       {
89460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89461       };
89462     }
89463   }
89464   jresult = result;
89465   return jresult;
89466 }
89467
89468
89469 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
89470   unsigned long jresult ;
89471   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89472   std::size_t result;
89473
89474   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89475   {
89476     try {
89477       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);
89478     } catch (std::out_of_range& e) {
89479       {
89480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89481       };
89482     } catch (std::exception& e) {
89483       {
89484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89485       };
89486     } catch (...) {
89487       {
89488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89489       };
89490     }
89491   }
89492   jresult = (unsigned long)result;
89493   return jresult;
89494 }
89495
89496
89497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
89498   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89499   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89500
89501   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89502   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89503   {
89504     try {
89505       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
89506     } catch (std::out_of_range& e) {
89507       {
89508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89509       };
89510     } catch (std::exception& e) {
89511       {
89512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89513       };
89514     } catch (...) {
89515       {
89516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89517       };
89518     }
89519   }
89520 }
89521
89522
89523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
89524   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89525   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89526
89527   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89528   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89529   {
89530     try {
89531       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89532     } catch (std::out_of_range& e) {
89533       {
89534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89535       };
89536     } catch (std::exception& e) {
89537       {
89538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89539       };
89540     } catch (...) {
89541       {
89542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89543       };
89544     }
89545   }
89546 }
89547
89548
89549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
89550   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89551   Dali::Toolkit::PageTurnView arg2 ;
89552   unsigned int arg3 ;
89553   bool arg4 ;
89554   Dali::Toolkit::PageTurnView *argp2 ;
89555
89556   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89557   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89558   if (!argp2) {
89559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89560     return ;
89561   }
89562   arg2 = *argp2;
89563   arg3 = (unsigned int)jarg3;
89564   arg4 = jarg4 ? true : false;
89565   {
89566     try {
89567       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89568     } catch (std::out_of_range& e) {
89569       {
89570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89571       };
89572     } catch (std::exception& e) {
89573       {
89574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89575       };
89576     } catch (...) {
89577       {
89578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89579       };
89580     }
89581   }
89582 }
89583
89584
89585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
89586   void * jresult ;
89587   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
89588
89589   {
89590     try {
89591       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
89592     } catch (std::out_of_range& e) {
89593       {
89594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89595       };
89596     } catch (std::exception& e) {
89597       {
89598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89599       };
89600     } catch (...) {
89601       {
89602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89603       };
89604     }
89605   }
89606   jresult = (void *)result;
89607   return jresult;
89608 }
89609
89610
89611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
89612   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89613
89614   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89615   {
89616     try {
89617       delete arg1;
89618     } catch (std::out_of_range& e) {
89619       {
89620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89621       };
89622     } catch (std::exception& e) {
89623       {
89624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89625       };
89626     } catch (...) {
89627       {
89628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89629       };
89630     }
89631   }
89632 }
89633
89634
89635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
89636   unsigned int jresult ;
89637   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89638   bool result;
89639
89640   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89641   {
89642     try {
89643       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89644     } catch (std::out_of_range& e) {
89645       {
89646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89647       };
89648     } catch (std::exception& e) {
89649       {
89650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89651       };
89652     } catch (...) {
89653       {
89654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89655       };
89656     }
89657   }
89658   jresult = result;
89659   return jresult;
89660 }
89661
89662
89663 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
89664   unsigned long jresult ;
89665   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89666   std::size_t result;
89667
89668   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89669   {
89670     try {
89671       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89672     } catch (std::out_of_range& e) {
89673       {
89674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89675       };
89676     } catch (std::exception& e) {
89677       {
89678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89679       };
89680     } catch (...) {
89681       {
89682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89683       };
89684     }
89685   }
89686   jresult = (unsigned long)result;
89687   return jresult;
89688 }
89689
89690
89691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
89692   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89693   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89694
89695   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89696   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89697   {
89698     try {
89699       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
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_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
89718   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89719   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89720
89721   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89722   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89723   {
89724     try {
89725       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
89726     } catch (std::out_of_range& e) {
89727       {
89728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89729       };
89730     } catch (std::exception& e) {
89731       {
89732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89733       };
89734     } catch (...) {
89735       {
89736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89737       };
89738     }
89739   }
89740 }
89741
89742
89743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
89744   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89745   Dali::Toolkit::PageTurnView arg2 ;
89746   Dali::Toolkit::PageTurnView *argp2 ;
89747
89748   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89749   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89750   if (!argp2) {
89751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89752     return ;
89753   }
89754   arg2 = *argp2;
89755   {
89756     try {
89757       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
89758     } catch (std::out_of_range& e) {
89759       {
89760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89761       };
89762     } catch (std::exception& e) {
89763       {
89764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89765       };
89766     } catch (...) {
89767       {
89768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89769       };
89770     }
89771   }
89772 }
89773
89774
89775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
89776   void * jresult ;
89777   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
89778
89779   {
89780     try {
89781       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
89782     } catch (std::out_of_range& e) {
89783       {
89784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89785       };
89786     } catch (std::exception& e) {
89787       {
89788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89789       };
89790     } catch (...) {
89791       {
89792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89793       };
89794     }
89795   }
89796   jresult = (void *)result;
89797   return jresult;
89798 }
89799
89800
89801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
89802   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89803
89804   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89805   {
89806     try {
89807       delete arg1;
89808     } catch (std::out_of_range& e) {
89809       {
89810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89811       };
89812     } catch (std::exception& e) {
89813       {
89814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89815       };
89816     } catch (...) {
89817       {
89818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89819       };
89820     }
89821   }
89822 }
89823
89824
89825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
89826   unsigned int jresult ;
89827   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89828   bool result;
89829
89830   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89831   {
89832     try {
89833       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *)arg1);
89834     } catch (std::out_of_range& e) {
89835       {
89836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89837       };
89838     } catch (std::exception& e) {
89839       {
89840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89841       };
89842     } catch (...) {
89843       {
89844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89845       };
89846     }
89847   }
89848   jresult = result;
89849   return jresult;
89850 }
89851
89852
89853 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
89854   unsigned long jresult ;
89855   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89856   std::size_t result;
89857
89858   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89859   {
89860     try {
89861       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > const *)arg1);
89862     } catch (std::out_of_range& e) {
89863       {
89864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89865       };
89866     } catch (std::exception& e) {
89867       {
89868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89869       };
89870     } catch (...) {
89871       {
89872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89873       };
89874     }
89875   }
89876   jresult = (unsigned long)result;
89877   return jresult;
89878 }
89879
89880
89881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
89882   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89883   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
89884
89885   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89886   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
89887   {
89888     try {
89889       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
89890     } catch (std::out_of_range& e) {
89891       {
89892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89893       };
89894     } catch (std::exception& e) {
89895       {
89896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89897       };
89898     } catch (...) {
89899       {
89900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89901       };
89902     }
89903   }
89904 }
89905
89906
89907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89908   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89909   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
89910
89911   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89912   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
89913   {
89914     try {
89915       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
89916     } catch (std::out_of_range& e) {
89917       {
89918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89919       };
89920     } catch (std::exception& e) {
89921       {
89922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89923       };
89924     } catch (...) {
89925       {
89926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89927       };
89928     }
89929   }
89930 }
89931
89932
89933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
89934   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89935   Dali::Toolkit::ProgressBar arg2 ;
89936   float arg3 ;
89937   float arg4 ;
89938   Dali::Toolkit::ProgressBar *argp2 ;
89939
89940   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89941   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
89942   if (!argp2) {
89943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
89944     return ;
89945   }
89946   arg2 = *argp2;
89947   arg3 = (float)jarg3;
89948   arg4 = (float)jarg4;
89949   {
89950     try {
89951       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89952     } catch (std::out_of_range& e) {
89953       {
89954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89955       };
89956     } catch (std::exception& e) {
89957       {
89958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89959       };
89960     } catch (...) {
89961       {
89962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89963       };
89964     }
89965   }
89966 }
89967
89968
89969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
89970   void * jresult ;
89971   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
89972
89973   {
89974     try {
89975       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
89976     } catch (std::out_of_range& e) {
89977       {
89978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89979       };
89980     } catch (std::exception& e) {
89981       {
89982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89983       };
89984     } catch (...) {
89985       {
89986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89987       };
89988     }
89989   }
89990   jresult = (void *)result;
89991   return jresult;
89992 }
89993
89994
89995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
89996   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89997
89998   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89999   {
90000     try {
90001       delete arg1;
90002     } catch (std::out_of_range& e) {
90003       {
90004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90005       };
90006     } catch (std::exception& e) {
90007       {
90008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90009       };
90010     } catch (...) {
90011       {
90012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90013       };
90014     }
90015   }
90016 }
90017
90018
90019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
90020   unsigned int jresult ;
90021   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90022   bool result;
90023
90024   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90025   {
90026     try {
90027       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);
90028     } catch (std::out_of_range& e) {
90029       {
90030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90031       };
90032     } catch (std::exception& e) {
90033       {
90034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90035       };
90036     } catch (...) {
90037       {
90038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90039       };
90040     }
90041   }
90042   jresult = result;
90043   return jresult;
90044 }
90045
90046
90047 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
90048   unsigned long jresult ;
90049   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90050   std::size_t result;
90051
90052   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90053   {
90054     try {
90055       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);
90056     } catch (std::out_of_range& e) {
90057       {
90058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90059       };
90060     } catch (std::exception& e) {
90061       {
90062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90063       };
90064     } catch (...) {
90065       {
90066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90067       };
90068     }
90069   }
90070   jresult = (unsigned long)result;
90071   return jresult;
90072 }
90073
90074
90075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
90076   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90077   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90078
90079   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90080   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90081   {
90082     try {
90083       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
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_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
90102   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90103   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90104
90105   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90106   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90107   {
90108     try {
90109       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90110     } catch (std::out_of_range& e) {
90111       {
90112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90113       };
90114     } catch (std::exception& e) {
90115       {
90116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90117       };
90118     } catch (...) {
90119       {
90120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90121       };
90122     }
90123   }
90124 }
90125
90126
90127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
90128   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90129   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
90130
90131   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90132   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
90133   if (!arg2) {
90134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
90135     return ;
90136   }
90137   {
90138     try {
90139       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
90140     } catch (std::out_of_range& e) {
90141       {
90142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90143       };
90144     } catch (std::exception& e) {
90145       {
90146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90147       };
90148     } catch (...) {
90149       {
90150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90151       };
90152     }
90153   }
90154 }
90155
90156
90157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
90158   void * jresult ;
90159   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
90160
90161   {
90162     try {
90163       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
90164     } catch (std::out_of_range& e) {
90165       {
90166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90167       };
90168     } catch (std::exception& e) {
90169       {
90170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90171       };
90172     } catch (...) {
90173       {
90174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90175       };
90176     }
90177   }
90178   jresult = (void *)result;
90179   return jresult;
90180 }
90181
90182
90183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
90184   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90185
90186   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90187   {
90188     try {
90189       delete arg1;
90190     } catch (std::out_of_range& e) {
90191       {
90192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90193       };
90194     } catch (std::exception& e) {
90195       {
90196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90197       };
90198     } catch (...) {
90199       {
90200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90201       };
90202     }
90203   }
90204 }
90205
90206
90207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
90208   unsigned int jresult ;
90209   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90210   bool result;
90211
90212   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90213   {
90214     try {
90215       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90216     } catch (std::out_of_range& e) {
90217       {
90218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90219       };
90220     } catch (std::exception& e) {
90221       {
90222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90223       };
90224     } catch (...) {
90225       {
90226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90227       };
90228     }
90229   }
90230   jresult = result;
90231   return jresult;
90232 }
90233
90234
90235 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
90236   unsigned long jresult ;
90237   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90238   std::size_t result;
90239
90240   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90241   {
90242     try {
90243       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90244     } catch (std::out_of_range& e) {
90245       {
90246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90247       };
90248     } catch (std::exception& e) {
90249       {
90250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90251       };
90252     } catch (...) {
90253       {
90254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90255       };
90256     }
90257   }
90258   jresult = (unsigned long)result;
90259   return jresult;
90260 }
90261
90262
90263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
90264   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90265   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90266
90267   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90268   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90269   {
90270     try {
90271       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90272     } catch (std::out_of_range& e) {
90273       {
90274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90275       };
90276     } catch (std::exception& e) {
90277       {
90278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90279       };
90280     } catch (...) {
90281       {
90282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90283       };
90284     }
90285   }
90286 }
90287
90288
90289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
90290   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90291   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90292
90293   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90294   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90295   {
90296     try {
90297       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90298     } catch (std::out_of_range& e) {
90299       {
90300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90301       };
90302     } catch (std::exception& e) {
90303       {
90304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90305       };
90306     } catch (...) {
90307       {
90308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90309       };
90310     }
90311   }
90312 }
90313
90314
90315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
90316   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90317   Dali::Vector2 *arg2 = 0 ;
90318
90319   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90320   arg2 = (Dali::Vector2 *)jarg2;
90321   if (!arg2) {
90322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90323     return ;
90324   }
90325   {
90326     try {
90327       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
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 void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
90346   void * jresult ;
90347   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
90348
90349   {
90350     try {
90351       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
90352     } catch (std::out_of_range& e) {
90353       {
90354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90355       };
90356     } catch (std::exception& e) {
90357       {
90358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90359       };
90360     } catch (...) {
90361       {
90362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90363       };
90364     }
90365   }
90366   jresult = (void *)result;
90367   return jresult;
90368 }
90369
90370
90371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
90372   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90373
90374   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90375   {
90376     try {
90377       delete arg1;
90378     } catch (std::out_of_range& e) {
90379       {
90380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90381       };
90382     } catch (std::exception& e) {
90383       {
90384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90385       };
90386     } catch (...) {
90387       {
90388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90389       };
90390     }
90391   }
90392 }
90393
90394
90395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
90396   unsigned int jresult ;
90397   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90398   bool result;
90399
90400   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90401   {
90402     try {
90403       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90404     } catch (std::out_of_range& e) {
90405       {
90406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90407       };
90408     } catch (std::exception& e) {
90409       {
90410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90411       };
90412     } catch (...) {
90413       {
90414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90415       };
90416     }
90417   }
90418   jresult = result;
90419   return jresult;
90420 }
90421
90422
90423 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
90424   unsigned long jresult ;
90425   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90426   std::size_t result;
90427
90428   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90429   {
90430     try {
90431       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90432     } catch (std::out_of_range& e) {
90433       {
90434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90435       };
90436     } catch (std::exception& e) {
90437       {
90438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90439       };
90440     } catch (...) {
90441       {
90442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90443       };
90444     }
90445   }
90446   jresult = (unsigned long)result;
90447   return jresult;
90448 }
90449
90450
90451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
90452   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90453   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90454
90455   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90456   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90457   {
90458     try {
90459       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
90460     } catch (std::out_of_range& e) {
90461       {
90462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90463       };
90464     } catch (std::exception& e) {
90465       {
90466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90467       };
90468     } catch (...) {
90469       {
90470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90471       };
90472     }
90473   }
90474 }
90475
90476
90477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
90478   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90479   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90480
90481   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90482   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90483   {
90484     try {
90485       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
90486     } catch (std::out_of_range& e) {
90487       {
90488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90489       };
90490     } catch (std::exception& e) {
90491       {
90492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90493       };
90494     } catch (...) {
90495       {
90496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90497       };
90498     }
90499   }
90500 }
90501
90502
90503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
90504   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90505   Dali::Toolkit::TextEditor arg2 ;
90506   Dali::Toolkit::TextEditor *argp2 ;
90507
90508   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90509   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
90510   if (!argp2) {
90511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
90512     return ;
90513   }
90514   arg2 = *argp2;
90515   {
90516     try {
90517       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
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 void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
90536   void * jresult ;
90537   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
90538
90539   {
90540     try {
90541       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
90542     } catch (std::out_of_range& e) {
90543       {
90544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90545       };
90546     } catch (std::exception& e) {
90547       {
90548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90549       };
90550     } catch (...) {
90551       {
90552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90553       };
90554     }
90555   }
90556   jresult = (void *)result;
90557   return jresult;
90558 }
90559
90560
90561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
90562   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90563
90564   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90565   {
90566     try {
90567       delete arg1;
90568     } catch (std::out_of_range& e) {
90569       {
90570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90571       };
90572     } catch (std::exception& e) {
90573       {
90574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90575       };
90576     } catch (...) {
90577       {
90578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90579       };
90580     }
90581   }
90582 }
90583
90584
90585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
90586   unsigned int jresult ;
90587   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90588   bool result;
90589
90590   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90591   {
90592     try {
90593       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90594     } catch (std::out_of_range& e) {
90595       {
90596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90597       };
90598     } catch (std::exception& e) {
90599       {
90600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90601       };
90602     } catch (...) {
90603       {
90604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90605       };
90606     }
90607   }
90608   jresult = result;
90609   return jresult;
90610 }
90611
90612
90613 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
90614   unsigned long jresult ;
90615   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90616   std::size_t result;
90617
90618   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90619   {
90620     try {
90621       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90622     } catch (std::out_of_range& e) {
90623       {
90624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90625       };
90626     } catch (std::exception& e) {
90627       {
90628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90629       };
90630     } catch (...) {
90631       {
90632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90633       };
90634     }
90635   }
90636   jresult = (unsigned long)result;
90637   return jresult;
90638 }
90639
90640
90641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
90642   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90643   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90644
90645   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90646   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90647   {
90648     try {
90649       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
90650     } catch (std::out_of_range& e) {
90651       {
90652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90653       };
90654     } catch (std::exception& e) {
90655       {
90656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90657       };
90658     } catch (...) {
90659       {
90660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90661       };
90662     }
90663   }
90664 }
90665
90666
90667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
90668   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90669   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90670
90671   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90672   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90673   {
90674     try {
90675       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
90676     } catch (std::out_of_range& e) {
90677       {
90678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90679       };
90680     } catch (std::exception& e) {
90681       {
90682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90683       };
90684     } catch (...) {
90685       {
90686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90687       };
90688     }
90689   }
90690 }
90691
90692
90693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
90694   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90695   Dali::Toolkit::TextField arg2 ;
90696   Dali::Toolkit::TextField *argp2 ;
90697
90698   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90699   argp2 = (Dali::Toolkit::TextField *)jarg2;
90700   if (!argp2) {
90701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
90702     return ;
90703   }
90704   arg2 = *argp2;
90705   {
90706     try {
90707       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
90708     } catch (std::out_of_range& e) {
90709       {
90710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90711       };
90712     } catch (std::exception& e) {
90713       {
90714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90715       };
90716     } catch (...) {
90717       {
90718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90719       };
90720     }
90721   }
90722 }
90723
90724
90725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
90726   void * jresult ;
90727   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
90728
90729   {
90730     try {
90731       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
90732     } catch (std::out_of_range& e) {
90733       {
90734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90735       };
90736     } catch (std::exception& e) {
90737       {
90738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90739       };
90740     } catch (...) {
90741       {
90742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90743       };
90744     }
90745   }
90746   jresult = (void *)result;
90747   return jresult;
90748 }
90749
90750
90751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
90752   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90753
90754   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90755   {
90756     try {
90757       delete arg1;
90758     } catch (std::out_of_range& e) {
90759       {
90760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90761       };
90762     } catch (std::exception& e) {
90763       {
90764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90765       };
90766     } catch (...) {
90767       {
90768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90769       };
90770     }
90771   }
90772 }
90773
90774
90775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
90776   unsigned int jresult ;
90777   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90778   bool result;
90779
90780   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90781   {
90782     try {
90783       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);
90784     } catch (std::out_of_range& e) {
90785       {
90786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90787       };
90788     } catch (std::exception& e) {
90789       {
90790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90791       };
90792     } catch (...) {
90793       {
90794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90795       };
90796     }
90797   }
90798   jresult = result;
90799   return jresult;
90800 }
90801
90802
90803 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
90804   unsigned long jresult ;
90805   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90806   std::size_t result;
90807
90808   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90809   {
90810     try {
90811       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);
90812     } catch (std::out_of_range& e) {
90813       {
90814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90815       };
90816     } catch (std::exception& e) {
90817       {
90818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90819       };
90820     } catch (...) {
90821       {
90822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90823       };
90824     }
90825   }
90826   jresult = (unsigned long)result;
90827   return jresult;
90828 }
90829
90830
90831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
90832   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90833   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90834
90835   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90836   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90837   {
90838     try {
90839       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90840     } catch (std::out_of_range& e) {
90841       {
90842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90843       };
90844     } catch (std::exception& e) {
90845       {
90846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90847       };
90848     } catch (...) {
90849       {
90850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90851       };
90852     }
90853   }
90854 }
90855
90856
90857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
90858   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90859   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90860
90861   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90862   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90863   {
90864     try {
90865       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90866     } catch (std::out_of_range& e) {
90867       {
90868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90869       };
90870     } catch (std::exception& e) {
90871       {
90872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90873       };
90874     } catch (...) {
90875       {
90876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90877       };
90878     }
90879   }
90880 }
90881
90882
90883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90884   unsigned int jresult ;
90885   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90886   Dali::Toolkit::Control arg2 ;
90887   Dali::KeyEvent *arg3 = 0 ;
90888   Dali::Toolkit::Control *argp2 ;
90889   bool result;
90890
90891   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90892   argp2 = (Dali::Toolkit::Control *)jarg2;
90893   if (!argp2) {
90894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
90895     return 0;
90896   }
90897   arg2 = *argp2;
90898   arg3 = (Dali::KeyEvent *)jarg3;
90899   if (!arg3) {
90900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
90901     return 0;
90902   }
90903   {
90904     try {
90905       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);
90906     } catch (std::out_of_range& e) {
90907       {
90908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90909       };
90910     } catch (std::exception& e) {
90911       {
90912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90913       };
90914     } catch (...) {
90915       {
90916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90917       };
90918     }
90919   }
90920   jresult = result;
90921   return jresult;
90922 }
90923
90924
90925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
90926   void * jresult ;
90927   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
90928
90929   {
90930     try {
90931       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
90932     } catch (std::out_of_range& e) {
90933       {
90934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90935       };
90936     } catch (std::exception& e) {
90937       {
90938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90939       };
90940     } catch (...) {
90941       {
90942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90943       };
90944     }
90945   }
90946   jresult = (void *)result;
90947   return jresult;
90948 }
90949
90950
90951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
90952   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90953
90954   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90955   {
90956     try {
90957       delete arg1;
90958     } catch (std::out_of_range& e) {
90959       {
90960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90961       };
90962     } catch (std::exception& e) {
90963       {
90964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90965       };
90966     } catch (...) {
90967       {
90968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90969       };
90970     }
90971   }
90972 }
90973
90974
90975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
90976   unsigned int jresult ;
90977   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90978   bool result;
90979
90980   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90981   {
90982     try {
90983       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
90984     } catch (std::out_of_range& e) {
90985       {
90986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90987       };
90988     } catch (std::exception& e) {
90989       {
90990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90991       };
90992     } catch (...) {
90993       {
90994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90995       };
90996     }
90997   }
90998   jresult = result;
90999   return jresult;
91000 }
91001
91002
91003 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
91004   unsigned long jresult ;
91005   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91006   std::size_t result;
91007
91008   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91009   {
91010     try {
91011       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91012     } catch (std::out_of_range& e) {
91013       {
91014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91015       };
91016     } catch (std::exception& e) {
91017       {
91018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91019       };
91020     } catch (...) {
91021       {
91022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91023       };
91024     }
91025   }
91026   jresult = (unsigned long)result;
91027   return jresult;
91028 }
91029
91030
91031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
91032   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91033   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91034
91035   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91036   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91037   {
91038     try {
91039       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,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_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
91058   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91059   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91060
91061   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91062   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91063   {
91064     try {
91065       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
91066     } catch (std::out_of_range& e) {
91067       {
91068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91069       };
91070     } catch (std::exception& e) {
91071       {
91072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91073       };
91074     } catch (...) {
91075       {
91076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91077       };
91078     }
91079   }
91080 }
91081
91082
91083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
91084   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91085   Dali::Toolkit::Control arg2 ;
91086   Dali::Toolkit::Control *argp2 ;
91087
91088   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91089   argp2 = (Dali::Toolkit::Control *)jarg2;
91090   if (!argp2) {
91091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91092     return ;
91093   }
91094   arg2 = *argp2;
91095   {
91096     try {
91097       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
91098     } catch (std::out_of_range& e) {
91099       {
91100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91101       };
91102     } catch (std::exception& e) {
91103       {
91104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91105       };
91106     } catch (...) {
91107       {
91108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91109       };
91110     }
91111   }
91112 }
91113
91114
91115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
91116   void * jresult ;
91117   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
91118
91119   {
91120     try {
91121       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
91122     } catch (std::out_of_range& e) {
91123       {
91124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91125       };
91126     } catch (std::exception& e) {
91127       {
91128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91129       };
91130     } catch (...) {
91131       {
91132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91133       };
91134     }
91135   }
91136   jresult = (void *)result;
91137   return jresult;
91138 }
91139
91140
91141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
91142   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91143
91144   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91145   {
91146     try {
91147       delete arg1;
91148     } catch (std::out_of_range& e) {
91149       {
91150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91151       };
91152     } catch (std::exception& e) {
91153       {
91154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91155       };
91156     } catch (...) {
91157       {
91158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91159       };
91160     }
91161   }
91162 }
91163
91164
91165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
91166   unsigned int jresult ;
91167   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91168   bool result;
91169
91170   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91171   {
91172     try {
91173       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91174     } catch (std::out_of_range& e) {
91175       {
91176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91177       };
91178     } catch (std::exception& e) {
91179       {
91180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91181       };
91182     } catch (...) {
91183       {
91184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91185       };
91186     }
91187   }
91188   jresult = result;
91189   return jresult;
91190 }
91191
91192
91193 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
91194   unsigned long jresult ;
91195   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91196   std::size_t result;
91197
91198   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91199   {
91200     try {
91201       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91202     } catch (std::out_of_range& e) {
91203       {
91204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91205       };
91206     } catch (std::exception& e) {
91207       {
91208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91209       };
91210     } catch (...) {
91211       {
91212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91213       };
91214     }
91215   }
91216   jresult = (unsigned long)result;
91217   return jresult;
91218 }
91219
91220
91221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
91222   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91223   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91224
91225   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91226   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91227   {
91228     try {
91229       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
91230     } catch (std::out_of_range& e) {
91231       {
91232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91233       };
91234     } catch (std::exception& e) {
91235       {
91236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91237       };
91238     } catch (...) {
91239       {
91240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91241       };
91242     }
91243   }
91244 }
91245
91246
91247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
91248   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91249   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91250
91251   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91252   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91253   {
91254     try {
91255       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
91256     } catch (std::out_of_range& e) {
91257       {
91258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91259       };
91260     } catch (std::exception& e) {
91261       {
91262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91263       };
91264     } catch (...) {
91265       {
91266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91267       };
91268     }
91269   }
91270 }
91271
91272
91273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
91274   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91275   Dali::Toolkit::VideoView *arg2 = 0 ;
91276
91277   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91278   arg2 = (Dali::Toolkit::VideoView *)jarg2;
91279   if (!arg2) {
91280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
91281     return ;
91282   }
91283   {
91284     try {
91285       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
91286     } catch (std::out_of_range& e) {
91287       {
91288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91289       };
91290     } catch (std::exception& e) {
91291       {
91292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91293       };
91294     } catch (...) {
91295       {
91296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91297       };
91298     }
91299   }
91300 }
91301
91302
91303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
91304   void * jresult ;
91305   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
91306
91307   {
91308     try {
91309       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
91310     } catch (std::out_of_range& e) {
91311       {
91312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91313       };
91314     } catch (std::exception& e) {
91315       {
91316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91317       };
91318     } catch (...) {
91319       {
91320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91321       };
91322     }
91323   }
91324   jresult = (void *)result;
91325   return jresult;
91326 }
91327
91328
91329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
91330   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91331
91332   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91333   {
91334     try {
91335       delete arg1;
91336     } catch (std::out_of_range& e) {
91337       {
91338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91339       };
91340     } catch (std::exception& e) {
91341       {
91342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91343       };
91344     } catch (...) {
91345       {
91346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91347       };
91348     }
91349   }
91350 }
91351
91352
91353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
91354   unsigned int jresult ;
91355   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91356   bool result;
91357
91358   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91359   {
91360     try {
91361       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91362     } catch (std::out_of_range& e) {
91363       {
91364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91365       };
91366     } catch (std::exception& e) {
91367       {
91368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91369       };
91370     } catch (...) {
91371       {
91372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91373       };
91374     }
91375   }
91376   jresult = result;
91377   return jresult;
91378 }
91379
91380
91381 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
91382   unsigned long jresult ;
91383   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91384   std::size_t result;
91385
91386   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91387   {
91388     try {
91389       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91390     } catch (std::out_of_range& e) {
91391       {
91392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91393       };
91394     } catch (std::exception& e) {
91395       {
91396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91397       };
91398     } catch (...) {
91399       {
91400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91401       };
91402     }
91403   }
91404   jresult = (unsigned long)result;
91405   return jresult;
91406 }
91407
91408
91409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91410   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91411   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91412
91413   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91414   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91415   {
91416     try {
91417       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(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_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91436   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91437   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91438
91439   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91440   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91441   {
91442     try {
91443       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91444     } catch (std::out_of_range& e) {
91445       {
91446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91447       };
91448     } catch (std::exception& e) {
91449       {
91450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91451       };
91452     } catch (...) {
91453       {
91454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91455       };
91456     }
91457   }
91458 }
91459
91460
91461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
91462   unsigned int jresult ;
91463   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91464   Dali::Toolkit::Slider arg2 ;
91465   float arg3 ;
91466   Dali::Toolkit::Slider *argp2 ;
91467   bool result;
91468
91469   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91470   argp2 = (Dali::Toolkit::Slider *)jarg2;
91471   if (!argp2) {
91472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91473     return 0;
91474   }
91475   arg2 = *argp2;
91476   arg3 = (float)jarg3;
91477   {
91478     try {
91479       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
91480     } catch (std::out_of_range& e) {
91481       {
91482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91483       };
91484     } catch (std::exception& e) {
91485       {
91486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91487       };
91488     } catch (...) {
91489       {
91490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91491       };
91492     }
91493   }
91494   jresult = result;
91495   return jresult;
91496 }
91497
91498
91499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
91500   void * jresult ;
91501   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
91502
91503   {
91504     try {
91505       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
91506     } catch (std::out_of_range& e) {
91507       {
91508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91509       };
91510     } catch (std::exception& e) {
91511       {
91512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91513       };
91514     } catch (...) {
91515       {
91516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91517       };
91518     }
91519   }
91520   jresult = (void *)result;
91521   return jresult;
91522 }
91523
91524
91525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
91526   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91527
91528   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91529   {
91530     try {
91531       delete arg1;
91532     } catch (std::out_of_range& e) {
91533       {
91534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91535       };
91536     } catch (std::exception& e) {
91537       {
91538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91539       };
91540     } catch (...) {
91541       {
91542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91543       };
91544     }
91545   }
91546 }
91547
91548
91549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
91550   unsigned int jresult ;
91551   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91552   bool result;
91553
91554   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91555   {
91556     try {
91557       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91558     } catch (std::out_of_range& e) {
91559       {
91560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91561       };
91562     } catch (std::exception& e) {
91563       {
91564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91565       };
91566     } catch (...) {
91567       {
91568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91569       };
91570     }
91571   }
91572   jresult = result;
91573   return jresult;
91574 }
91575
91576
91577 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
91578   unsigned long jresult ;
91579   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91580   std::size_t result;
91581
91582   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91583   {
91584     try {
91585       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91586     } catch (std::out_of_range& e) {
91587       {
91588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91589       };
91590     } catch (std::exception& e) {
91591       {
91592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91593       };
91594     } catch (...) {
91595       {
91596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91597       };
91598     }
91599   }
91600   jresult = (unsigned long)result;
91601   return jresult;
91602 }
91603
91604
91605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
91606   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91607   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91608
91609   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91610   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91611   {
91612     try {
91613       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
91614     } catch (std::out_of_range& e) {
91615       {
91616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91617       };
91618     } catch (std::exception& e) {
91619       {
91620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91621       };
91622     } catch (...) {
91623       {
91624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91625       };
91626     }
91627   }
91628 }
91629
91630
91631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
91632   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91633   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91634
91635   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91636   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91637   {
91638     try {
91639       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
91640     } catch (std::out_of_range& e) {
91641       {
91642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91643       };
91644     } catch (std::exception& e) {
91645       {
91646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91647       };
91648     } catch (...) {
91649       {
91650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91651       };
91652     }
91653   }
91654 }
91655
91656
91657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91658   unsigned int jresult ;
91659   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91660   Dali::Toolkit::Slider arg2 ;
91661   int arg3 ;
91662   Dali::Toolkit::Slider *argp2 ;
91663   bool result;
91664
91665   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91666   argp2 = (Dali::Toolkit::Slider *)jarg2;
91667   if (!argp2) {
91668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91669     return 0;
91670   }
91671   arg2 = *argp2;
91672   arg3 = (int)jarg3;
91673   {
91674     try {
91675       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
91676     } catch (std::out_of_range& e) {
91677       {
91678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91679       };
91680     } catch (std::exception& e) {
91681       {
91682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91683       };
91684     } catch (...) {
91685       {
91686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91687       };
91688     }
91689   }
91690   jresult = result;
91691   return jresult;
91692 }
91693
91694
91695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
91696   void * jresult ;
91697   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
91698
91699   {
91700     try {
91701       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
91702     } catch (std::out_of_range& e) {
91703       {
91704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91705       };
91706     } catch (std::exception& e) {
91707       {
91708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91709       };
91710     } catch (...) {
91711       {
91712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91713       };
91714     }
91715   }
91716   jresult = (void *)result;
91717   return jresult;
91718 }
91719
91720
91721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
91722   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91723
91724   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91725   {
91726     try {
91727       delete arg1;
91728     } catch (std::out_of_range& e) {
91729       {
91730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91731       };
91732     } catch (std::exception& e) {
91733       {
91734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91735       };
91736     } catch (...) {
91737       {
91738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91739       };
91740     }
91741   }
91742 }
91743
91744
91745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
91746   void * jresult ;
91747   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91748
91749   {
91750     try {
91751       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
91752     } catch (std::out_of_range& e) {
91753       {
91754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91755       };
91756     } catch (std::exception& e) {
91757       {
91758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91759       };
91760     } catch (...) {
91761       {
91762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91763       };
91764     }
91765   }
91766   jresult = (void *)result;
91767   return jresult;
91768 }
91769
91770
91771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
91772   void * jresult ;
91773   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
91774   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91775
91776   arg1 = (Dali::Toolkit::Ruler *)jarg1;
91777   {
91778     try {
91779       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
91780     } catch (std::out_of_range& e) {
91781       {
91782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91783       };
91784     } catch (std::exception& e) {
91785       {
91786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91787       };
91788     } catch (...) {
91789       {
91790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91791       };
91792     }
91793   }
91794   jresult = (void *)result;
91795   return jresult;
91796 }
91797
91798
91799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
91800   void * jresult ;
91801   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
91802   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91803
91804   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91805   if (!arg1) {
91806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91807     return 0;
91808   }
91809   {
91810     try {
91811       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
91812     } catch (std::out_of_range& e) {
91813       {
91814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91815       };
91816     } catch (std::exception& e) {
91817       {
91818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91819       };
91820     } catch (...) {
91821       {
91822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91823       };
91824     }
91825   }
91826   jresult = (void *)result;
91827   return jresult;
91828 }
91829
91830
91831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
91832   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91833
91834   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91835   {
91836     try {
91837       delete arg1;
91838     } catch (std::out_of_range& e) {
91839       {
91840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91841       };
91842     } catch (std::exception& e) {
91843       {
91844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91845       };
91846     } catch (...) {
91847       {
91848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91849       };
91850     }
91851   }
91852 }
91853
91854
91855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
91856   void * jresult ;
91857   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91858   Dali::Toolkit::Ruler *result = 0 ;
91859
91860   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91861   {
91862     try {
91863       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
91864     } catch (std::out_of_range& e) {
91865       {
91866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91867       };
91868     } catch (std::exception& e) {
91869       {
91870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91871       };
91872     } catch (...) {
91873       {
91874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91875       };
91876     }
91877   }
91878   jresult = (void *)result;
91879   return jresult;
91880 }
91881
91882
91883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
91884   void * jresult ;
91885   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91886   Dali::Toolkit::Ruler *result = 0 ;
91887
91888   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91889   {
91890     try {
91891       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
91892     } catch (std::out_of_range& e) {
91893       {
91894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91895       };
91896     } catch (std::exception& e) {
91897       {
91898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91899       };
91900     } catch (...) {
91901       {
91902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91903       };
91904     }
91905   }
91906   jresult = (void *)result;
91907   return jresult;
91908 }
91909
91910
91911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
91912   void * jresult ;
91913   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91914   Dali::Toolkit::Ruler *result = 0 ;
91915
91916   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91917   {
91918     try {
91919       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
91920     } catch (std::out_of_range& e) {
91921       {
91922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91923       };
91924     } catch (std::exception& e) {
91925       {
91926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91927       };
91928     } catch (...) {
91929       {
91930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91931       };
91932     }
91933   }
91934   jresult = (void *)result;
91935   return jresult;
91936 }
91937
91938
91939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
91940   void * jresult ;
91941   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91942   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
91943   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91944
91945   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91946   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
91947   if (!arg2) {
91948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91949     return 0;
91950   }
91951   {
91952     try {
91953       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
91954     } catch (std::out_of_range& e) {
91955       {
91956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91957       };
91958     } catch (std::exception& e) {
91959       {
91960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91961       };
91962     } catch (...) {
91963       {
91964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91965       };
91966     }
91967   }
91968   jresult = (void *)result;
91969   return jresult;
91970 }
91971
91972
91973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
91974   void * jresult ;
91975   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91976   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
91977   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91978
91979   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91980   arg2 = (Dali::Toolkit::Ruler *)jarg2;
91981   {
91982     try {
91983       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
91984     } catch (std::out_of_range& e) {
91985       {
91986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91987       };
91988     } catch (std::exception& e) {
91989       {
91990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91991       };
91992     } catch (...) {
91993       {
91994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91995       };
91996     }
91997   }
91998   jresult = (void *)result;
91999   return jresult;
92000 }
92001
92002
92003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
92004   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92005
92006   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92007   {
92008     try {
92009       (arg1)->Reset();
92010     } catch (std::out_of_range& e) {
92011       {
92012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92013       };
92014     } catch (std::exception& e) {
92015       {
92016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92017       };
92018     } catch (...) {
92019       {
92020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92021       };
92022     }
92023   }
92024 }
92025
92026
92027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
92028   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92029   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92030
92031   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92032   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92033   {
92034     try {
92035       (arg1)->Reset(arg2);
92036     } catch (std::out_of_range& e) {
92037       {
92038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92039       };
92040     } catch (std::exception& e) {
92041       {
92042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92043       };
92044     } catch (...) {
92045       {
92046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92047       };
92048     }
92049   }
92050 }
92051
92052
92053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
92054   void * jresult ;
92055   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92056   Dali::Toolkit::Ruler *result = 0 ;
92057
92058   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92059   {
92060     try {
92061       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
92062     } catch (std::out_of_range& e) {
92063       {
92064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92065       };
92066     } catch (std::exception& e) {
92067       {
92068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92069       };
92070     } catch (...) {
92071       {
92072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92073       };
92074     }
92075   }
92076   jresult = (void *)result;
92077   return jresult;
92078 }
92079
92080
92081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
92082   float jresult ;
92083   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92084   float arg2 ;
92085   float arg3 ;
92086   float result;
92087
92088   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92089   arg2 = (float)jarg2;
92090   arg3 = (float)jarg3;
92091   {
92092     try {
92093       result = (float)(*arg1)->Snap(arg2,arg3);
92094     } catch (std::out_of_range& e) {
92095       {
92096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92097       };
92098     } catch (std::exception& e) {
92099       {
92100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92101       };
92102     } catch (...) {
92103       {
92104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92105       };
92106     }
92107   }
92108   jresult = result;
92109   return jresult;
92110 }
92111
92112
92113 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
92114   float jresult ;
92115   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92116   float arg2 ;
92117   float result;
92118
92119   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92120   arg2 = (float)jarg2;
92121   {
92122     try {
92123       result = (float)(*arg1)->Snap(arg2);
92124     } catch (std::out_of_range& e) {
92125       {
92126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92127       };
92128     } catch (std::exception& e) {
92129       {
92130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92131       };
92132     } catch (...) {
92133       {
92134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92135       };
92136     }
92137   }
92138   jresult = result;
92139   return jresult;
92140 }
92141
92142
92143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
92144   float jresult ;
92145   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92146   unsigned int arg2 ;
92147   unsigned int *arg3 = 0 ;
92148   bool arg4 ;
92149   float result;
92150
92151   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92152   arg2 = (unsigned int)jarg2;
92153   arg3 = (unsigned int *)jarg3;
92154   arg4 = jarg4 ? true : false;
92155   {
92156     try {
92157       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
92158     } catch (std::out_of_range& e) {
92159       {
92160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92161       };
92162     } catch (std::exception& e) {
92163       {
92164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92165       };
92166     } catch (...) {
92167       {
92168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92169       };
92170     }
92171   }
92172   jresult = result;
92173   return jresult;
92174 }
92175
92176
92177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
92178   unsigned int jresult ;
92179   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92180   float arg2 ;
92181   bool arg3 ;
92182   unsigned int result;
92183
92184   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92185   arg2 = (float)jarg2;
92186   arg3 = jarg3 ? true : false;
92187   {
92188     try {
92189       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
92190     } catch (std::out_of_range& e) {
92191       {
92192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92193       };
92194     } catch (std::exception& e) {
92195       {
92196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92197       };
92198     } catch (...) {
92199       {
92200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92201       };
92202     }
92203   }
92204   jresult = result;
92205   return jresult;
92206 }
92207
92208
92209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
92210   unsigned int jresult ;
92211   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92212   unsigned int result;
92213
92214   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92215   {
92216     try {
92217       result = (unsigned int)(*arg1)->GetTotalPages();
92218     } catch (std::out_of_range& e) {
92219       {
92220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92221       };
92222     } catch (std::exception& e) {
92223       {
92224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92225       };
92226     } catch (...) {
92227       {
92228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92229       };
92230     }
92231   }
92232   jresult = result;
92233   return jresult;
92234 }
92235
92236
92237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
92238   int jresult ;
92239   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92240   Dali::Toolkit::Ruler::RulerType result;
92241
92242   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92243   {
92244     try {
92245       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
92246     } catch (std::out_of_range& e) {
92247       {
92248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92249       };
92250     } catch (std::exception& e) {
92251       {
92252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92253       };
92254     } catch (...) {
92255       {
92256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92257       };
92258     }
92259   }
92260   jresult = (int)result;
92261   return jresult;
92262 }
92263
92264
92265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
92266   unsigned int jresult ;
92267   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92268   bool result;
92269
92270   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92271   {
92272     try {
92273       result = (bool)(*arg1)->IsEnabled();
92274     } catch (std::out_of_range& e) {
92275       {
92276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92277       };
92278     } catch (std::exception& e) {
92279       {
92280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92281       };
92282     } catch (...) {
92283       {
92284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92285       };
92286     }
92287   }
92288   jresult = result;
92289   return jresult;
92290 }
92291
92292
92293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
92294   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92295
92296   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92297   {
92298     try {
92299       (*arg1)->Enable();
92300     } catch (std::out_of_range& e) {
92301       {
92302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92303       };
92304     } catch (std::exception& e) {
92305       {
92306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92307       };
92308     } catch (...) {
92309       {
92310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92311       };
92312     }
92313   }
92314 }
92315
92316
92317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
92318   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92319
92320   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92321   {
92322     try {
92323       (*arg1)->Disable();
92324     } catch (std::out_of_range& e) {
92325       {
92326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92327       };
92328     } catch (std::exception& e) {
92329       {
92330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92331       };
92332     } catch (...) {
92333       {
92334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92335       };
92336     }
92337   }
92338 }
92339
92340
92341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
92342   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92343   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
92344   Dali::Toolkit::RulerDomain *argp2 ;
92345
92346   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92347   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
92348   if (!argp2) {
92349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
92350     return ;
92351   }
92352   arg2 = *argp2;
92353   {
92354     try {
92355       (*arg1)->SetDomain(arg2);
92356     } catch (std::out_of_range& e) {
92357       {
92358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92359       };
92360     } catch (std::exception& e) {
92361       {
92362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92363       };
92364     } catch (...) {
92365       {
92366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92367       };
92368     }
92369   }
92370 }
92371
92372
92373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
92374   void * jresult ;
92375   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92376   Dali::Toolkit::RulerDomain *result = 0 ;
92377
92378   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92379   {
92380     try {
92381       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
92382     } catch (std::out_of_range& e) {
92383       {
92384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92385       };
92386     } catch (std::exception& e) {
92387       {
92388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92389       };
92390     } catch (...) {
92391       {
92392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92393       };
92394     }
92395   }
92396   jresult = (void *)result;
92397   return jresult;
92398 }
92399
92400
92401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
92402   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92403
92404   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92405   {
92406     try {
92407       (*arg1)->DisableDomain();
92408     } catch (std::out_of_range& e) {
92409       {
92410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92411       };
92412     } catch (std::exception& e) {
92413       {
92414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92415       };
92416     } catch (...) {
92417       {
92418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92419       };
92420     }
92421   }
92422 }
92423
92424
92425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
92426   float jresult ;
92427   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92428   float arg2 ;
92429   float arg3 ;
92430   float arg4 ;
92431   float result;
92432
92433   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92434   arg2 = (float)jarg2;
92435   arg3 = (float)jarg3;
92436   arg4 = (float)jarg4;
92437   {
92438     try {
92439       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
92440     } catch (std::out_of_range& e) {
92441       {
92442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92443       };
92444     } catch (std::exception& e) {
92445       {
92446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92447       };
92448     } catch (...) {
92449       {
92450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92451       };
92452     }
92453   }
92454   jresult = result;
92455   return jresult;
92456 }
92457
92458
92459 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
92460   float jresult ;
92461   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92462   float arg2 ;
92463   float arg3 ;
92464   float result;
92465
92466   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92467   arg2 = (float)jarg2;
92468   arg3 = (float)jarg3;
92469   {
92470     try {
92471       result = (float)(*arg1)->Clamp(arg2,arg3);
92472     } catch (std::out_of_range& e) {
92473       {
92474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92475       };
92476     } catch (std::exception& e) {
92477       {
92478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92479       };
92480     } catch (...) {
92481       {
92482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92483       };
92484     }
92485   }
92486   jresult = result;
92487   return jresult;
92488 }
92489
92490
92491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
92492   float jresult ;
92493   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92494   float arg2 ;
92495   float result;
92496
92497   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92498   arg2 = (float)jarg2;
92499   {
92500     try {
92501       result = (float)(*arg1)->Clamp(arg2);
92502     } catch (std::out_of_range& e) {
92503       {
92504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92505       };
92506     } catch (std::exception& e) {
92507       {
92508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92509       };
92510     } catch (...) {
92511       {
92512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92513       };
92514     }
92515   }
92516   jresult = result;
92517   return jresult;
92518 }
92519
92520
92521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
92522   float jresult ;
92523   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92524   float arg2 ;
92525   float arg3 ;
92526   float arg4 ;
92527   Dali::Toolkit::ClampState *arg5 = 0 ;
92528   float result;
92529
92530   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92531   arg2 = (float)jarg2;
92532   arg3 = (float)jarg3;
92533   arg4 = (float)jarg4;
92534   arg5 = (Dali::Toolkit::ClampState *)jarg5;
92535   if (!arg5) {
92536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92537     return 0;
92538   }
92539   {
92540     try {
92541       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
92542     } catch (std::out_of_range& e) {
92543       {
92544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92545       };
92546     } catch (std::exception& e) {
92547       {
92548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92549       };
92550     } catch (...) {
92551       {
92552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92553       };
92554     }
92555   }
92556   jresult = result;
92557   return jresult;
92558 }
92559
92560
92561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
92562   float jresult ;
92563   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92564   float arg2 ;
92565   float arg3 ;
92566   float arg4 ;
92567   float arg5 ;
92568   float result;
92569
92570   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92571   arg2 = (float)jarg2;
92572   arg3 = (float)jarg3;
92573   arg4 = (float)jarg4;
92574   arg5 = (float)jarg5;
92575   {
92576     try {
92577       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
92578     } catch (std::out_of_range& e) {
92579       {
92580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92581       };
92582     } catch (std::exception& e) {
92583       {
92584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92585       };
92586     } catch (...) {
92587       {
92588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92589       };
92590     }
92591   }
92592   jresult = result;
92593   return jresult;
92594 }
92595
92596
92597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
92598   float jresult ;
92599   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92600   float arg2 ;
92601   float arg3 ;
92602   float arg4 ;
92603   float result;
92604
92605   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92606   arg2 = (float)jarg2;
92607   arg3 = (float)jarg3;
92608   arg4 = (float)jarg4;
92609   {
92610     try {
92611       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
92612     } catch (std::out_of_range& e) {
92613       {
92614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92615       };
92616     } catch (std::exception& e) {
92617       {
92618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92619       };
92620     } catch (...) {
92621       {
92622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92623       };
92624     }
92625   }
92626   jresult = result;
92627   return jresult;
92628 }
92629
92630
92631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
92632   float jresult ;
92633   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92634   float arg2 ;
92635   float arg3 ;
92636   float result;
92637
92638   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92639   arg2 = (float)jarg2;
92640   arg3 = (float)jarg3;
92641   {
92642     try {
92643       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
92644     } catch (std::out_of_range& e) {
92645       {
92646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92647       };
92648     } catch (std::exception& e) {
92649       {
92650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92651       };
92652     } catch (...) {
92653       {
92654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92655       };
92656     }
92657   }
92658   jresult = result;
92659   return jresult;
92660 }
92661
92662
92663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
92664   float jresult ;
92665   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92666   float arg2 ;
92667   float result;
92668
92669   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92670   arg2 = (float)jarg2;
92671   {
92672     try {
92673       result = (float)(*arg1)->SnapAndClamp(arg2);
92674     } catch (std::out_of_range& e) {
92675       {
92676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92677       };
92678     } catch (std::exception& e) {
92679       {
92680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92681       };
92682     } catch (...) {
92683       {
92684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92685       };
92686     }
92687   }
92688   jresult = result;
92689   return jresult;
92690 }
92691
92692
92693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
92694   float jresult ;
92695   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92696   float arg2 ;
92697   float arg3 ;
92698   float arg4 ;
92699   float arg5 ;
92700   Dali::Toolkit::ClampState *arg6 = 0 ;
92701   float result;
92702
92703   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92704   arg2 = (float)jarg2;
92705   arg3 = (float)jarg3;
92706   arg4 = (float)jarg4;
92707   arg5 = (float)jarg5;
92708   arg6 = (Dali::Toolkit::ClampState *)jarg6;
92709   if (!arg6) {
92710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92711     return 0;
92712   }
92713   {
92714     try {
92715       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
92716     } catch (std::out_of_range& e) {
92717       {
92718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92719       };
92720     } catch (std::exception& e) {
92721       {
92722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92723       };
92724     } catch (...) {
92725       {
92726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92727       };
92728     }
92729   }
92730   jresult = result;
92731   return jresult;
92732 }
92733
92734
92735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
92736   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92737
92738   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92739   {
92740     try {
92741       (*arg1)->Reference();
92742     } catch (std::out_of_range& e) {
92743       {
92744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92745       };
92746     } catch (std::exception& e) {
92747       {
92748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92749       };
92750     } catch (...) {
92751       {
92752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92753       };
92754     }
92755   }
92756 }
92757
92758
92759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
92760   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92761
92762   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92763   {
92764     try {
92765       (*arg1)->Unreference();
92766     } catch (std::out_of_range& e) {
92767       {
92768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92769       };
92770     } catch (std::exception& e) {
92771       {
92772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92773       };
92774     } catch (...) {
92775       {
92776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92777       };
92778     }
92779   }
92780 }
92781
92782
92783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
92784   int jresult ;
92785   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92786   int result;
92787
92788   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92789   {
92790     try {
92791       result = (int)(*arg1)->ReferenceCount();
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 = result;
92807   return jresult;
92808 }
92809
92810
92811 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
92812     return (Dali::RefObject *)jarg1;
92813 }
92814
92815 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
92816     return (Dali::SignalObserver *)jarg1;
92817 }
92818
92819 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
92820     return (Dali::ConnectionTrackerInterface *)jarg1;
92821 }
92822
92823 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
92824     return (Dali::BaseHandle *)jarg1;
92825 }
92826
92827 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
92828     return (Dali::BaseHandle *)jarg1;
92829 }
92830
92831 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
92832     return (Dali::BaseHandle *)jarg1;
92833 }
92834
92835 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
92836     return (Dali::BaseHandle *)jarg1;
92837 }
92838
92839 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
92840     return (Dali::BaseHandle *)jarg1;
92841 }
92842
92843 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
92844     return (Dali::BaseHandle *)jarg1;
92845 }
92846
92847 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
92848     return (Dali::BaseHandle *)jarg1;
92849 }
92850
92851 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
92852     return (Dali::BaseHandle *)jarg1;
92853 }
92854
92855 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
92856     return (Dali::BaseHandle *)jarg1;
92857 }
92858
92859 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
92860     return (Dali::BaseHandle *)jarg1;
92861 }
92862
92863 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
92864     return (Dali::BaseHandle *)jarg1;
92865 }
92866
92867 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
92868     return (Dali::BaseHandle *)jarg1;
92869 }
92870
92871 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
92872     return (Dali::BaseHandle *)jarg1;
92873 }
92874
92875 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
92876     return (Dali::Handle *)jarg1;
92877 }
92878
92879 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
92880     return (Dali::Handle *)jarg1;
92881 }
92882
92883 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
92884     return (Dali::BaseHandle *)jarg1;
92885 }
92886
92887 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
92888     return (Dali::BaseHandle *)jarg1;
92889 }
92890
92891 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
92892     return (Dali::Handle *)jarg1;
92893 }
92894
92895 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
92896     return (Dali::BaseHandle *)jarg1;
92897 }
92898
92899 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
92900     return (Dali::Handle *)jarg1;
92901 }
92902
92903 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
92904     return (Dali::GestureDetector *)jarg1;
92905 }
92906
92907 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
92908     return (Dali::Gesture *)jarg1;
92909 }
92910
92911 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
92912     return (Dali::Handle *)jarg1;
92913 }
92914
92915 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
92916     return (Dali::Actor *)jarg1;
92917 }
92918
92919 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
92920     return (Dali::BaseHandle *)jarg1;
92921 }
92922
92923 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
92924     return (Dali::RefObject *)jarg1;
92925 }
92926
92927 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
92928     return (Dali::Actor *)jarg1;
92929 }
92930
92931 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
92932     return (Dali::GestureDetector *)jarg1;
92933 }
92934
92935 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
92936     return (Dali::Gesture *)jarg1;
92937 }
92938
92939 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
92940     return (Dali::GestureDetector *)jarg1;
92941 }
92942
92943 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
92944     return (Dali::Gesture *)jarg1;
92945 }
92946
92947 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
92948     return (Dali::GestureDetector *)jarg1;
92949 }
92950
92951 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
92952     return (Dali::Gesture *)jarg1;
92953 }
92954
92955 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
92956     return (Dali::BaseHandle *)jarg1;
92957 }
92958
92959 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
92960     return (Dali::Handle *)jarg1;
92961 }
92962
92963 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
92964     return (Dali::BaseHandle *)jarg1;
92965 }
92966
92967 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
92968     return (Dali::Handle *)jarg1;
92969 }
92970
92971 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
92972     return (Dali::Handle *)jarg1;
92973 }
92974
92975 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
92976     return (Dali::Image *)jarg1;
92977 }
92978
92979 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
92980     return (Dali::Image *)jarg1;
92981 }
92982
92983 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
92984     return (Dali::Image *)jarg1;
92985 }
92986
92987 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
92988     return (Dali::RefObject *)jarg1;
92989 }
92990
92991 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
92992     return (Dali::Image *)jarg1;
92993 }
92994
92995 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
92996     return (Dali::Image *)jarg1;
92997 }
92998
92999 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
93000     return (Dali::ResourceImage *)jarg1;
93001 }
93002
93003 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
93004     return (Dali::Actor *)jarg1;
93005 }
93006
93007 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
93008     return (Dali::BaseHandle *)jarg1;
93009 }
93010
93011 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
93012     return (Dali::BaseHandle *)jarg1;
93013 }
93014
93015 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
93016     return (Dali::BaseHandle *)jarg1;
93017 }
93018
93019 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
93020     return (Dali::BaseHandle *)jarg1;
93021 }
93022
93023 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
93024     return (Dali::BaseHandle *)jarg1;
93025 }
93026
93027 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
93028     return (Dali::BaseHandle *)jarg1;
93029 }
93030
93031 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
93032     return (Dali::CustomActorImpl *)jarg1;
93033 }
93034
93035 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
93036     return (Dali::CustomActor *)jarg1;
93037 }
93038
93039 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
93040     return (Dali::BaseHandle *)jarg1;
93041 }
93042
93043 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
93044     return (Dali::Toolkit::Control *)jarg1;
93045 }
93046
93047 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
93048     return (Dali::Toolkit::Control *)jarg1;
93049 }
93050
93051 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
93052     return (Dali::Toolkit::Button *)jarg1;
93053 }
93054
93055 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
93056     return (Dali::Toolkit::Button *)jarg1;
93057 }
93058
93059 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
93060     return (Dali::Toolkit::Button *)jarg1;
93061 }
93062
93063 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
93064     return (Dali::Toolkit::Control *)jarg1;
93065 }
93066
93067 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
93068     return (Dali::Toolkit::Control *)jarg1;
93069 }
93070
93071 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
93072     return (Dali::Toolkit::Control *)jarg1;
93073 }
93074
93075 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
93076     return (Dali::Toolkit::Control *)jarg1;
93077 }
93078
93079 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
93080     return (Dali::Toolkit::Control *)jarg1;
93081 }
93082
93083 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
93084     return (Dali::RefObject *)jarg1;
93085 }
93086
93087 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
93088     return (Dali::Toolkit::Scrollable *)jarg1;
93089 }
93090
93091 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
93092     return (Dali::BaseHandle *)jarg1;
93093 }
93094
93095 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
93096     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
93097 }
93098
93099 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
93100     return (Dali::RefObject *)jarg1;
93101 }
93102
93103 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
93104     return (Dali::Toolkit::Ruler *)jarg1;
93105 }
93106
93107 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
93108     return (Dali::Toolkit::Ruler *)jarg1;
93109 }
93110
93111 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
93112     return (Dali::Toolkit::Scrollable *)jarg1;
93113 }
93114
93115 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
93116     return (Dali::Toolkit::Control *)jarg1;
93117 }
93118
93119 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
93120     return (Dali::Toolkit::Control *)jarg1;
93121 }
93122
93123 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
93124     return (Dali::Toolkit::Control *)jarg1;
93125 }
93126
93127 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
93128     return (Dali::Toolkit::Control *)jarg1;
93129 }
93130
93131 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
93132     return (Dali::BaseHandle *)jarg1;
93133 }
93134
93135 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
93136     return (Dali::BaseHandle *)jarg1;
93137 }
93138
93139 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
93140     return (Dali::Toolkit::Control *)jarg1;
93141 }
93142
93143 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
93144     return (Dali::Toolkit::Control *)jarg1;
93145 }
93146
93147 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
93148     return (Dali::Toolkit::Control *)jarg1;
93149 }
93150
93151 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
93152     return (Dali::Toolkit::Control *)jarg1;
93153 }
93154
93155 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
93156     return (Dali::Toolkit::Control *)jarg1;
93157 }
93158
93159 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
93160     return (Dali::Toolkit::Control *)jarg1;
93161 }
93162
93163 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
93164     return (Dali::Toolkit::PageTurnView *)jarg1;
93165 }
93166
93167 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
93168     return (Dali::Toolkit::PageTurnView *)jarg1;
93169 }
93170
93171 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
93172     return (Dali::Toolkit::Button *)jarg1;
93173 }
93174
93175 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
93176     return (Dali::BaseHandle *)jarg1;
93177 }
93178
93179 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
93180     return (Dali::BaseHandle *)jarg1;
93181 }
93182
93183 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
93184     return (Dali::BaseHandle *)jarg1;
93185 }
93186
93187 #ifdef __cplusplus
93188 }
93189 #endif
93190